diff --git a/api/openapi-spec/swagger.json b/api/openapi-spec/swagger.json
index bca25ef2b3c..5e13cd1e807 100644
--- a/api/openapi-spec/swagger.json
+++ b/api/openapi-spec/swagger.json
@@ -1514,9 +1514,13 @@
     "io.k8s.api.apps.v1.RollingUpdateDaemonSet": {
       "description": "Spec to control the desired behavior of daemon set rolling update.",
       "properties": {
+        "maxSurge": {
+          "$ref": "#/definitions/io.k8s.apimachinery.pkg.util.intstr.IntOrString",
+          "description": "The maximum number of nodes with an existing available DaemonSet pod that can have an updated DaemonSet pod during during an update. Value can be an absolute number (ex: 5) or a percentage of desired pods (ex: 10%). This can not be 0 if MaxUnavailable is 0. Absolute number is calculated from percentage by rounding up to a minimum of 1. Default value is 0. Example: when this is set to 30%, at most 30% of the total number of nodes that should be running the daemon pod (i.e. status.desiredNumberScheduled) can have their a new pod created before the old pod is marked as deleted. The update starts by launching new pods on 30% of nodes. Once an updated pod is available (Ready for at least minReadySeconds) the old DaemonSet pod on that node is marked deleted. If the old pod becomes unavailable for any reason (Ready transitions to false, is evicted, or is drained) an updated pod is immediatedly created on that node without considering surge limits. Allowing surge implies the possibility that the resources consumed by the daemonset on any given node can double if the readiness check fails, and so resource intensive daemonsets should take into account that they may cause evictions during disruption. This is an alpha field and requires enabling DaemonSetUpdateSurge feature gate."
+        },
         "maxUnavailable": {
           "$ref": "#/definitions/io.k8s.apimachinery.pkg.util.intstr.IntOrString",
-          "description": "The maximum number of DaemonSet pods that can be unavailable during the update. Value can be an absolute number (ex: 5) or a percentage of total number of DaemonSet pods at the start of the update (ex: 10%). Absolute number is calculated from percentage by rounding up. This cannot be 0. Default value is 1. Example: when this is set to 30%, at most 30% of the total number of nodes that should be running the daemon pod (i.e. status.desiredNumberScheduled) can have their pods stopped for an update at any given time. The update starts by stopping at most 30% of those DaemonSet pods and then brings up new DaemonSet pods in their place. Once the new pods are available, it then proceeds onto other DaemonSet pods, thus ensuring that at least 70% of original number of DaemonSet pods are available at all times during the update."
+          "description": "The maximum number of DaemonSet pods that can be unavailable during the update. Value can be an absolute number (ex: 5) or a percentage of total number of DaemonSet pods at the start of the update (ex: 10%). Absolute number is calculated from percentage by rounding down to a minimum of one. This cannot be 0 if MaxSurge is 0 Default value is 1. Example: when this is set to 30%, at most 30% of the total number of nodes that should be running the daemon pod (i.e. status.desiredNumberScheduled) can have their pods stopped for an update at any given time. The update starts by stopping at most 30% of those DaemonSet pods and then brings up new DaemonSet pods in their place. Once the new pods are available, it then proceeds onto other DaemonSet pods, thus ensuring that at least 70% of original number of DaemonSet pods are available at all times during the update."
         }
       },
       "type": "object"
diff --git a/pkg/apis/apps/fuzzer/fuzzer.go b/pkg/apis/apps/fuzzer/fuzzer.go
index 952dbe64dc9..5f7858560ba 100644
--- a/pkg/apis/apps/fuzzer/fuzzer.go
+++ b/pkg/apis/apps/fuzzer/fuzzer.go
@@ -118,11 +118,13 @@ var Funcs = func(codecs runtimeserializer.CodecFactory) []interface{} {
 				rollingUpdate := apps.RollingUpdateDaemonSet{}
 				if c.RandBool() {
 					if c.RandBool() {
-						rollingUpdate.MaxUnavailable = intstr.FromInt(1 + int(c.Rand.Int31()))
+						rollingUpdate.MaxUnavailable = intstr.FromInt(int(c.Rand.Int31()))
+						rollingUpdate.MaxSurge = intstr.FromInt(int(c.Rand.Int31()))
 					} else {
-						rollingUpdate.MaxUnavailable = intstr.FromString(fmt.Sprintf("%d%%", 1+c.Rand.Int31()))
+						rollingUpdate.MaxSurge = intstr.FromString(fmt.Sprintf("%d%%", c.Rand.Int31()))
 					}
 				}
+
 				j.RollingUpdate = &rollingUpdate
 			}
 		},
diff --git a/pkg/apis/apps/types.go b/pkg/apis/apps/types.go
index c42ea2b6215..6866540baf0 100644
--- a/pkg/apis/apps/types.go
+++ b/pkg/apis/apps/types.go
@@ -532,19 +532,41 @@ type RollingUpdateDaemonSet struct {
 	// The maximum number of DaemonSet pods that can be unavailable during the
 	// update. Value can be an absolute number (ex: 5) or a percentage of total
 	// number of DaemonSet pods at the start of the update (ex: 10%). Absolute
-	// number is calculated from percentage by rounding up.
-	// This cannot be 0.
+	// number is calculated from percentage by rounding down to a minimum of one.
+	// This cannot be 0 if MaxSurge is 0
 	// Default value is 1.
 	// Example: when this is set to 30%, at most 30% of the total number of nodes
 	// that should be running the daemon pod (i.e. status.desiredNumberScheduled)
-	// can have their pods stopped for an update at any given
-	// time. The update starts by stopping at most 30% of those DaemonSet pods
-	// and then brings up new DaemonSet pods in their place. Once the new pods
-	// are available, it then proceeds onto other DaemonSet pods, thus ensuring
-	// that at least 70% of original number of DaemonSet pods are available at
-	// all times during the update.
+	// can have their pods stopped for an update at any given time. The update
+	// starts by stopping at most 30% of those DaemonSet pods and then brings
+	// up new DaemonSet pods in their place. Once the new pods are available,
+	// it then proceeds onto other DaemonSet pods, thus ensuring that at least
+	// 70% of original number of DaemonSet pods are available at all times during
+	// the update.
 	// +optional
 	MaxUnavailable intstr.IntOrString
+
+	// The maximum number of nodes with an existing available DaemonSet pod that
+	// can have an updated DaemonSet pod during during an update.
+	// Value can be an absolute number (ex: 5) or a percentage of desired pods (ex: 10%).
+	// This can not be 0 if MaxUnavailable is 0.
+	// Absolute number is calculated from percentage by rounding up to a minimum of 1.
+	// Default value is 0.
+	// Example: when this is set to 30%, at most 30% of the total number of nodes
+	// that should be running the daemon pod (i.e. status.desiredNumberScheduled)
+	// can have their a new pod created before the old pod is marked as deleted.
+	// The update starts by launching new pods on 30% of nodes. Once an updated
+	// pod is available (Ready for at least minReadySeconds) the old DaemonSet pod
+	// on that node is marked deleted. If the old pod becomes unavailable for any
+	// reason (Ready transitions to false, is evicted, or is drained) an updated
+	// pod is immediatedly created on that node without considering surge limits.
+	// Allowing surge implies the possibility that the resources consumed by the
+	// daemonset on any given node can double if the readiness check fails, and
+	// so resource intensive daemonsets should take into account that they may
+	// cause evictions during disruption.
+	// This is an alpha field and requires enabling DaemonSetUpdateSurge feature gate.
+	// +optional
+	MaxSurge intstr.IntOrString
 }
 
 // DaemonSetSpec is the specification of a daemon set.
diff --git a/pkg/apis/apps/v1/conversion_test.go b/pkg/apis/apps/v1/conversion_test.go
index 0d6b08e58f7..72957afbc19 100644
--- a/pkg/apis/apps/v1/conversion_test.go
+++ b/pkg/apis/apps/v1/conversion_test.go
@@ -20,7 +20,7 @@ import (
 	"testing"
 
 	appsv1 "k8s.io/api/apps/v1"
-	"k8s.io/api/core/v1"
+	v1 "k8s.io/api/core/v1"
 	apiequality "k8s.io/apimachinery/pkg/api/equality"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/util/intstr"
@@ -226,13 +226,14 @@ func TestV1StatefulSetUpdateStrategyConversion(t *testing.T) {
 
 func TestV1RollingUpdateDaemonSetConversion(t *testing.T) {
 	intorstr := intstr.FromInt(1)
+	maxSurge := intstr.FromInt(0)
 	testcases := map[string]struct {
 		rollingUpdateDs1 *apps.RollingUpdateDaemonSet
 		rollingUpdateDs2 *appsv1.RollingUpdateDaemonSet
 	}{
 		"RollingUpdateDaemonSet Conversion 2": {
-			rollingUpdateDs1: &apps.RollingUpdateDaemonSet{MaxUnavailable: intorstr},
-			rollingUpdateDs2: &appsv1.RollingUpdateDaemonSet{MaxUnavailable: &intorstr},
+			rollingUpdateDs1: &apps.RollingUpdateDaemonSet{MaxUnavailable: intorstr, MaxSurge: maxSurge},
+			rollingUpdateDs2: &appsv1.RollingUpdateDaemonSet{MaxUnavailable: &intorstr, MaxSurge: &maxSurge},
 		},
 	}
 
diff --git a/pkg/apis/apps/v1/defaults.go b/pkg/apis/apps/v1/defaults.go
index 964c34d51be..8b3a0e9882e 100644
--- a/pkg/apis/apps/v1/defaults.go
+++ b/pkg/apis/apps/v1/defaults.go
@@ -84,6 +84,11 @@ func SetDefaults_DaemonSet(obj *appsv1.DaemonSet) {
 			maxUnavailable := intstr.FromInt(1)
 			updateStrategy.RollingUpdate.MaxUnavailable = &maxUnavailable
 		}
+		if updateStrategy.RollingUpdate.MaxSurge == nil {
+			// Set default MaxSurge as 0 by default.
+			maxSurge := intstr.FromInt(0)
+			updateStrategy.RollingUpdate.MaxSurge = &maxSurge
+		}
 	}
 	if obj.Spec.RevisionHistoryLimit == nil {
 		obj.Spec.RevisionHistoryLimit = new(int32)
diff --git a/pkg/apis/apps/v1/defaults_test.go b/pkg/apis/apps/v1/defaults_test.go
index 0d44bcef56a..b1d07d47e7f 100644
--- a/pkg/apis/apps/v1/defaults_test.go
+++ b/pkg/apis/apps/v1/defaults_test.go
@@ -21,7 +21,7 @@ import (
 	"testing"
 
 	appsv1 "k8s.io/api/apps/v1"
-	"k8s.io/api/core/v1"
+	v1 "k8s.io/api/core/v1"
 	apiequality "k8s.io/apimachinery/pkg/api/equality"
 	"k8s.io/apimachinery/pkg/api/resource"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -38,6 +38,7 @@ import (
 func TestSetDefaultDaemonSetSpec(t *testing.T) {
 	defaultLabels := map[string]string{"foo": "bar"}
 	maxUnavailable := intstr.FromInt(1)
+	maxSurge := intstr.FromInt(0)
 	period := int64(v1.DefaultTerminationGracePeriodSeconds)
 	defaultTemplate := v1.PodTemplateSpec{
 		Spec: v1.PodSpec{
@@ -80,6 +81,7 @@ func TestSetDefaultDaemonSetSpec(t *testing.T) {
 						Type: appsv1.RollingUpdateDaemonSetStrategyType,
 						RollingUpdate: &appsv1.RollingUpdateDaemonSet{
 							MaxUnavailable: &maxUnavailable,
+							MaxSurge:       &maxSurge,
 						},
 					},
 					RevisionHistoryLimit: utilpointer.Int32Ptr(10),
@@ -110,6 +112,7 @@ func TestSetDefaultDaemonSetSpec(t *testing.T) {
 						Type: appsv1.RollingUpdateDaemonSetStrategyType,
 						RollingUpdate: &appsv1.RollingUpdateDaemonSet{
 							MaxUnavailable: &maxUnavailable,
+							MaxSurge:       &maxSurge,
 						},
 					},
 					RevisionHistoryLimit: utilpointer.Int32Ptr(1),
@@ -146,6 +149,7 @@ func TestSetDefaultDaemonSetSpec(t *testing.T) {
 						Type: appsv1.RollingUpdateDaemonSetStrategyType,
 						RollingUpdate: &appsv1.RollingUpdateDaemonSet{
 							MaxUnavailable: &maxUnavailable,
+							MaxSurge:       &maxSurge,
 						},
 					},
 					RevisionHistoryLimit: utilpointer.Int32Ptr(10),
diff --git a/pkg/apis/apps/v1/zz_generated.conversion.go b/pkg/apis/apps/v1/zz_generated.conversion.go
index bc63ff526a7..78cc6d01ef0 100644
--- a/pkg/apis/apps/v1/zz_generated.conversion.go
+++ b/pkg/apis/apps/v1/zz_generated.conversion.go
@@ -971,6 +971,9 @@ func autoConvert_v1_RollingUpdateDaemonSet_To_apps_RollingUpdateDaemonSet(in *v1
 	if err := metav1.Convert_Pointer_intstr_IntOrString_To_intstr_IntOrString(&in.MaxUnavailable, &out.MaxUnavailable, s); err != nil {
 		return err
 	}
+	if err := metav1.Convert_Pointer_intstr_IntOrString_To_intstr_IntOrString(&in.MaxSurge, &out.MaxSurge, s); err != nil {
+		return err
+	}
 	return nil
 }
 
@@ -983,6 +986,9 @@ func autoConvert_apps_RollingUpdateDaemonSet_To_v1_RollingUpdateDaemonSet(in *ap
 	if err := metav1.Convert_intstr_IntOrString_To_Pointer_intstr_IntOrString(&in.MaxUnavailable, &out.MaxUnavailable, s); err != nil {
 		return err
 	}
+	if err := metav1.Convert_intstr_IntOrString_To_Pointer_intstr_IntOrString(&in.MaxSurge, &out.MaxSurge, s); err != nil {
+		return err
+	}
 	return nil
 }
 
diff --git a/pkg/apis/apps/v1beta2/conversion_test.go b/pkg/apis/apps/v1beta2/conversion_test.go
index f0f185c1f17..c7d8f9b34ec 100644
--- a/pkg/apis/apps/v1beta2/conversion_test.go
+++ b/pkg/apis/apps/v1beta2/conversion_test.go
@@ -20,7 +20,7 @@ import (
 	"testing"
 
 	"k8s.io/api/apps/v1beta2"
-	"k8s.io/api/core/v1"
+	v1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/util/intstr"
 	"k8s.io/kubernetes/pkg/api/legacyscheme"
 	"k8s.io/kubernetes/pkg/apis/apps"
@@ -153,13 +153,14 @@ func TestV1beta2StatefulSetUpdateStrategyConversion(t *testing.T) {
 
 func TestV1beta2RollingUpdateDaemonSetConversion(t *testing.T) {
 	intorstr := intstr.FromInt(1)
+	maxSurge := intstr.FromInt(0)
 	testcases := map[string]struct {
 		rollingUpdateDs1 *apps.RollingUpdateDaemonSet
 		rollingUpdateDs2 *v1beta2.RollingUpdateDaemonSet
 	}{
 		"RollingUpdateDaemonSet Conversion 2": {
-			rollingUpdateDs1: &apps.RollingUpdateDaemonSet{MaxUnavailable: intorstr},
-			rollingUpdateDs2: &v1beta2.RollingUpdateDaemonSet{MaxUnavailable: &intorstr},
+			rollingUpdateDs1: &apps.RollingUpdateDaemonSet{MaxUnavailable: intorstr, MaxSurge: maxSurge},
+			rollingUpdateDs2: &v1beta2.RollingUpdateDaemonSet{MaxUnavailable: &intorstr, MaxSurge: &maxSurge},
 		},
 	}
 
diff --git a/pkg/apis/apps/v1beta2/defaults.go b/pkg/apis/apps/v1beta2/defaults.go
index c93db681dad..f42b021b04e 100644
--- a/pkg/apis/apps/v1beta2/defaults.go
+++ b/pkg/apis/apps/v1beta2/defaults.go
@@ -41,6 +41,11 @@ func SetDefaults_DaemonSet(obj *appsv1beta2.DaemonSet) {
 			maxUnavailable := intstr.FromInt(1)
 			updateStrategy.RollingUpdate.MaxUnavailable = &maxUnavailable
 		}
+		if updateStrategy.RollingUpdate.MaxSurge == nil {
+			// Set default MaxSurge as 0 by default.
+			maxSurge := intstr.FromInt(0)
+			updateStrategy.RollingUpdate.MaxSurge = &maxSurge
+		}
 	}
 	if obj.Spec.RevisionHistoryLimit == nil {
 		obj.Spec.RevisionHistoryLimit = new(int32)
diff --git a/pkg/apis/apps/v1beta2/defaults_test.go b/pkg/apis/apps/v1beta2/defaults_test.go
index 7c9f6c3d6a6..d28df38d4d9 100644
--- a/pkg/apis/apps/v1beta2/defaults_test.go
+++ b/pkg/apis/apps/v1beta2/defaults_test.go
@@ -21,7 +21,7 @@ import (
 	"testing"
 
 	appsv1beta2 "k8s.io/api/apps/v1beta2"
-	"k8s.io/api/core/v1"
+	v1 "k8s.io/api/core/v1"
 	apiequality "k8s.io/apimachinery/pkg/api/equality"
 	"k8s.io/apimachinery/pkg/api/resource"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -38,6 +38,7 @@ import (
 func TestSetDefaultDaemonSetSpec(t *testing.T) {
 	defaultLabels := map[string]string{"foo": "bar"}
 	maxUnavailable := intstr.FromInt(1)
+	maxSurge := intstr.FromInt(0)
 	period := int64(v1.DefaultTerminationGracePeriodSeconds)
 	defaultTemplate := v1.PodTemplateSpec{
 		Spec: v1.PodSpec{
@@ -80,6 +81,7 @@ func TestSetDefaultDaemonSetSpec(t *testing.T) {
 						Type: appsv1beta2.RollingUpdateDaemonSetStrategyType,
 						RollingUpdate: &appsv1beta2.RollingUpdateDaemonSet{
 							MaxUnavailable: &maxUnavailable,
+							MaxSurge:       &maxSurge,
 						},
 					},
 					RevisionHistoryLimit: utilpointer.Int32Ptr(10),
@@ -110,6 +112,7 @@ func TestSetDefaultDaemonSetSpec(t *testing.T) {
 						Type: appsv1beta2.RollingUpdateDaemonSetStrategyType,
 						RollingUpdate: &appsv1beta2.RollingUpdateDaemonSet{
 							MaxUnavailable: &maxUnavailable,
+							MaxSurge:       &maxSurge,
 						},
 					},
 					RevisionHistoryLimit: utilpointer.Int32Ptr(1),
@@ -146,6 +149,7 @@ func TestSetDefaultDaemonSetSpec(t *testing.T) {
 						Type: appsv1beta2.RollingUpdateDaemonSetStrategyType,
 						RollingUpdate: &appsv1beta2.RollingUpdateDaemonSet{
 							MaxUnavailable: &maxUnavailable,
+							MaxSurge:       &maxSurge,
 						},
 					},
 					RevisionHistoryLimit: utilpointer.Int32Ptr(10),
diff --git a/pkg/apis/apps/v1beta2/zz_generated.conversion.go b/pkg/apis/apps/v1beta2/zz_generated.conversion.go
index 22944e28078..ac17f192dae 100644
--- a/pkg/apis/apps/v1beta2/zz_generated.conversion.go
+++ b/pkg/apis/apps/v1beta2/zz_generated.conversion.go
@@ -1002,6 +1002,9 @@ func autoConvert_v1beta2_RollingUpdateDaemonSet_To_apps_RollingUpdateDaemonSet(i
 	if err := metav1.Convert_Pointer_intstr_IntOrString_To_intstr_IntOrString(&in.MaxUnavailable, &out.MaxUnavailable, s); err != nil {
 		return err
 	}
+	if err := metav1.Convert_Pointer_intstr_IntOrString_To_intstr_IntOrString(&in.MaxSurge, &out.MaxSurge, s); err != nil {
+		return err
+	}
 	return nil
 }
 
@@ -1014,6 +1017,9 @@ func autoConvert_apps_RollingUpdateDaemonSet_To_v1beta2_RollingUpdateDaemonSet(i
 	if err := metav1.Convert_intstr_IntOrString_To_Pointer_intstr_IntOrString(&in.MaxUnavailable, &out.MaxUnavailable, s); err != nil {
 		return err
 	}
+	if err := metav1.Convert_intstr_IntOrString_To_Pointer_intstr_IntOrString(&in.MaxSurge, &out.MaxSurge, s); err != nil {
+		return err
+	}
 	return nil
 }
 
diff --git a/pkg/apis/apps/validation/BUILD b/pkg/apis/apps/validation/BUILD
index b6967f8b796..b2d9ec1e36d 100644
--- a/pkg/apis/apps/validation/BUILD
+++ b/pkg/apis/apps/validation/BUILD
@@ -14,6 +14,7 @@ go_library(
         "//pkg/apis/apps:go_default_library",
         "//pkg/apis/core:go_default_library",
         "//pkg/apis/core/validation:go_default_library",
+        "//pkg/features:go_default_library",
         "//staging/src/k8s.io/apimachinery/pkg/api/equality:go_default_library",
         "//staging/src/k8s.io/apimachinery/pkg/api/validation:go_default_library",
         "//staging/src/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
@@ -22,6 +23,7 @@ go_library(
         "//staging/src/k8s.io/apimachinery/pkg/util/intstr:go_default_library",
         "//staging/src/k8s.io/apimachinery/pkg/util/validation:go_default_library",
         "//staging/src/k8s.io/apimachinery/pkg/util/validation/field:go_default_library",
+        "//staging/src/k8s.io/apiserver/pkg/util/feature:go_default_library",
     ],
 )
 
diff --git a/pkg/apis/apps/validation/validation.go b/pkg/apis/apps/validation/validation.go
index e297c8a75b9..e1705bb75f8 100644
--- a/pkg/apis/apps/validation/validation.go
+++ b/pkg/apis/apps/validation/validation.go
@@ -28,9 +28,11 @@ import (
 	"k8s.io/apimachinery/pkg/util/intstr"
 	"k8s.io/apimachinery/pkg/util/validation"
 	"k8s.io/apimachinery/pkg/util/validation/field"
+	utilfeature "k8s.io/apiserver/pkg/util/feature"
 	"k8s.io/kubernetes/pkg/apis/apps"
 	api "k8s.io/kubernetes/pkg/apis/core"
 	apivalidation "k8s.io/kubernetes/pkg/apis/core/validation"
+	"k8s.io/kubernetes/pkg/features"
 )
 
 // ValidateStatefulSetName can be used to check whether the given StatefulSet name is valid.
@@ -343,14 +345,35 @@ func ValidateDaemonSetSpec(spec *apps.DaemonSetSpec, fldPath *field.Path, opts a
 
 // ValidateRollingUpdateDaemonSet validates a given RollingUpdateDaemonSet.
 func ValidateRollingUpdateDaemonSet(rollingUpdate *apps.RollingUpdateDaemonSet, fldPath *field.Path) field.ErrorList {
-	allErrs := field.ErrorList{}
-	allErrs = append(allErrs, ValidatePositiveIntOrPercent(rollingUpdate.MaxUnavailable, fldPath.Child("maxUnavailable"))...)
-	if getIntOrPercentValue(rollingUpdate.MaxUnavailable) == 0 {
-		// MaxUnavailable cannot be 0.
-		allErrs = append(allErrs, field.Invalid(fldPath.Child("maxUnavailable"), rollingUpdate.MaxUnavailable, "cannot be 0"))
+	var allErrs field.ErrorList
+	if utilfeature.DefaultFeatureGate.Enabled(features.DaemonSetUpdateSurge) {
+		// Validate both fields are positive ints or have a percentage value
+		allErrs = append(allErrs, ValidatePositiveIntOrPercent(rollingUpdate.MaxUnavailable, fldPath.Child("maxUnavailable"))...)
+		allErrs = append(allErrs, ValidatePositiveIntOrPercent(rollingUpdate.MaxSurge, fldPath.Child("maxSurge"))...)
+
+		// Validate that MaxUnavailable and MaxSurge are not more than 100%.
+		allErrs = append(allErrs, IsNotMoreThan100Percent(rollingUpdate.MaxUnavailable, fldPath.Child("maxUnavailable"))...)
+		allErrs = append(allErrs, IsNotMoreThan100Percent(rollingUpdate.MaxSurge, fldPath.Child("maxSurge"))...)
+
+		// Validate exactly one of MaxSurge or MaxUnavailable is non-zero
+		hasUnavailable := getIntOrPercentValue(rollingUpdate.MaxUnavailable) != 0
+		hasSurge := getIntOrPercentValue(rollingUpdate.MaxSurge) != 0
+		switch {
+		case hasUnavailable && hasSurge:
+			allErrs = append(allErrs, field.Invalid(fldPath.Child("maxSurge"), rollingUpdate.MaxSurge, "may not be set when maxUnavailable is non-zero"))
+		case !hasUnavailable && !hasSurge:
+			allErrs = append(allErrs, field.Required(fldPath.Child("maxUnavailable"), "cannot be 0 when maxSurge is 0"))
+		}
+
+	} else {
+		allErrs = append(allErrs, ValidatePositiveIntOrPercent(rollingUpdate.MaxUnavailable, fldPath.Child("maxUnavailable"))...)
+		if getIntOrPercentValue(rollingUpdate.MaxUnavailable) == 0 {
+			// MaxUnavailable cannot be 0.
+			allErrs = append(allErrs, field.Invalid(fldPath.Child("maxUnavailable"), rollingUpdate.MaxUnavailable, "cannot be 0"))
+		}
+		// Validate that MaxUnavailable is not more than 100%.
+		allErrs = append(allErrs, IsNotMoreThan100Percent(rollingUpdate.MaxUnavailable, fldPath.Child("maxUnavailable"))...)
 	}
-	// Validate that MaxUnavailable is not more than 100%.
-	allErrs = append(allErrs, IsNotMoreThan100Percent(rollingUpdate.MaxUnavailable, fldPath.Child("maxUnavailable"))...)
 	return allErrs
 }
 
diff --git a/pkg/apis/apps/validation/validation_test.go b/pkg/apis/apps/validation/validation_test.go
index 10a5d23b83f..ee6f650917b 100644
--- a/pkg/apis/apps/validation/validation_test.go
+++ b/pkg/apis/apps/validation/validation_test.go
@@ -2971,3 +2971,182 @@ func TestValidateReplicaSet(t *testing.T) {
 		}
 	}
 }
+
+func TestDaemonSetUpdateMaxSurge(t *testing.T) {
+	testCases := map[string]struct {
+		ds          *apps.RollingUpdateDaemonSet
+		enableSurge bool
+		expectError bool
+	}{
+		"invalid: unset": {
+			ds:          &apps.RollingUpdateDaemonSet{},
+			expectError: true,
+		},
+		"invalid: zero percent": {
+			ds: &apps.RollingUpdateDaemonSet{
+				MaxUnavailable: intstr.FromString("0%"),
+			},
+			expectError: true,
+		},
+		"invalid: zero": {
+			ds: &apps.RollingUpdateDaemonSet{
+				MaxUnavailable: intstr.FromInt(0),
+			},
+			expectError: true,
+		},
+		"valid: one": {
+			ds: &apps.RollingUpdateDaemonSet{
+				MaxUnavailable: intstr.FromInt(1),
+			},
+		},
+		"valid: one percent": {
+			ds: &apps.RollingUpdateDaemonSet{
+				MaxUnavailable: intstr.FromString("1%"),
+			},
+		},
+		"valid: 100%": {
+			ds: &apps.RollingUpdateDaemonSet{
+				MaxUnavailable: intstr.FromString("100%"),
+			},
+		},
+		"invalid: greater than 100%": {
+			ds: &apps.RollingUpdateDaemonSet{
+				MaxUnavailable: intstr.FromString("101%"),
+			},
+			expectError: true,
+		},
+
+		"valid: surge and unavailable set": {
+			ds: &apps.RollingUpdateDaemonSet{
+				MaxUnavailable: intstr.FromString("1%"),
+				MaxSurge:       intstr.FromString("1%"),
+			},
+		},
+
+		"invalid: surge enabled, unavailable zero percent": {
+			ds: &apps.RollingUpdateDaemonSet{
+				MaxUnavailable: intstr.FromString("0%"),
+			},
+			enableSurge: true,
+			expectError: true,
+		},
+		"invalid: surge enabled, unavailable zero": {
+			ds: &apps.RollingUpdateDaemonSet{
+				MaxUnavailable: intstr.FromInt(0),
+			},
+			enableSurge: true,
+			expectError: true,
+		},
+		"valid: surge enabled, unavailable one": {
+			ds: &apps.RollingUpdateDaemonSet{
+				MaxUnavailable: intstr.FromInt(1),
+			},
+			enableSurge: true,
+		},
+		"valid: surge enabled, unavailable one percent": {
+			ds: &apps.RollingUpdateDaemonSet{
+				MaxUnavailable: intstr.FromString("1%"),
+			},
+			enableSurge: true,
+		},
+		"valid: surge enabled, unavailable 100%": {
+			ds: &apps.RollingUpdateDaemonSet{
+				MaxUnavailable: intstr.FromString("100%"),
+			},
+			enableSurge: true,
+		},
+		"invalid: surge enabled, unavailable greater than 100%": {
+			ds: &apps.RollingUpdateDaemonSet{
+				MaxUnavailable: intstr.FromString("101%"),
+			},
+			enableSurge: true,
+			expectError: true,
+		},
+
+		"invalid: surge enabled, surge zero percent": {
+			ds: &apps.RollingUpdateDaemonSet{
+				MaxSurge: intstr.FromString("0%"),
+			},
+			enableSurge: true,
+			expectError: true,
+		},
+		"invalid: surge enabled, surge zero": {
+			ds: &apps.RollingUpdateDaemonSet{
+				MaxSurge: intstr.FromInt(0),
+			},
+			enableSurge: true,
+			expectError: true,
+		},
+		"valid: surge enabled, surge one": {
+			ds: &apps.RollingUpdateDaemonSet{
+				MaxSurge: intstr.FromInt(1),
+			},
+			enableSurge: true,
+		},
+		"valid: surge enabled, surge one percent": {
+			ds: &apps.RollingUpdateDaemonSet{
+				MaxSurge: intstr.FromString("1%"),
+			},
+			enableSurge: true,
+		},
+		"valid: surge enabled, surge 100%": {
+			ds: &apps.RollingUpdateDaemonSet{
+				MaxSurge: intstr.FromString("100%"),
+			},
+			enableSurge: true,
+		},
+		"invalid: surge enabled, surge greater than 100%": {
+			ds: &apps.RollingUpdateDaemonSet{
+				MaxSurge: intstr.FromString("101%"),
+			},
+			enableSurge: true,
+			expectError: true,
+		},
+
+		"invalid: surge enabled, surge and unavailable set": {
+			ds: &apps.RollingUpdateDaemonSet{
+				MaxUnavailable: intstr.FromString("1%"),
+				MaxSurge:       intstr.FromString("1%"),
+			},
+			enableSurge: true,
+			expectError: true,
+		},
+
+		"invalid: surge enabled, surge and unavailable zero percent": {
+			ds: &apps.RollingUpdateDaemonSet{
+				MaxUnavailable: intstr.FromString("0%"),
+				MaxSurge:       intstr.FromString("0%"),
+			},
+			enableSurge: true,
+			expectError: true,
+		},
+		"invalid: surge enabled, surge and unavailable zero": {
+			ds: &apps.RollingUpdateDaemonSet{
+				MaxUnavailable: intstr.FromInt(0),
+				MaxSurge:       intstr.FromInt(0),
+			},
+			enableSurge: true,
+			expectError: true,
+		},
+		"invalid: surge enabled, surge and unavailable mixed zero": {
+			ds: &apps.RollingUpdateDaemonSet{
+				MaxUnavailable: intstr.FromInt(0),
+				MaxSurge:       intstr.FromString("0%"),
+			},
+			enableSurge: true,
+			expectError: true,
+		},
+	}
+	for tcName, tc := range testCases {
+		t.Run(tcName, func(t *testing.T) {
+			defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.DaemonSetUpdateSurge, tc.enableSurge)()
+			errs := ValidateRollingUpdateDaemonSet(tc.ds, field.NewPath("spec", "updateStrategy", "rollingUpdate"))
+			if tc.expectError && len(errs) == 0 {
+				t.Errorf("Unexpected success")
+			}
+			if !tc.expectError && len(errs) != 0 {
+				t.Errorf("Unexpected error(s): %v", errs)
+			}
+		})
+	}
+}
diff --git a/pkg/apis/apps/zz_generated.deepcopy.go b/pkg/apis/apps/zz_generated.deepcopy.go
index deda2e6234a..ff11b8fb264 100644
--- a/pkg/apis/apps/zz_generated.deepcopy.go
+++ b/pkg/apis/apps/zz_generated.deepcopy.go
@@ -585,6 +585,7 @@ func (in *RollbackConfig) DeepCopy() *RollbackConfig {
 func (in *RollingUpdateDaemonSet) DeepCopyInto(out *RollingUpdateDaemonSet) {
 	*out = *in
 	out.MaxUnavailable = in.MaxUnavailable
+	out.MaxSurge = in.MaxSurge
 	return
 }
 
diff --git a/pkg/apis/extensions/v1beta1/defaults.go b/pkg/apis/extensions/v1beta1/defaults.go
index 1631dcb0eed..1ba702ccc4b 100644
--- a/pkg/apis/extensions/v1beta1/defaults.go
+++ b/pkg/apis/extensions/v1beta1/defaults.go
@@ -19,7 +19,7 @@ package v1beta1
 import (
 	"math"
 
-	"k8s.io/api/core/v1"
+	v1 "k8s.io/api/core/v1"
 	extensionsv1beta1 "k8s.io/api/extensions/v1beta1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
@@ -58,6 +58,11 @@ func SetDefaults_DaemonSet(obj *extensionsv1beta1.DaemonSet) {
 			maxUnavailable := intstr.FromInt(1)
 			updateStrategy.RollingUpdate.MaxUnavailable = &maxUnavailable
 		}
+		if updateStrategy.RollingUpdate.MaxSurge == nil {
+			// Set default MaxSurge as 0 by default.
+			maxSurge := intstr.FromInt(0)
+			updateStrategy.RollingUpdate.MaxSurge = &maxSurge
+		}
 	}
 	if obj.Spec.RevisionHistoryLimit == nil {
 		obj.Spec.RevisionHistoryLimit = new(int32)
diff --git a/pkg/apis/extensions/v1beta1/zz_generated.conversion.go b/pkg/apis/extensions/v1beta1/zz_generated.conversion.go
index 6b94fdc072d..ca906562088 100644
--- a/pkg/apis/extensions/v1beta1/zz_generated.conversion.go
+++ b/pkg/apis/extensions/v1beta1/zz_generated.conversion.go
@@ -2108,6 +2108,9 @@ func autoConvert_v1beta1_RollingUpdateDaemonSet_To_apps_RollingUpdateDaemonSet(i
 	if err := metav1.Convert_Pointer_intstr_IntOrString_To_intstr_IntOrString(&in.MaxUnavailable, &out.MaxUnavailable, s); err != nil {
 		return err
 	}
+	if err := metav1.Convert_Pointer_intstr_IntOrString_To_intstr_IntOrString(&in.MaxSurge, &out.MaxSurge, s); err != nil {
+		return err
+	}
 	return nil
 }
 
@@ -2120,6 +2123,9 @@ func autoConvert_apps_RollingUpdateDaemonSet_To_v1beta1_RollingUpdateDaemonSet(i
 	if err := metav1.Convert_intstr_IntOrString_To_Pointer_intstr_IntOrString(&in.MaxUnavailable, &out.MaxUnavailable, s); err != nil {
 		return err
 	}
+	if err := metav1.Convert_intstr_IntOrString_To_Pointer_intstr_IntOrString(&in.MaxSurge, &out.MaxSurge, s); err != nil {
+		return err
+	}
 	return nil
 }
 
diff --git a/pkg/features/kube_features.go b/pkg/features/kube_features.go
index 575a0a2e102..fedddd75f2a 100644
--- a/pkg/features/kube_features.go
+++ b/pkg/features/kube_features.go
@@ -573,6 +573,12 @@ const (
 	// This feature is deprecated, and will be removed in v1.22.
 	CronJobControllerV2 featuregate.Feature = "CronJobControllerV2"
 
+	// owner: @smarterclayton
+	// alpha: v1.21
+	//
+	// DaemonSets allow workloads to maintain availability during update per node
+	DaemonSetUpdateSurge featuregate.Feature = "DaemonSetUpdateSurge"
+
 	// owner: @m1093782566
 	// alpha: v1.17
 	//
@@ -808,6 +814,7 @@ var defaultKubernetesFeatureGates = map[featuregate.Feature]featuregate.FeatureS
 	AllowInsecureBackendProxy:                      {Default: true, PreRelease: featuregate.Beta},
 	PodDisruptionBudget:                            {Default: true, PreRelease: featuregate.Beta},
 	CronJobControllerV2:                            {Default: false, PreRelease: featuregate.Alpha},
+	DaemonSetUpdateSurge:                           {Default: false, PreRelease: featuregate.Alpha},
 	ServiceTopology:                                {Default: false, PreRelease: featuregate.Alpha},
 	ServiceAppProtocol:                             {Default: true, PreRelease: featuregate.GA, LockToDefault: true},
 	ImmutableEphemeralVolumes:                      {Default: true, PreRelease: featuregate.Beta},
diff --git a/pkg/registry/apps/daemonset/BUILD b/pkg/registry/apps/daemonset/BUILD
index 68ae8aefac1..42bf43c9353 100644
--- a/pkg/registry/apps/daemonset/BUILD
+++ b/pkg/registry/apps/daemonset/BUILD
@@ -18,16 +18,19 @@ go_library(
         "//pkg/api/pod:go_default_library",
         "//pkg/apis/apps:go_default_library",
         "//pkg/apis/apps/validation:go_default_library",
+        "//pkg/features:go_default_library",
         "//staging/src/k8s.io/api/apps/v1beta2:go_default_library",
         "//staging/src/k8s.io/api/extensions/v1beta1:go_default_library",
         "//staging/src/k8s.io/apimachinery/pkg/api/equality:go_default_library",
         "//staging/src/k8s.io/apimachinery/pkg/api/validation:go_default_library",
         "//staging/src/k8s.io/apimachinery/pkg/runtime:go_default_library",
         "//staging/src/k8s.io/apimachinery/pkg/runtime/schema:go_default_library",
+        "//staging/src/k8s.io/apimachinery/pkg/util/intstr:go_default_library",
         "//staging/src/k8s.io/apimachinery/pkg/util/validation/field:go_default_library",
         "//staging/src/k8s.io/apiserver/pkg/endpoints/request:go_default_library",
         "//staging/src/k8s.io/apiserver/pkg/registry/rest:go_default_library",
         "//staging/src/k8s.io/apiserver/pkg/storage/names:go_default_library",
+        "//staging/src/k8s.io/apiserver/pkg/util/feature:go_default_library",
     ],
 )
 
@@ -38,10 +41,15 @@ go_test(
     deps = [
         "//pkg/apis/apps:go_default_library",
         "//pkg/apis/core:go_default_library",
+        "//pkg/features:go_default_library",
         "//staging/src/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//staging/src/k8s.io/apimachinery/pkg/util/diff:go_default_library",
+        "//staging/src/k8s.io/apimachinery/pkg/util/intstr:go_default_library",
         "//staging/src/k8s.io/apimachinery/pkg/util/validation/field:go_default_library",
         "//staging/src/k8s.io/apiserver/pkg/endpoints/request:go_default_library",
         "//staging/src/k8s.io/apiserver/pkg/registry/rest:go_default_library",
+        "//staging/src/k8s.io/apiserver/pkg/util/feature:go_default_library",
+        "//staging/src/k8s.io/component-base/featuregate/testing:go_default_library",
     ],
 )
 
diff --git a/pkg/registry/apps/daemonset/strategy.go b/pkg/registry/apps/daemonset/strategy.go
index 03bdaa89583..af934471bae 100644
--- a/pkg/registry/apps/daemonset/strategy.go
+++ b/pkg/registry/apps/daemonset/strategy.go
@@ -25,14 +25,17 @@ import (
 	apivalidation "k8s.io/apimachinery/pkg/api/validation"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/apimachinery/pkg/util/intstr"
 	"k8s.io/apimachinery/pkg/util/validation/field"
 	genericapirequest "k8s.io/apiserver/pkg/endpoints/request"
 	"k8s.io/apiserver/pkg/registry/rest"
 	"k8s.io/apiserver/pkg/storage/names"
+	utilfeature "k8s.io/apiserver/pkg/util/feature"
 	"k8s.io/kubernetes/pkg/api/legacyscheme"
 	"k8s.io/kubernetes/pkg/api/pod"
 	"k8s.io/kubernetes/pkg/apis/apps"
 	"k8s.io/kubernetes/pkg/apis/apps/validation"
+	"k8s.io/kubernetes/pkg/features"
 )
 
 // daemonSetStrategy implements verification logic for daemon sets.
@@ -75,6 +78,7 @@ func (daemonSetStrategy) PrepareForCreate(ctx context.Context, obj runtime.Objec
 		daemonSet.Spec.TemplateGeneration = 1
 	}
 
+	dropDaemonSetDisabledFields(daemonSet, nil)
 	pod.DropDisabledTemplateFields(&daemonSet.Spec.Template, nil)
 }
 
@@ -83,6 +87,7 @@ func (daemonSetStrategy) PrepareForUpdate(ctx context.Context, obj, old runtime.
 	newDaemonSet := obj.(*apps.DaemonSet)
 	oldDaemonSet := old.(*apps.DaemonSet)
 
+	dropDaemonSetDisabledFields(newDaemonSet, oldDaemonSet)
 	pod.DropDisabledTemplateFields(&newDaemonSet.Spec.Template, &oldDaemonSet.Spec.Template)
 
 	// update is not allowed to set status
@@ -112,6 +117,35 @@ func (daemonSetStrategy) PrepareForUpdate(ctx context.Context, obj, old runtime.
 	}
 }
 
+// dropDaemonSetDisabledFields drops fields that are not used if their associated feature gates
+// are not enabled.  The typical pattern is:
+//     if !utilfeature.DefaultFeatureGate.Enabled(features.MyFeature) && !myFeatureInUse(oldSvc) {
+//         newSvc.Spec.MyFeature = nil
+//     }
+func dropDaemonSetDisabledFields(newDS *apps.DaemonSet, oldDS *apps.DaemonSet) {
+	if !utilfeature.DefaultFeatureGate.Enabled(features.DaemonSetUpdateSurge) {
+		if r := newDS.Spec.UpdateStrategy.RollingUpdate; r != nil {
+			if daemonSetSurgeFieldsInUse(oldDS) {
+				// we need to ensure that MaxUnavailable is non-zero to preserve previous behavior
+				if r.MaxUnavailable.IntVal == 0 && r.MaxUnavailable.StrVal == "0%" {
+					r.MaxUnavailable = intstr.FromInt(1)
+				}
+			} else {
+				// clear the MaxSurge field and let validation deal with MaxUnavailable
+				r.MaxSurge = intstr.IntOrString{}
+			}
+		}
+	}
+}
+
+// daemonSetSurgeFieldsInUse returns true if fields related to daemonset update surge are set
+func daemonSetSurgeFieldsInUse(ds *apps.DaemonSet) bool {
+	if ds == nil {
+		return false
+	}
+	return ds.Spec.UpdateStrategy.RollingUpdate != nil && (ds.Spec.UpdateStrategy.RollingUpdate.MaxSurge.IntVal != 0 || ds.Spec.UpdateStrategy.RollingUpdate.MaxSurge.StrVal != "")
+}
+
 // Validate validates a new daemon set.
 func (daemonSetStrategy) Validate(ctx context.Context, obj runtime.Object) field.ErrorList {
 	daemonSet := obj.(*apps.DaemonSet)
diff --git a/pkg/registry/apps/daemonset/strategy_test.go b/pkg/registry/apps/daemonset/strategy_test.go
index f48b3fd7e26..d5e30ec230c 100644
--- a/pkg/registry/apps/daemonset/strategy_test.go
+++ b/pkg/registry/apps/daemonset/strategy_test.go
@@ -21,11 +21,16 @@ import (
 	"testing"
 
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/util/diff"
+	"k8s.io/apimachinery/pkg/util/intstr"
 	"k8s.io/apimachinery/pkg/util/validation/field"
 	genericapirequest "k8s.io/apiserver/pkg/endpoints/request"
 	"k8s.io/apiserver/pkg/registry/rest"
+	utilfeature "k8s.io/apiserver/pkg/util/feature"
+	featuregatetesting "k8s.io/component-base/featuregate/testing"
 	"k8s.io/kubernetes/pkg/apis/apps"
 	api "k8s.io/kubernetes/pkg/apis/core"
+	"k8s.io/kubernetes/pkg/features"
 )
 
 const (
@@ -189,3 +194,207 @@ func newDaemonSetWithSelectorLabels(selectorLabels map[string]string, templateGe
 		},
 	}
 }
+
+func makeDaemonSetWithSurge(unavailable intstr.IntOrString, surge intstr.IntOrString) *apps.DaemonSet {
+	return &apps.DaemonSet{
+		Spec: apps.DaemonSetSpec{
+			UpdateStrategy: apps.DaemonSetUpdateStrategy{
+				Type: apps.RollingUpdateDaemonSetStrategyType,
+				RollingUpdate: &apps.RollingUpdateDaemonSet{
+					MaxUnavailable: unavailable,
+					MaxSurge:       surge,
+				},
+			},
+		},
+	}
+}
+
+func TestDropDisabledField(t *testing.T) {
+	testCases := []struct {
+		name        string
+		enableSurge bool
+		ds          *apps.DaemonSet
+		old         *apps.DaemonSet
+		expect      *apps.DaemonSet
+	}{
+		{
+			name:        "not surge, no update",
+			enableSurge: false,
+			ds:          &apps.DaemonSet{},
+			old:         nil,
+			expect:      &apps.DaemonSet{},
+		},
+		{
+			name:        "not surge, field not used",
+			enableSurge: false,
+			ds:          makeDaemonSetWithSurge(intstr.FromInt(1), intstr.IntOrString{}),
+			old:         nil,
+			expect:      makeDaemonSetWithSurge(intstr.FromInt(1), intstr.IntOrString{}),
+		},
+		{
+			name:        "not surge, field not used in old and new",
+			enableSurge: false,
+			ds:          makeDaemonSetWithSurge(intstr.FromInt(1), intstr.IntOrString{}),
+			old:         makeDaemonSetWithSurge(intstr.FromInt(1), intstr.IntOrString{}),
+			expect:      makeDaemonSetWithSurge(intstr.FromInt(1), intstr.IntOrString{}),
+		},
+		{
+			name:        "not surge, field used",
+			enableSurge: false,
+			ds:          makeDaemonSetWithSurge(intstr.FromInt(2), intstr.FromInt(1)),
+			old:         makeDaemonSetWithSurge(intstr.FromInt(2), intstr.FromInt(1)),
+			expect:      makeDaemonSetWithSurge(intstr.FromInt(2), intstr.FromInt(1)),
+		},
+		{
+			name:        "not surge, field used, percent",
+			enableSurge: false,
+			ds:          makeDaemonSetWithSurge(intstr.FromInt(2), intstr.FromString("1%")),
+			old:         makeDaemonSetWithSurge(intstr.FromInt(2), intstr.FromString("1%")),
+			expect:      makeDaemonSetWithSurge(intstr.FromInt(2), intstr.FromString("1%")),
+		},
+		{
+			name:        "not surge, field used and cleared",
+			enableSurge: false,
+			ds:          makeDaemonSetWithSurge(intstr.FromInt(2), intstr.IntOrString{}),
+			old:         makeDaemonSetWithSurge(intstr.FromInt(2), intstr.FromInt(1)),
+			expect:      makeDaemonSetWithSurge(intstr.FromInt(2), intstr.IntOrString{}),
+		},
+		{
+			name:        "not surge, field used and cleared, percent",
+			enableSurge: false,
+			ds:          makeDaemonSetWithSurge(intstr.FromInt(2), intstr.IntOrString{}),
+			old:         makeDaemonSetWithSurge(intstr.FromInt(2), intstr.FromString("1%")),
+			expect:      makeDaemonSetWithSurge(intstr.FromInt(2), intstr.IntOrString{}),
+		},
+		{
+			name:        "surge, field not used",
+			enableSurge: true,
+			ds:          makeDaemonSetWithSurge(intstr.FromInt(1), intstr.IntOrString{}),
+			old:         nil,
+			expect:      makeDaemonSetWithSurge(intstr.FromInt(1), intstr.IntOrString{}),
+		},
+		{
+			name:        "surge, field not used in old and new",
+			enableSurge: true,
+			ds:          makeDaemonSetWithSurge(intstr.FromInt(1), intstr.IntOrString{}),
+			old:         makeDaemonSetWithSurge(intstr.FromInt(1), intstr.IntOrString{}),
+			expect:      makeDaemonSetWithSurge(intstr.FromInt(1), intstr.IntOrString{}),
+		},
+		{
+			name:        "surge, field used",
+			enableSurge: true,
+			ds:          makeDaemonSetWithSurge(intstr.IntOrString{}, intstr.FromInt(1)),
+			old:         nil,
+			expect:      makeDaemonSetWithSurge(intstr.IntOrString{}, intstr.FromInt(1)),
+		},
+		{
+			name:        "surge, field used, percent",
+			enableSurge: true,
+			ds:          makeDaemonSetWithSurge(intstr.FromInt(2), intstr.FromString("1%")),
+			old:         makeDaemonSetWithSurge(intstr.FromInt(2), intstr.FromString("1%")),
+			expect:      makeDaemonSetWithSurge(intstr.FromInt(2), intstr.FromString("1%")),
+		},
+		{
+			name:        "surge, field used in old and new",
+			enableSurge: true,
+			ds:          makeDaemonSetWithSurge(intstr.IntOrString{}, intstr.FromInt(1)),
+			old:         makeDaemonSetWithSurge(intstr.IntOrString{}, intstr.FromInt(1)),
+			expect:      makeDaemonSetWithSurge(intstr.IntOrString{}, intstr.FromInt(1)),
+		},
+		{
+			name:        "surge, allows both fields (validation must catch)",
+			enableSurge: true,
+			ds:          makeDaemonSetWithSurge(intstr.FromInt(2), intstr.FromInt(1)),
+			old:         makeDaemonSetWithSurge(intstr.FromInt(2), intstr.FromInt(1)),
+			expect:      makeDaemonSetWithSurge(intstr.FromInt(2), intstr.FromInt(1)),
+		},
+		{
+			name:        "surge, allows change from unavailable to surge",
+			enableSurge: true,
+			ds:          makeDaemonSetWithSurge(intstr.FromInt(2), intstr.IntOrString{}),
+			old:         makeDaemonSetWithSurge(intstr.IntOrString{}, intstr.FromInt(1)),
+			expect:      makeDaemonSetWithSurge(intstr.FromInt(2), intstr.IntOrString{}),
+		},
+		{
+			name:        "surge, allows change from surge to unvailable",
+			enableSurge: true,
+			ds:          makeDaemonSetWithSurge(intstr.IntOrString{}, intstr.FromInt(1)),
+			old:         makeDaemonSetWithSurge(intstr.FromInt(2), intstr.IntOrString{}),
+			expect:      makeDaemonSetWithSurge(intstr.IntOrString{}, intstr.FromInt(1)),
+		},
+		{
+			name:        "not surge, allows change from unavailable to surge",
+			enableSurge: false,
+			ds:          makeDaemonSetWithSurge(intstr.FromInt(2), intstr.IntOrString{}),
+			old:         makeDaemonSetWithSurge(intstr.IntOrString{}, intstr.FromInt(1)),
+			expect:      makeDaemonSetWithSurge(intstr.FromInt(2), intstr.IntOrString{}),
+		},
+		{
+			name:        "not surge, allows change from surge to unvailable",
+			enableSurge: false,
+			ds:          makeDaemonSetWithSurge(intstr.IntOrString{}, intstr.FromInt(1)),
+			old:         makeDaemonSetWithSurge(intstr.FromInt(2), intstr.IntOrString{}),
+			expect:      makeDaemonSetWithSurge(intstr.IntOrString{}, intstr.IntOrString{}),
+		},
+		{
+			name:        "not surge, allows change from unavailable to surge, percent",
+			enableSurge: false,
+			ds:          makeDaemonSetWithSurge(intstr.FromString("2%"), intstr.IntOrString{}),
+			old:         makeDaemonSetWithSurge(intstr.IntOrString{}, intstr.FromString("1%")),
+			expect:      makeDaemonSetWithSurge(intstr.FromString("2%"), intstr.IntOrString{}),
+		},
+		{
+			name:        "not surge, allows change from surge to unvailable, percent",
+			enableSurge: false,
+			ds:          makeDaemonSetWithSurge(intstr.IntOrString{}, intstr.FromString("1%")),
+			old:         makeDaemonSetWithSurge(intstr.FromString("2%"), intstr.IntOrString{}),
+			expect:      makeDaemonSetWithSurge(intstr.IntOrString{}, intstr.IntOrString{}),
+		},
+		{
+			name:        "not surge, resets zero percent, one percent",
+			enableSurge: false,
+			ds:          makeDaemonSetWithSurge(intstr.FromString("0%"), intstr.FromString("1%")),
+			old:         makeDaemonSetWithSurge(intstr.FromString("0%"), intstr.FromString("1%")),
+			expect:      makeDaemonSetWithSurge(intstr.FromInt(1), intstr.FromString("1%")),
+		},
+		{
+			name:        "not surge, resets and clears when zero percent",
+			enableSurge: false,
+			ds:          makeDaemonSetWithSurge(intstr.FromString("0%"), intstr.IntOrString{}),
+			old:         makeDaemonSetWithSurge(intstr.FromString("0%"), intstr.FromString("1%")),
+			expect:      makeDaemonSetWithSurge(intstr.FromInt(1), intstr.IntOrString{}),
+		},
+		{
+			name:        "not surge, sets zero percent, one percent",
+			enableSurge: false,
+			ds:          makeDaemonSetWithSurge(intstr.FromString("0%"), intstr.FromString("1%")),
+			old:         nil,
+			expect:      makeDaemonSetWithSurge(intstr.FromString("0%"), intstr.IntOrString{}),
+		},
+		{
+			name:        "not surge, sets and clears zero percent",
+			enableSurge: false,
+			ds:          makeDaemonSetWithSurge(intstr.FromString("0%"), intstr.IntOrString{}),
+			old:         nil,
+			expect:      makeDaemonSetWithSurge(intstr.FromString("0%"), intstr.IntOrString{}),
+		},
+	}
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.DaemonSetUpdateSurge, tc.enableSurge)()
+			old := tc.old.DeepCopy()
+
+			dropDaemonSetDisabledFields(tc.ds, tc.old)
+
+			// old obj should never be changed
+			if !reflect.DeepEqual(tc.old, old) {
+				t.Fatalf("old ds changed: %v", diff.ObjectReflectDiff(tc.old, old))
+			}
+
+			if !reflect.DeepEqual(tc.ds, tc.expect) {
+				t.Fatalf("unexpected ds spec: %v", diff.ObjectReflectDiff(tc.expect, tc.ds))
+			}
+		})
+	}
+
+}
diff --git a/staging/src/k8s.io/api/apps/v1/generated.pb.go b/staging/src/k8s.io/api/apps/v1/generated.pb.go
index 6ef25f50f90..1ed316ed257 100644
--- a/staging/src/k8s.io/api/apps/v1/generated.pb.go
+++ b/staging/src/k8s.io/api/apps/v1/generated.pb.go
@@ -870,132 +870,132 @@ func init() {
 var fileDescriptor_e1014cab6f31e43b = []byte{
 	// 2031 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x5a, 0xcd, 0x6f, 0x24, 0x47,
-	0x1d, 0x75, 0xcf, 0x87, 0x3d, 0x2e, 0xaf, 0xed, 0xdd, 0xb2, 0xb1, 0x27, 0xbb, 0x64, 0x66, 0x19,
+	0x15, 0x77, 0xcf, 0x87, 0x3d, 0x2e, 0xaf, 0xed, 0xdd, 0xb2, 0xb1, 0x27, 0xbb, 0x64, 0x66, 0x19,
 	0x60, 0xe3, 0x64, 0xb3, 0x3d, 0xec, 0x66, 0x13, 0xa1, 0x2c, 0x02, 0x79, 0xc6, 0x21, 0x84, 0x78,
 	0x6c, 0x53, 0x5e, 0xef, 0x61, 0x09, 0x12, 0xe5, 0xe9, 0xda, 0x71, 0xc7, 0xfd, 0xa5, 0xee, 0xea,
-	0x61, 0x47, 0x5c, 0x10, 0x12, 0x9c, 0x38, 0xf0, 0x9f, 0x20, 0x84, 0xe0, 0x86, 0x22, 0xc4, 0x65,
-	0x2f, 0x48, 0x11, 0x17, 0x72, 0xb2, 0xd8, 0xc9, 0x09, 0xa1, 0x1c, 0xb9, 0xe4, 0x02, 0xaa, 0xea,
-	0xea, 0xef, 0x6a, 0xcf, 0xd8, 0x9b, 0x38, 0x24, 0xca, 0xcd, 0x53, 0xf5, 0x7e, 0xaf, 0x7f, 0x55,
-	0xf5, 0xab, 0x7a, 0xaf, 0xab, 0x0d, 0xee, 0x1d, 0x7f, 0xdb, 0x53, 0x75, 0xbb, 0x7d, 0xec, 0x1f,
-	0x12, 0xd7, 0x22, 0x94, 0x78, 0xed, 0x21, 0xb1, 0x34, 0xdb, 0x6d, 0x8b, 0x0e, 0xec, 0xe8, 0x6d,
-	0xec, 0x38, 0x5e, 0x7b, 0x78, 0xbb, 0x3d, 0x20, 0x16, 0x71, 0x31, 0x25, 0x9a, 0xea, 0xb8, 0x36,
-	0xb5, 0x21, 0x0c, 0x30, 0x2a, 0x76, 0x74, 0x95, 0x61, 0xd4, 0xe1, 0xed, 0xab, 0xb7, 0x06, 0x3a,
-	0x3d, 0xf2, 0x0f, 0xd5, 0xbe, 0x6d, 0xb6, 0x07, 0xf6, 0xc0, 0x6e, 0x73, 0xe8, 0xa1, 0xff, 0x88,
-	0xff, 0xe2, 0x3f, 0xf8, 0x5f, 0x01, 0xc5, 0xd5, 0x56, 0xe2, 0x31, 0x7d, 0xdb, 0x25, 0x92, 0xc7,
-	0x5c, 0xbd, 0x1b, 0x63, 0x4c, 0xdc, 0x3f, 0xd2, 0x2d, 0xe2, 0x8e, 0xda, 0xce, 0xf1, 0x80, 0x35,
-	0x78, 0x6d, 0x93, 0x50, 0x2c, 0x8b, 0x6a, 0x17, 0x45, 0xb9, 0xbe, 0x45, 0x75, 0x93, 0xe4, 0x02,
-	0x5e, 0x9b, 0x14, 0xe0, 0xf5, 0x8f, 0x88, 0x89, 0x73, 0x71, 0xaf, 0x14, 0xc5, 0xf9, 0x54, 0x37,
-	0xda, 0xba, 0x45, 0x3d, 0xea, 0x66, 0x83, 0x5a, 0xff, 0x51, 0x00, 0xec, 0xda, 0x16, 0x75, 0x6d,
-	0xc3, 0x20, 0x2e, 0x22, 0x43, 0xdd, 0xd3, 0x6d, 0x0b, 0xfe, 0x14, 0xd4, 0xd8, 0x78, 0x34, 0x4c,
-	0x71, 0x5d, 0xb9, 0xae, 0x6c, 0x2c, 0xdc, 0xf9, 0x96, 0x1a, 0x4f, 0x72, 0x44, 0xaf, 0x3a, 0xc7,
-	0x03, 0xd6, 0xe0, 0xa9, 0x0c, 0xad, 0x0e, 0x6f, 0xab, 0xbb, 0x87, 0xef, 0x92, 0x3e, 0xed, 0x11,
-	0x8a, 0x3b, 0xf0, 0xc9, 0x49, 0x73, 0x66, 0x7c, 0xd2, 0x04, 0x71, 0x1b, 0x8a, 0x58, 0xe1, 0x2e,
-	0xa8, 0x70, 0xf6, 0x12, 0x67, 0xbf, 0x55, 0xc8, 0x2e, 0x06, 0xad, 0x22, 0xfc, 0xb3, 0x37, 0x1e,
-	0x53, 0x62, 0xb1, 0xf4, 0x3a, 0x97, 0x04, 0x75, 0x65, 0x0b, 0x53, 0x8c, 0x38, 0x11, 0x7c, 0x19,
-	0xd4, 0x5c, 0x91, 0x7e, 0xbd, 0x7c, 0x5d, 0xd9, 0x28, 0x77, 0x2e, 0x0b, 0x54, 0x2d, 0x1c, 0x16,
-	0x8a, 0x10, 0xad, 0xbf, 0x2a, 0x60, 0x2d, 0x3f, 0xee, 0x6d, 0xdd, 0xa3, 0xf0, 0x9d, 0xdc, 0xd8,
-	0xd5, 0xe9, 0xc6, 0xce, 0xa2, 0xf9, 0xc8, 0xa3, 0x07, 0x87, 0x2d, 0x89, 0x71, 0xbf, 0x0d, 0xaa,
-	0x3a, 0x25, 0xa6, 0x57, 0x2f, 0x5d, 0x2f, 0x6f, 0x2c, 0xdc, 0xb9, 0xa1, 0xe6, 0x6b, 0x57, 0xcd,
-	0x27, 0xd6, 0x59, 0x14, 0x94, 0xd5, 0xb7, 0x58, 0x30, 0x0a, 0x38, 0x5a, 0xff, 0x55, 0xc0, 0xfc,
-	0x16, 0x26, 0xa6, 0x6d, 0xed, 0x13, 0x7a, 0x01, 0x8b, 0xd6, 0x05, 0x15, 0xcf, 0x21, 0x7d, 0xb1,
-	0x68, 0x5f, 0x93, 0xe5, 0x1e, 0xa5, 0xb3, 0xef, 0x90, 0x7e, 0xbc, 0x50, 0xec, 0x17, 0xe2, 0xc1,
-	0xf0, 0x6d, 0x30, 0xeb, 0x51, 0x4c, 0x7d, 0x8f, 0x2f, 0xd3, 0xc2, 0x9d, 0xaf, 0x9f, 0x4e, 0xc3,
-	0xa1, 0x9d, 0x25, 0x41, 0x34, 0x1b, 0xfc, 0x46, 0x82, 0xa2, 0xf5, 0xaf, 0x12, 0x80, 0x11, 0xb6,
-	0x6b, 0x5b, 0x9a, 0x4e, 0x59, 0xfd, 0xbe, 0x0e, 0x2a, 0x74, 0xe4, 0x10, 0x3e, 0x0d, 0xf3, 0x9d,
-	0x1b, 0x61, 0x16, 0xf7, 0x47, 0x0e, 0xf9, 0xf8, 0xa4, 0xb9, 0x96, 0x8f, 0x60, 0x3d, 0x88, 0xc7,
-	0xc0, 0xed, 0x28, 0xbf, 0x12, 0x8f, 0xbe, 0x9b, 0x7e, 0xf4, 0xc7, 0x27, 0x4d, 0xc9, 0x61, 0xa1,
-	0x46, 0x4c, 0xe9, 0x04, 0xe1, 0x10, 0x40, 0x03, 0x7b, 0xf4, 0xbe, 0x8b, 0x2d, 0x2f, 0x78, 0x92,
-	0x6e, 0x12, 0x31, 0xf2, 0x97, 0xa6, 0x5b, 0x1e, 0x16, 0xd1, 0xb9, 0x2a, 0xb2, 0x80, 0xdb, 0x39,
-	0x36, 0x24, 0x79, 0x02, 0xbc, 0x01, 0x66, 0x5d, 0x82, 0x3d, 0xdb, 0xaa, 0x57, 0xf8, 0x28, 0xa2,
-	0x09, 0x44, 0xbc, 0x15, 0x89, 0x5e, 0xf8, 0x22, 0x98, 0x33, 0x89, 0xe7, 0xe1, 0x01, 0xa9, 0x57,
-	0x39, 0x70, 0x59, 0x00, 0xe7, 0x7a, 0x41, 0x33, 0x0a, 0xfb, 0x5b, 0xbf, 0x57, 0xc0, 0x62, 0x34,
-	0x73, 0x17, 0xb0, 0x55, 0x3a, 0xe9, 0xad, 0xf2, 0xfc, 0xa9, 0x75, 0x52, 0xb0, 0x43, 0xde, 0x2b,
-	0x27, 0x72, 0x66, 0x45, 0x08, 0x7f, 0x02, 0x6a, 0x1e, 0x31, 0x48, 0x9f, 0xda, 0xae, 0xc8, 0xf9,
-	0x95, 0x29, 0x73, 0xc6, 0x87, 0xc4, 0xd8, 0x17, 0xa1, 0x9d, 0x4b, 0x2c, 0xe9, 0xf0, 0x17, 0x8a,
-	0x28, 0xe1, 0x8f, 0x40, 0x8d, 0x12, 0xd3, 0x31, 0x30, 0x25, 0x62, 0x9b, 0xa4, 0xea, 0x9b, 0x95,
-	0x0b, 0x23, 0xdb, 0xb3, 0xb5, 0xfb, 0x02, 0xc6, 0x37, 0x4a, 0x34, 0x0f, 0x61, 0x2b, 0x8a, 0x68,
-	0xe0, 0x31, 0x58, 0xf2, 0x1d, 0x8d, 0x21, 0x29, 0x3b, 0xba, 0x07, 0x23, 0x51, 0x3e, 0x37, 0x4f,
-	0x9d, 0x90, 0x83, 0x54, 0x48, 0x67, 0x4d, 0x3c, 0x60, 0x29, 0xdd, 0x8e, 0x32, 0xd4, 0x70, 0x13,
-	0x2c, 0x9b, 0xba, 0x85, 0x08, 0xd6, 0x46, 0xfb, 0xa4, 0x6f, 0x5b, 0x9a, 0xc7, 0x0b, 0xa8, 0xda,
-	0x59, 0x17, 0x04, 0xcb, 0xbd, 0x74, 0x37, 0xca, 0xe2, 0xe1, 0x36, 0x58, 0x0d, 0xcf, 0xd9, 0x1f,
-	0xe8, 0x1e, 0xb5, 0xdd, 0xd1, 0xb6, 0x6e, 0xea, 0xb4, 0x3e, 0xcb, 0x79, 0xea, 0xe3, 0x93, 0xe6,
-	0x2a, 0x92, 0xf4, 0x23, 0x69, 0x54, 0xeb, 0x37, 0xb3, 0x60, 0x39, 0x73, 0x1a, 0xc0, 0x07, 0x60,
-	0xad, 0xef, 0xbb, 0x2e, 0xb1, 0xe8, 0x8e, 0x6f, 0x1e, 0x12, 0x77, 0xbf, 0x7f, 0x44, 0x34, 0xdf,
-	0x20, 0x1a, 0x5f, 0xd1, 0x6a, 0xa7, 0x21, 0x72, 0x5d, 0xeb, 0x4a, 0x51, 0xa8, 0x20, 0x1a, 0xfe,
-	0x10, 0x40, 0x8b, 0x37, 0xf5, 0x74, 0xcf, 0x8b, 0x38, 0x4b, 0x9c, 0x33, 0xda, 0x80, 0x3b, 0x39,
-	0x04, 0x92, 0x44, 0xb1, 0x1c, 0x35, 0xe2, 0xe9, 0x2e, 0xd1, 0xb2, 0x39, 0x96, 0xd3, 0x39, 0x6e,
-	0x49, 0x51, 0xa8, 0x20, 0x1a, 0xbe, 0x0a, 0x16, 0x82, 0xa7, 0xf1, 0x39, 0x17, 0x8b, 0xb3, 0x22,
-	0xc8, 0x16, 0x76, 0xe2, 0x2e, 0x94, 0xc4, 0xb1, 0xa1, 0xd9, 0x87, 0x1e, 0x71, 0x87, 0x44, 0x7b,
-	0x33, 0xf0, 0x00, 0x4c, 0x28, 0xab, 0x5c, 0x28, 0xa3, 0xa1, 0xed, 0xe6, 0x10, 0x48, 0x12, 0xc5,
-	0x86, 0x16, 0x54, 0x4d, 0x6e, 0x68, 0xb3, 0xe9, 0xa1, 0x1d, 0x48, 0x51, 0xa8, 0x20, 0x9a, 0xd5,
-	0x5e, 0x90, 0xf2, 0xe6, 0x10, 0xeb, 0x06, 0x3e, 0x34, 0x48, 0x7d, 0x2e, 0x5d, 0x7b, 0x3b, 0xe9,
-	0x6e, 0x94, 0xc5, 0xc3, 0x37, 0xc1, 0x95, 0xa0, 0xe9, 0xc0, 0xc2, 0x11, 0x49, 0x8d, 0x93, 0x3c,
-	0x27, 0x48, 0xae, 0xec, 0x64, 0x01, 0x28, 0x1f, 0x03, 0x5f, 0x07, 0x4b, 0x7d, 0xdb, 0x30, 0x78,
-	0x3d, 0x76, 0x6d, 0xdf, 0xa2, 0xf5, 0x79, 0xce, 0x02, 0xd9, 0x1e, 0xea, 0xa6, 0x7a, 0x50, 0x06,
-	0x09, 0x1f, 0x02, 0xd0, 0x0f, 0xe5, 0xc0, 0xab, 0x83, 0x62, 0xa1, 0xcf, 0xeb, 0x50, 0x2c, 0xc0,
-	0x51, 0x93, 0x87, 0x12, 0x6c, 0xad, 0xf7, 0x14, 0xb0, 0x5e, 0xb0, 0xc7, 0xe1, 0xf7, 0x52, 0xaa,
-	0x77, 0x33, 0xa3, 0x7a, 0xd7, 0x0a, 0xc2, 0x12, 0xd2, 0xd7, 0x07, 0x8b, 0xcc, 0x77, 0xe8, 0xd6,
-	0x20, 0x80, 0x88, 0x13, 0xec, 0x25, 0x59, 0xee, 0x28, 0x09, 0x8c, 0x8f, 0xe1, 0x2b, 0xe3, 0x93,
-	0xe6, 0x62, 0xaa, 0x0f, 0xa5, 0x39, 0x5b, 0xbf, 0x2c, 0x01, 0xb0, 0x45, 0x1c, 0xc3, 0x1e, 0x99,
-	0xc4, 0xba, 0x08, 0xd7, 0xb2, 0x95, 0x72, 0x2d, 0x2d, 0xe9, 0x42, 0x44, 0xf9, 0x14, 0xda, 0x96,
-	0xed, 0x8c, 0x6d, 0xf9, 0xc6, 0x04, 0x9e, 0xd3, 0x7d, 0xcb, 0x3f, 0xca, 0x60, 0x25, 0x06, 0xc7,
-	0xc6, 0xe5, 0x5e, 0x6a, 0x09, 0x5f, 0xc8, 0x2c, 0xe1, 0xba, 0x24, 0xe4, 0x53, 0x73, 0x2e, 0xef,
-	0x82, 0x25, 0xe6, 0x2b, 0x82, 0x55, 0xe3, 0xae, 0x65, 0xf6, 0xcc, 0xae, 0x25, 0x52, 0x9d, 0xed,
-	0x14, 0x13, 0xca, 0x30, 0x17, 0xb8, 0xa4, 0xb9, 0xcf, 0xa3, 0x4b, 0xfa, 0x83, 0x02, 0x96, 0xe2,
-	0x65, 0xba, 0x00, 0x9b, 0xd4, 0x4d, 0xdb, 0xa4, 0xc6, 0xe9, 0x75, 0x59, 0xe0, 0x93, 0xfe, 0x5e,
-	0x49, 0x66, 0xcd, 0x8d, 0xd2, 0x06, 0x7b, 0xa1, 0x72, 0x0c, 0xbd, 0x8f, 0x3d, 0x21, 0xab, 0x97,
-	0x82, 0x97, 0xa9, 0xa0, 0x0d, 0x45, 0xbd, 0x29, 0x4b, 0x55, 0xfa, 0x74, 0x2d, 0x55, 0xf9, 0x93,
-	0xb1, 0x54, 0xf7, 0x41, 0xcd, 0x0b, 0xcd, 0x54, 0x85, 0x53, 0xde, 0x98, 0xb4, 0x9d, 0x85, 0x8f,
-	0x8a, 0x58, 0x23, 0x07, 0x15, 0x31, 0xc9, 0xbc, 0x53, 0xf5, 0xb3, 0xf4, 0x4e, 0xac, 0xbc, 0x1d,
-	0xec, 0x7b, 0x44, 0xe3, 0x5b, 0xa9, 0x16, 0x97, 0xf7, 0x1e, 0x6f, 0x45, 0xa2, 0x17, 0x1e, 0x80,
-	0x75, 0xc7, 0xb5, 0x07, 0x2e, 0xf1, 0xbc, 0x2d, 0x82, 0x35, 0x43, 0xb7, 0x48, 0x38, 0x80, 0x40,
-	0xf5, 0xae, 0x8d, 0x4f, 0x9a, 0xeb, 0x7b, 0x72, 0x08, 0x2a, 0x8a, 0x6d, 0xfd, 0xb9, 0x02, 0x2e,
-	0x67, 0x4f, 0xc4, 0x02, 0x23, 0xa2, 0x9c, 0xcb, 0x88, 0xbc, 0x9c, 0x28, 0xd1, 0xc0, 0xa5, 0x25,
-	0xde, 0xf9, 0x73, 0x65, 0xba, 0x09, 0x96, 0x85, 0xf1, 0x08, 0x3b, 0x85, 0x15, 0x8b, 0x96, 0xe7,
-	0x20, 0xdd, 0x8d, 0xb2, 0x78, 0x78, 0x0f, 0x2c, 0xba, 0xdc, 0x5b, 0x85, 0x04, 0x81, 0x3f, 0xf9,
-	0x8a, 0x20, 0x58, 0x44, 0xc9, 0x4e, 0x94, 0xc6, 0x32, 0x6f, 0x12, 0x5b, 0x8e, 0x90, 0xa0, 0x92,
-	0xf6, 0x26, 0x9b, 0x59, 0x00, 0xca, 0xc7, 0xc0, 0x1e, 0x58, 0xf1, 0xad, 0x3c, 0x55, 0x50, 0x6b,
-	0xd7, 0x04, 0xd5, 0xca, 0x41, 0x1e, 0x82, 0x64, 0x71, 0xf0, 0xc7, 0x29, 0xbb, 0x32, 0xcb, 0x4f,
-	0x91, 0x17, 0x4e, 0xdf, 0x0e, 0x53, 0xfb, 0x15, 0x89, 0x8f, 0xaa, 0x4d, 0xeb, 0xa3, 0x5a, 0x7f,
-	0x52, 0x00, 0xcc, 0x6f, 0xc1, 0x89, 0x2f, 0xf7, 0xb9, 0x88, 0x84, 0x44, 0x6a, 0x72, 0x87, 0x73,
-	0x73, 0xb2, 0xc3, 0x89, 0x4f, 0xd0, 0xe9, 0x2c, 0x8e, 0x98, 0xde, 0x8b, 0xb9, 0x98, 0x99, 0xc2,
-	0xe2, 0xc4, 0xf9, 0x3c, 0x9b, 0xc5, 0x49, 0xf0, 0x9c, 0x6e, 0x71, 0xfe, 0x5d, 0x02, 0x2b, 0x31,
-	0x78, 0x6a, 0x8b, 0x23, 0x09, 0xf9, 0xf2, 0x72, 0x66, 0x3a, 0xdb, 0x11, 0x4f, 0xdd, 0xff, 0x89,
-	0xed, 0x88, 0x13, 0x2a, 0xb0, 0x1d, 0xbf, 0x2b, 0x25, 0xb3, 0x3e, 0xa3, 0xed, 0xf8, 0x04, 0xae,
-	0x2a, 0x3e, 0x77, 0xce, 0xa5, 0xf5, 0x97, 0x32, 0xb8, 0x9c, 0xdd, 0x82, 0x29, 0x1d, 0x54, 0x26,
-	0xea, 0xe0, 0x1e, 0x58, 0x7d, 0xe4, 0x1b, 0xc6, 0x88, 0x8f, 0x21, 0x21, 0x86, 0x81, 0x82, 0x7e,
-	0x55, 0x44, 0xae, 0x7e, 0x5f, 0x82, 0x41, 0xd2, 0xc8, 0xbc, 0x2c, 0x56, 0x9e, 0x55, 0x16, 0xab,
-	0xe7, 0x90, 0x45, 0xb9, 0xb3, 0x28, 0x9f, 0xcb, 0x59, 0x4c, 0xad, 0x89, 0x92, 0xe3, 0x6a, 0xe2,
-	0x3b, 0xfc, 0xaf, 0x15, 0xb0, 0x26, 0x7f, 0x7d, 0x86, 0x06, 0x58, 0x32, 0xf1, 0xe3, 0xe4, 0xe5,
-	0xc5, 0x24, 0xc1, 0xf0, 0xa9, 0x6e, 0xa8, 0xc1, 0xd7, 0x1d, 0xf5, 0x2d, 0x8b, 0xee, 0xba, 0xfb,
-	0xd4, 0xd5, 0xad, 0x41, 0x20, 0xb0, 0xbd, 0x14, 0x17, 0xca, 0x70, 0xb7, 0x3e, 0x54, 0xc0, 0x7a,
-	0x81, 0xca, 0x5d, 0x6c, 0x26, 0xf0, 0x21, 0xa8, 0x99, 0xf8, 0xf1, 0xbe, 0xef, 0x0e, 0x42, 0x49,
-	0x3e, 0xfb, 0x73, 0xf8, 0x2e, 0xec, 0x09, 0x16, 0x14, 0xf1, 0xb5, 0x76, 0xc1, 0xf5, 0xd4, 0x20,
-	0xd9, 0xa6, 0x21, 0x8f, 0x7c, 0x83, 0xef, 0x1f, 0xe1, 0x29, 0x6e, 0x82, 0x79, 0x07, 0xbb, 0x54,
-	0x8f, 0xcc, 0x68, 0xb5, 0xb3, 0x38, 0x3e, 0x69, 0xce, 0xef, 0x85, 0x8d, 0x28, 0xee, 0x6f, 0xfd,
-	0xaa, 0x04, 0x16, 0x12, 0x24, 0x17, 0xa0, 0xef, 0x6f, 0xa4, 0xf4, 0x5d, 0xfa, 0xc5, 0x24, 0x39,
-	0xaa, 0x22, 0x81, 0xef, 0x65, 0x04, 0xfe, 0x9b, 0x93, 0x88, 0x4e, 0x57, 0xf8, 0x8f, 0x4a, 0x60,
-	0x35, 0x81, 0x8e, 0x25, 0xfe, 0x3b, 0x29, 0x89, 0xdf, 0xc8, 0x48, 0x7c, 0x5d, 0x16, 0xf3, 0xa5,
-	0xc6, 0x4f, 0xd6, 0xf8, 0x3f, 0x2a, 0x60, 0x39, 0x31, 0x77, 0x17, 0x20, 0xf2, 0x5b, 0x69, 0x91,
-	0x6f, 0x4e, 0xa8, 0x97, 0x02, 0x95, 0x7f, 0x52, 0x4d, 0xe5, 0xfd, 0x85, 0xbf, 0x5d, 0xf8, 0x39,
-	0x58, 0x1d, 0xda, 0x86, 0x6f, 0x92, 0xae, 0x81, 0x75, 0x33, 0x04, 0x30, 0x55, 0x64, 0x93, 0xf8,
-	0xa2, 0x94, 0x9e, 0xb8, 0x9e, 0xee, 0x51, 0x62, 0xd1, 0x07, 0x71, 0x64, 0xac, 0xc5, 0x0f, 0x24,
-	0x74, 0x48, 0xfa, 0x10, 0xf8, 0x2a, 0x58, 0x60, 0x6a, 0xa6, 0xf7, 0xc9, 0x0e, 0x36, 0xc3, 0x9a,
-	0x8a, 0xbe, 0x0f, 0xec, 0xc7, 0x5d, 0x28, 0x89, 0x83, 0x47, 0x60, 0xc5, 0xb1, 0xb5, 0x1e, 0xb6,
-	0xf0, 0x80, 0xb0, 0xf3, 0x7f, 0xcf, 0x36, 0xf4, 0xfe, 0x88, 0xdf, 0x3b, 0xcc, 0x77, 0x5e, 0x0b,
-	0xdf, 0x29, 0xf7, 0xf2, 0x10, 0xe6, 0xd9, 0x25, 0xcd, 0x7c, 0x3f, 0xcb, 0x28, 0xa1, 0x99, 0xfb,
-	0x9c, 0x35, 0x97, 0xfb, 0x1f, 0x00, 0x59, 0x71, 0x9d, 0xf3, 0x83, 0x56, 0xd1, 0x8d, 0x4a, 0xed,
-	0x5c, 0x5f, 0xa3, 0x3e, 0xaa, 0x80, 0x2b, 0xb9, 0x03, 0xf2, 0x33, 0xbc, 0xd3, 0xc8, 0x39, 0xaf,
-	0xf2, 0x19, 0x9c, 0xd7, 0x26, 0x58, 0x16, 0x1f, 0xc2, 0x32, 0xc6, 0x2d, 0x32, 0xd0, 0xdd, 0x74,
-	0x37, 0xca, 0xe2, 0x65, 0x77, 0x2a, 0xd5, 0x33, 0xde, 0xa9, 0x24, 0xb3, 0x10, 0xff, 0xbf, 0x11,
-	0x54, 0x5d, 0x3e, 0x0b, 0xf1, 0x6f, 0x1c, 0x59, 0x3c, 0xfc, 0x6e, 0x58, 0x52, 0x11, 0xc3, 0x1c,
-	0x67, 0xc8, 0xd4, 0x48, 0x44, 0x90, 0x41, 0x3f, 0xd3, 0xc7, 0x9e, 0x77, 0x24, 0x1f, 0x7b, 0x36,
-	0x26, 0x94, 0xf2, 0xf4, 0x56, 0xf1, 0x6f, 0x0a, 0x78, 0xae, 0x70, 0x0f, 0xc0, 0xcd, 0x94, 0xce,
-	0xde, 0xca, 0xe8, 0xec, 0xf3, 0x85, 0x81, 0x09, 0xb1, 0x35, 0xe5, 0x17, 0x22, 0x77, 0x27, 0x5e,
-	0x88, 0x48, 0x5c, 0xd4, 0xe4, 0x9b, 0x91, 0xce, 0xc6, 0x93, 0xa7, 0x8d, 0x99, 0xf7, 0x9f, 0x36,
-	0x66, 0x3e, 0x78, 0xda, 0x98, 0xf9, 0xc5, 0xb8, 0xa1, 0x3c, 0x19, 0x37, 0x94, 0xf7, 0xc7, 0x0d,
-	0xe5, 0x83, 0x71, 0x43, 0xf9, 0xe7, 0xb8, 0xa1, 0xfc, 0xf6, 0xc3, 0xc6, 0xcc, 0xc3, 0xd2, 0xf0,
-	0xf6, 0xff, 0x02, 0x00, 0x00, 0xff, 0xff, 0x59, 0xb3, 0x11, 0xc0, 0x12, 0x26, 0x00, 0x00,
+	0x61, 0x47, 0x5c, 0x10, 0x12, 0x37, 0x0e, 0xfc, 0x27, 0x08, 0x21, 0xb8, 0xa1, 0x08, 0x71, 0xd9,
+	0x0b, 0x52, 0xc4, 0x85, 0x9c, 0x2c, 0x76, 0x72, 0x42, 0x28, 0x47, 0x2e, 0xb9, 0x80, 0xaa, 0xba,
+	0xfa, 0xbb, 0xda, 0x33, 0xf6, 0x26, 0xce, 0x87, 0x72, 0xf3, 0x54, 0xfd, 0xde, 0xaf, 0xde, 0xab,
+	0x7a, 0x55, 0xef, 0xd7, 0x55, 0x06, 0xf7, 0x8e, 0xbf, 0xeb, 0xa9, 0xba, 0xdd, 0x3e, 0xf6, 0x0f,
+	0x89, 0x6b, 0x11, 0x4a, 0xbc, 0xf6, 0x90, 0x58, 0x9a, 0xed, 0xb6, 0x45, 0x07, 0x76, 0xf4, 0x36,
+	0x76, 0x1c, 0xaf, 0x3d, 0xbc, 0xdd, 0x1e, 0x10, 0x8b, 0xb8, 0x98, 0x12, 0x4d, 0x75, 0x5c, 0x9b,
+	0xda, 0x10, 0x06, 0x18, 0x15, 0x3b, 0xba, 0xca, 0x30, 0xea, 0xf0, 0xf6, 0xd5, 0x5b, 0x03, 0x9d,
+	0x1e, 0xf9, 0x87, 0x6a, 0xdf, 0x36, 0xdb, 0x03, 0x7b, 0x60, 0xb7, 0x39, 0xf4, 0xd0, 0x7f, 0xc4,
+	0x7f, 0xf1, 0x1f, 0xfc, 0xaf, 0x80, 0xe2, 0x6a, 0x2b, 0x31, 0x4c, 0xdf, 0x76, 0x89, 0x64, 0x98,
+	0xab, 0x77, 0x63, 0x8c, 0x89, 0xfb, 0x47, 0xba, 0x45, 0xdc, 0x51, 0xdb, 0x39, 0x1e, 0xb0, 0x06,
+	0xaf, 0x6d, 0x12, 0x8a, 0x65, 0x56, 0xed, 0x22, 0x2b, 0xd7, 0xb7, 0xa8, 0x6e, 0x92, 0x9c, 0xc1,
+	0x6b, 0x93, 0x0c, 0xbc, 0xfe, 0x11, 0x31, 0x71, 0xce, 0xee, 0x95, 0x22, 0x3b, 0x9f, 0xea, 0x46,
+	0x5b, 0xb7, 0xa8, 0x47, 0xdd, 0xac, 0x51, 0xeb, 0xbf, 0x0a, 0x80, 0x5d, 0xdb, 0xa2, 0xae, 0x6d,
+	0x18, 0xc4, 0x45, 0x64, 0xa8, 0x7b, 0xba, 0x6d, 0xc1, 0x9f, 0x83, 0x1a, 0x8b, 0x47, 0xc3, 0x14,
+	0xd7, 0x95, 0xeb, 0xca, 0xc6, 0xc2, 0x9d, 0xef, 0xa8, 0xf1, 0x24, 0x47, 0xf4, 0xaa, 0x73, 0x3c,
+	0x60, 0x0d, 0x9e, 0xca, 0xd0, 0xea, 0xf0, 0xb6, 0xba, 0x7b, 0xf8, 0x2e, 0xe9, 0xd3, 0x1e, 0xa1,
+	0xb8, 0x03, 0x9f, 0x9c, 0x34, 0x67, 0xc6, 0x27, 0x4d, 0x10, 0xb7, 0xa1, 0x88, 0x15, 0xee, 0x82,
+	0x0a, 0x67, 0x2f, 0x71, 0xf6, 0x5b, 0x85, 0xec, 0x22, 0x68, 0x15, 0xe1, 0x5f, 0xbc, 0xf1, 0x98,
+	0x12, 0x8b, 0xb9, 0xd7, 0xb9, 0x24, 0xa8, 0x2b, 0x5b, 0x98, 0x62, 0xc4, 0x89, 0xe0, 0xcb, 0xa0,
+	0xe6, 0x0a, 0xf7, 0xeb, 0xe5, 0xeb, 0xca, 0x46, 0xb9, 0x73, 0x59, 0xa0, 0x6a, 0x61, 0x58, 0x28,
+	0x42, 0xb4, 0xfe, 0xa6, 0x80, 0xb5, 0x7c, 0xdc, 0xdb, 0xba, 0x47, 0xe1, 0x3b, 0xb9, 0xd8, 0xd5,
+	0xe9, 0x62, 0x67, 0xd6, 0x3c, 0xf2, 0x68, 0xe0, 0xb0, 0x25, 0x11, 0xf7, 0xdb, 0xa0, 0xaa, 0x53,
+	0x62, 0x7a, 0xf5, 0xd2, 0xf5, 0xf2, 0xc6, 0xc2, 0x9d, 0x1b, 0x6a, 0x3e, 0x77, 0xd5, 0xbc, 0x63,
+	0x9d, 0x45, 0x41, 0x59, 0x7d, 0x8b, 0x19, 0xa3, 0x80, 0xa3, 0xf5, 0x3f, 0x05, 0xcc, 0x6f, 0x61,
+	0x62, 0xda, 0xd6, 0x3e, 0xa1, 0x17, 0xb0, 0x68, 0x5d, 0x50, 0xf1, 0x1c, 0xd2, 0x17, 0x8b, 0xf6,
+	0x0d, 0x99, 0xef, 0x91, 0x3b, 0xfb, 0x0e, 0xe9, 0xc7, 0x0b, 0xc5, 0x7e, 0x21, 0x6e, 0x0c, 0xdf,
+	0x06, 0xb3, 0x1e, 0xc5, 0xd4, 0xf7, 0xf8, 0x32, 0x2d, 0xdc, 0xf9, 0xe6, 0xe9, 0x34, 0x1c, 0xda,
+	0x59, 0x12, 0x44, 0xb3, 0xc1, 0x6f, 0x24, 0x28, 0x5a, 0xff, 0x2e, 0x01, 0x18, 0x61, 0xbb, 0xb6,
+	0xa5, 0xe9, 0x94, 0xe5, 0xef, 0xeb, 0xa0, 0x42, 0x47, 0x0e, 0xe1, 0xd3, 0x30, 0xdf, 0xb9, 0x11,
+	0x7a, 0x71, 0x7f, 0xe4, 0x90, 0x8f, 0x4f, 0x9a, 0x6b, 0x79, 0x0b, 0xd6, 0x83, 0xb8, 0x0d, 0xdc,
+	0x8e, 0xfc, 0x2b, 0x71, 0xeb, 0xbb, 0xe9, 0xa1, 0x3f, 0x3e, 0x69, 0x4a, 0x0e, 0x0b, 0x35, 0x62,
+	0x4a, 0x3b, 0x08, 0x87, 0x00, 0x1a, 0xd8, 0xa3, 0xf7, 0x5d, 0x6c, 0x79, 0xc1, 0x48, 0xba, 0x49,
+	0x44, 0xe4, 0x2f, 0x4d, 0xb7, 0x3c, 0xcc, 0xa2, 0x73, 0x55, 0x78, 0x01, 0xb7, 0x73, 0x6c, 0x48,
+	0x32, 0x02, 0xbc, 0x01, 0x66, 0x5d, 0x82, 0x3d, 0xdb, 0xaa, 0x57, 0x78, 0x14, 0xd1, 0x04, 0x22,
+	0xde, 0x8a, 0x44, 0x2f, 0x7c, 0x11, 0xcc, 0x99, 0xc4, 0xf3, 0xf0, 0x80, 0xd4, 0xab, 0x1c, 0xb8,
+	0x2c, 0x80, 0x73, 0xbd, 0xa0, 0x19, 0x85, 0xfd, 0xad, 0x3f, 0x28, 0x60, 0x31, 0x9a, 0xb9, 0x0b,
+	0xd8, 0x2a, 0x9d, 0xf4, 0x56, 0x79, 0xfe, 0xd4, 0x3c, 0x29, 0xd8, 0x21, 0xef, 0x95, 0x13, 0x3e,
+	0xb3, 0x24, 0x84, 0x3f, 0x03, 0x35, 0x8f, 0x18, 0xa4, 0x4f, 0x6d, 0x57, 0xf8, 0xfc, 0xca, 0x94,
+	0x3e, 0xe3, 0x43, 0x62, 0xec, 0x0b, 0xd3, 0xce, 0x25, 0xe6, 0x74, 0xf8, 0x0b, 0x45, 0x94, 0xf0,
+	0x27, 0xa0, 0x46, 0x89, 0xe9, 0x18, 0x98, 0x12, 0xb1, 0x4d, 0x52, 0xf9, 0xcd, 0xd2, 0x85, 0x91,
+	0xed, 0xd9, 0xda, 0x7d, 0x01, 0xe3, 0x1b, 0x25, 0x9a, 0x87, 0xb0, 0x15, 0x45, 0x34, 0xf0, 0x18,
+	0x2c, 0xf9, 0x8e, 0xc6, 0x90, 0x94, 0x1d, 0xdd, 0x83, 0x91, 0x48, 0x9f, 0x9b, 0xa7, 0x4e, 0xc8,
+	0x41, 0xca, 0xa4, 0xb3, 0x26, 0x06, 0x58, 0x4a, 0xb7, 0xa3, 0x0c, 0x35, 0xdc, 0x04, 0xcb, 0xa6,
+	0x6e, 0x21, 0x82, 0xb5, 0xd1, 0x3e, 0xe9, 0xdb, 0x96, 0xe6, 0xf1, 0x04, 0xaa, 0x76, 0xd6, 0x05,
+	0xc1, 0x72, 0x2f, 0xdd, 0x8d, 0xb2, 0x78, 0xb8, 0x0d, 0x56, 0xc3, 0x73, 0xf6, 0x47, 0xba, 0x47,
+	0x6d, 0x77, 0xb4, 0xad, 0x9b, 0x3a, 0xad, 0xcf, 0x72, 0x9e, 0xfa, 0xf8, 0xa4, 0xb9, 0x8a, 0x24,
+	0xfd, 0x48, 0x6a, 0xd5, 0xfa, 0xed, 0x2c, 0x58, 0xce, 0x9c, 0x06, 0xf0, 0x01, 0x58, 0xeb, 0xfb,
+	0xae, 0x4b, 0x2c, 0xba, 0xe3, 0x9b, 0x87, 0xc4, 0xdd, 0xef, 0x1f, 0x11, 0xcd, 0x37, 0x88, 0xc6,
+	0x57, 0xb4, 0xda, 0x69, 0x08, 0x5f, 0xd7, 0xba, 0x52, 0x14, 0x2a, 0xb0, 0x86, 0x3f, 0x06, 0xd0,
+	0xe2, 0x4d, 0x3d, 0xdd, 0xf3, 0x22, 0xce, 0x12, 0xe7, 0x8c, 0x36, 0xe0, 0x4e, 0x0e, 0x81, 0x24,
+	0x56, 0xcc, 0x47, 0x8d, 0x78, 0xba, 0x4b, 0xb4, 0xac, 0x8f, 0xe5, 0xb4, 0x8f, 0x5b, 0x52, 0x14,
+	0x2a, 0xb0, 0x86, 0xaf, 0x82, 0x85, 0x60, 0x34, 0x3e, 0xe7, 0x62, 0x71, 0x56, 0x04, 0xd9, 0xc2,
+	0x4e, 0xdc, 0x85, 0x92, 0x38, 0x16, 0x9a, 0x7d, 0xe8, 0x11, 0x77, 0x48, 0xb4, 0x37, 0x03, 0x0d,
+	0xc0, 0x0a, 0x65, 0x95, 0x17, 0xca, 0x28, 0xb4, 0xdd, 0x1c, 0x02, 0x49, 0xac, 0x58, 0x68, 0x41,
+	0xd6, 0xe4, 0x42, 0x9b, 0x4d, 0x87, 0x76, 0x20, 0x45, 0xa1, 0x02, 0x6b, 0x96, 0x7b, 0x81, 0xcb,
+	0x9b, 0x43, 0xac, 0x1b, 0xf8, 0xd0, 0x20, 0xf5, 0xb9, 0x74, 0xee, 0xed, 0xa4, 0xbb, 0x51, 0x16,
+	0x0f, 0xdf, 0x04, 0x57, 0x82, 0xa6, 0x03, 0x0b, 0x47, 0x24, 0x35, 0x4e, 0xf2, 0x9c, 0x20, 0xb9,
+	0xb2, 0x93, 0x05, 0xa0, 0xbc, 0x0d, 0x7c, 0x1d, 0x2c, 0xf5, 0x6d, 0xc3, 0xe0, 0xf9, 0xd8, 0xb5,
+	0x7d, 0x8b, 0xd6, 0xe7, 0x39, 0x0b, 0x64, 0x7b, 0xa8, 0x9b, 0xea, 0x41, 0x19, 0x24, 0x7c, 0x08,
+	0x40, 0x3f, 0x2c, 0x07, 0x5e, 0x1d, 0x14, 0x17, 0xfa, 0x7c, 0x1d, 0x8a, 0x0b, 0x70, 0xd4, 0xe4,
+	0xa1, 0x04, 0x5b, 0xeb, 0x3d, 0x05, 0xac, 0x17, 0xec, 0x71, 0xf8, 0x83, 0x54, 0xd5, 0xbb, 0x99,
+	0xa9, 0x7a, 0xd7, 0x0a, 0xcc, 0x12, 0xa5, 0xaf, 0x0f, 0x16, 0x99, 0xee, 0xd0, 0xad, 0x41, 0x00,
+	0x11, 0x27, 0xd8, 0x4b, 0x32, 0xdf, 0x51, 0x12, 0x18, 0x1f, 0xc3, 0x57, 0xc6, 0x27, 0xcd, 0xc5,
+	0x54, 0x1f, 0x4a, 0x73, 0xb6, 0x7e, 0x5d, 0x02, 0x60, 0x8b, 0x38, 0x86, 0x3d, 0x32, 0x89, 0x75,
+	0x11, 0xaa, 0x65, 0x2b, 0xa5, 0x5a, 0x5a, 0xd2, 0x85, 0x88, 0xfc, 0x29, 0x94, 0x2d, 0xdb, 0x19,
+	0xd9, 0xf2, 0xad, 0x09, 0x3c, 0xa7, 0xeb, 0x96, 0x7f, 0x96, 0xc1, 0x4a, 0x0c, 0x8e, 0x85, 0xcb,
+	0xbd, 0xd4, 0x12, 0xbe, 0x90, 0x59, 0xc2, 0x75, 0x89, 0xc9, 0xa7, 0xa6, 0x5c, 0xde, 0x05, 0x4b,
+	0x4c, 0x57, 0x04, 0xab, 0xc6, 0x55, 0xcb, 0xec, 0x99, 0x55, 0x4b, 0x54, 0x75, 0xb6, 0x53, 0x4c,
+	0x28, 0xc3, 0x5c, 0xa0, 0x92, 0xe6, 0xbe, 0x88, 0x2a, 0xe9, 0x8f, 0x0a, 0x58, 0x8a, 0x97, 0xe9,
+	0x02, 0x64, 0x52, 0x37, 0x2d, 0x93, 0x1a, 0xa7, 0xe7, 0x65, 0x81, 0x4e, 0xfa, 0x47, 0x25, 0xe9,
+	0x35, 0x17, 0x4a, 0x1b, 0xec, 0x83, 0xca, 0x31, 0xf4, 0x3e, 0xf6, 0x44, 0x59, 0xbd, 0x14, 0x7c,
+	0x4c, 0x05, 0x6d, 0x28, 0xea, 0x4d, 0x49, 0xaa, 0xd2, 0xa7, 0x2b, 0xa9, 0xca, 0x9f, 0x8c, 0xa4,
+	0xba, 0x0f, 0x6a, 0x5e, 0x28, 0xa6, 0x2a, 0x9c, 0xf2, 0xc6, 0xa4, 0xed, 0x2c, 0x74, 0x54, 0xc4,
+	0x1a, 0x29, 0xa8, 0x88, 0x49, 0xa6, 0x9d, 0xaa, 0x9f, 0xa5, 0x76, 0x62, 0xe9, 0xed, 0x60, 0xdf,
+	0x23, 0x1a, 0xdf, 0x4a, 0xb5, 0x38, 0xbd, 0xf7, 0x78, 0x2b, 0x12, 0xbd, 0xf0, 0x00, 0xac, 0x3b,
+	0xae, 0x3d, 0x70, 0x89, 0xe7, 0x6d, 0x11, 0xac, 0x19, 0xba, 0x45, 0xc2, 0x00, 0x82, 0xaa, 0x77,
+	0x6d, 0x7c, 0xd2, 0x5c, 0xdf, 0x93, 0x43, 0x50, 0x91, 0x6d, 0xeb, 0x2f, 0x15, 0x70, 0x39, 0x7b,
+	0x22, 0x16, 0x08, 0x11, 0xe5, 0x5c, 0x42, 0xe4, 0xe5, 0x44, 0x8a, 0x06, 0x2a, 0x2d, 0xf1, 0xcd,
+	0x9f, 0x4b, 0xd3, 0x4d, 0xb0, 0x2c, 0x84, 0x47, 0xd8, 0x29, 0xa4, 0x58, 0xb4, 0x3c, 0x07, 0xe9,
+	0x6e, 0x94, 0xc5, 0xc3, 0x7b, 0x60, 0xd1, 0xe5, 0xda, 0x2a, 0x24, 0x08, 0xf4, 0xc9, 0xd7, 0x04,
+	0xc1, 0x22, 0x4a, 0x76, 0xa2, 0x34, 0x96, 0x69, 0x93, 0x58, 0x72, 0x84, 0x04, 0x95, 0xb4, 0x36,
+	0xd9, 0xcc, 0x02, 0x50, 0xde, 0x06, 0xf6, 0xc0, 0x8a, 0x6f, 0xe5, 0xa9, 0x82, 0x5c, 0xbb, 0x26,
+	0xa8, 0x56, 0x0e, 0xf2, 0x10, 0x24, 0xb3, 0x83, 0x3f, 0x4d, 0xc9, 0x95, 0x59, 0x7e, 0x8a, 0xbc,
+	0x70, 0xfa, 0x76, 0x98, 0x5a, 0xaf, 0x48, 0x74, 0x54, 0x6d, 0x5a, 0x1d, 0xd5, 0xfa, 0xb3, 0x02,
+	0x60, 0x7e, 0x0b, 0x4e, 0xfc, 0xb8, 0xcf, 0x59, 0x24, 0x4a, 0xa4, 0x26, 0x57, 0x38, 0x37, 0x27,
+	0x2b, 0x9c, 0xf8, 0x04, 0x9d, 0x4e, 0xe2, 0x88, 0xe9, 0xbd, 0x98, 0x8b, 0x99, 0x29, 0x24, 0x4e,
+	0xec, 0xcf, 0xb3, 0x49, 0x9c, 0x04, 0xcf, 0xe9, 0x12, 0xe7, 0x3f, 0x25, 0xb0, 0x12, 0x83, 0xa7,
+	0x96, 0x38, 0x12, 0x93, 0xaf, 0x2e, 0x67, 0xa6, 0x93, 0x1d, 0xf1, 0xd4, 0x7d, 0x4e, 0x64, 0x47,
+	0xec, 0x50, 0x81, 0xec, 0xf8, 0x7d, 0x29, 0xe9, 0xf5, 0x19, 0x65, 0xc7, 0x27, 0x70, 0x55, 0xf1,
+	0x85, 0x53, 0x2e, 0xad, 0xbf, 0x96, 0xc1, 0xe5, 0xec, 0x16, 0x4c, 0xd5, 0x41, 0x65, 0x62, 0x1d,
+	0xdc, 0x03, 0xab, 0x8f, 0x7c, 0xc3, 0x18, 0xf1, 0x18, 0x12, 0xc5, 0x30, 0xa8, 0xa0, 0x5f, 0x17,
+	0x96, 0xab, 0x3f, 0x94, 0x60, 0x90, 0xd4, 0x32, 0x5f, 0x16, 0x2b, 0xcf, 0x5a, 0x16, 0xab, 0xe7,
+	0x28, 0x8b, 0x72, 0x65, 0x51, 0x3e, 0x97, 0xb2, 0x98, 0xba, 0x26, 0x4a, 0x8e, 0xab, 0x89, 0xdf,
+	0xf0, 0x63, 0x05, 0xac, 0xc9, 0x3f, 0x9f, 0xa1, 0x01, 0x96, 0x4c, 0xfc, 0x38, 0x79, 0x79, 0x31,
+	0xa9, 0x60, 0xf8, 0x54, 0x37, 0xd4, 0xe0, 0x75, 0x47, 0x7d, 0xcb, 0xa2, 0xbb, 0xee, 0x3e, 0x75,
+	0x75, 0x6b, 0x10, 0x14, 0xd8, 0x5e, 0x8a, 0x0b, 0x65, 0xb8, 0xe1, 0x43, 0x50, 0x33, 0xf1, 0xe3,
+	0x7d, 0xdf, 0x1d, 0x84, 0x85, 0xf0, 0xec, 0xe3, 0xf0, 0xdc, 0xef, 0x09, 0x16, 0x14, 0xf1, 0xb5,
+	0x3e, 0x54, 0xc0, 0x7a, 0x41, 0x05, 0xfd, 0x12, 0x45, 0xb9, 0x0b, 0xae, 0xa7, 0x82, 0x64, 0x1b,
+	0x92, 0x3c, 0xf2, 0x0d, 0xbe, 0x37, 0x85, 0x5e, 0xb9, 0x09, 0xe6, 0x1d, 0xec, 0x52, 0x3d, 0x12,
+	0xba, 0xd5, 0xce, 0xe2, 0xf8, 0xa4, 0x39, 0xbf, 0x17, 0x36, 0xa2, 0xb8, 0xbf, 0xf5, 0x9b, 0x12,
+	0x58, 0x48, 0x90, 0x5c, 0x80, 0x76, 0x78, 0x23, 0xa5, 0x1d, 0xa4, 0xaf, 0x31, 0xc9, 0xa8, 0x8a,
+	0xc4, 0x43, 0x2f, 0x23, 0x1e, 0xbe, 0x3d, 0x89, 0xe8, 0x74, 0xf5, 0xf0, 0x51, 0x09, 0xac, 0x26,
+	0xd0, 0xb1, 0x7c, 0xf8, 0x5e, 0x4a, 0x3e, 0x6c, 0x64, 0xe4, 0x43, 0x5d, 0x66, 0xf3, 0x95, 0x7e,
+	0x98, 0xac, 0x1f, 0xfe, 0xa4, 0x80, 0xe5, 0xc4, 0xdc, 0x5d, 0x80, 0x80, 0xd8, 0x4a, 0x0b, 0x88,
+	0xe6, 0x84, 0x7c, 0x29, 0x50, 0x10, 0x4f, 0xaa, 0x29, 0xbf, 0xbf, 0xf4, 0x37, 0x17, 0xbf, 0x04,
+	0xab, 0x43, 0xdb, 0xf0, 0x4d, 0xd2, 0x35, 0xb0, 0x6e, 0x86, 0x00, 0x56, 0x71, 0xd9, 0x24, 0xbe,
+	0x28, 0xa5, 0x27, 0xae, 0xa7, 0x7b, 0x94, 0x58, 0xf4, 0x41, 0x6c, 0x19, 0xd7, 0xf9, 0x07, 0x12,
+	0x3a, 0x24, 0x1d, 0x04, 0xbe, 0x0a, 0x16, 0x58, 0xa5, 0xd4, 0xfb, 0x64, 0x07, 0x9b, 0x61, 0x4e,
+	0x45, 0x6f, 0x0f, 0xfb, 0x71, 0x17, 0x4a, 0xe2, 0xe0, 0x11, 0x58, 0x71, 0x6c, 0xad, 0x87, 0x2d,
+	0x3c, 0x20, 0xec, 0xfc, 0xdf, 0xb3, 0x0d, 0xbd, 0x3f, 0xe2, 0x77, 0x1a, 0xf3, 0x9d, 0xd7, 0xc2,
+	0xef, 0xd5, 0xbd, 0x3c, 0x84, 0x7d, 0x0f, 0x48, 0x9a, 0xf9, 0x7e, 0x96, 0x51, 0x42, 0x33, 0xf7,
+	0x54, 0x36, 0x97, 0xfb, 0xff, 0x02, 0x59, 0x72, 0x9d, 0xf3, 0xb1, 0xac, 0xe8, 0xb6, 0xa6, 0x76,
+	0xae, 0x97, 0xae, 0x8f, 0x2a, 0xe0, 0x4a, 0xee, 0x80, 0xfc, 0x0c, 0xef, 0x4b, 0x72, 0xaa, 0xae,
+	0x7c, 0x06, 0x55, 0xb7, 0x09, 0x96, 0xc5, 0x23, 0x5b, 0x46, 0x14, 0x46, 0xe2, 0xbc, 0x9b, 0xee,
+	0x46, 0x59, 0xbc, 0xec, 0xbe, 0xa6, 0x7a, 0xc6, 0xfb, 0x9a, 0xa4, 0x17, 0xe2, 0x7f, 0x43, 0x82,
+	0xac, 0xcb, 0x7b, 0x21, 0xfe, 0x45, 0x24, 0x8b, 0x87, 0xdf, 0x0f, 0x53, 0x2a, 0x62, 0x98, 0xe3,
+	0x0c, 0x99, 0x1c, 0x89, 0x08, 0x32, 0xe8, 0x67, 0x7a, 0x48, 0x7a, 0x47, 0xf2, 0x90, 0xb4, 0x31,
+	0x21, 0x95, 0xa7, 0x97, 0xa1, 0x7f, 0x57, 0xc0, 0x73, 0x85, 0x7b, 0x00, 0x6e, 0xa6, 0xea, 0xec,
+	0xad, 0x4c, 0x9d, 0x7d, 0xbe, 0xd0, 0x30, 0x51, 0x6c, 0x4d, 0xf9, 0x65, 0xcb, 0xdd, 0x89, 0x97,
+	0x2d, 0x12, 0x15, 0x35, 0xf9, 0xd6, 0xa5, 0xb3, 0xf1, 0xe4, 0x69, 0x63, 0xe6, 0xfd, 0xa7, 0x8d,
+	0x99, 0x0f, 0x9e, 0x36, 0x66, 0x7e, 0x35, 0x6e, 0x28, 0x4f, 0xc6, 0x0d, 0xe5, 0xfd, 0x71, 0x43,
+	0xf9, 0x60, 0xdc, 0x50, 0xfe, 0x35, 0x6e, 0x28, 0xbf, 0xfb, 0xb0, 0x31, 0xf3, 0xb0, 0x34, 0xbc,
+	0xfd, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xe6, 0xc9, 0x16, 0xd9, 0x6e, 0x26, 0x00, 0x00,
 }
 
 func (m *ControllerRevision) Marshal() (dAtA []byte, err error) {
@@ -2035,6 +2035,18 @@ func (m *RollingUpdateDaemonSet) MarshalToSizedBuffer(dAtA []byte) (int, error)
 	_ = i
 	var l int
 	_ = l
+	if m.MaxSurge != nil {
+		{
+			size, err := m.MaxSurge.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintGenerated(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x12
+	}
 	if m.MaxUnavailable != nil {
 		{
 			size, err := m.MaxUnavailable.MarshalToSizedBuffer(dAtA[:i])
@@ -2849,6 +2861,10 @@ func (m *RollingUpdateDaemonSet) Size() (n int) {
 		l = m.MaxUnavailable.Size()
 		n += 1 + l + sovGenerated(uint64(l))
 	}
+	if m.MaxSurge != nil {
+		l = m.MaxSurge.Size()
+		n += 1 + l + sovGenerated(uint64(l))
+	}
 	return n
 }
 
@@ -3306,6 +3322,7 @@ func (this *RollingUpdateDaemonSet) String() string {
 	}
 	s := strings.Join([]string{`&RollingUpdateDaemonSet{`,
 		`MaxUnavailable:` + strings.Replace(fmt.Sprintf("%v", this.MaxUnavailable), "IntOrString", "intstr.IntOrString", 1) + `,`,
+		`MaxSurge:` + strings.Replace(fmt.Sprintf("%v", this.MaxSurge), "IntOrString", "intstr.IntOrString", 1) + `,`,
 		`}`,
 	}, "")
 	return s
@@ -6764,6 +6781,42 @@ func (m *RollingUpdateDaemonSet) Unmarshal(dAtA []byte) error {
 				return err
 			}
 			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field MaxSurge", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenerated
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.MaxSurge == nil {
+				m.MaxSurge = &intstr.IntOrString{}
+			}
+			if err := m.MaxSurge.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipGenerated(dAtA[iNdEx:])
diff --git a/staging/src/k8s.io/api/apps/v1/generated.proto b/staging/src/k8s.io/api/apps/v1/generated.proto
index 3ee640462d6..d4689d88b51 100644
--- a/staging/src/k8s.io/api/apps/v1/generated.proto
+++ b/staging/src/k8s.io/api/apps/v1/generated.proto
@@ -479,19 +479,41 @@ message RollingUpdateDaemonSet {
   // The maximum number of DaemonSet pods that can be unavailable during the
   // update. Value can be an absolute number (ex: 5) or a percentage of total
   // number of DaemonSet pods at the start of the update (ex: 10%). Absolute
-  // number is calculated from percentage by rounding up.
-  // This cannot be 0.
+  // number is calculated from percentage by rounding down to a minimum of one.
+  // This cannot be 0 if MaxSurge is 0
   // Default value is 1.
   // Example: when this is set to 30%, at most 30% of the total number of nodes
   // that should be running the daemon pod (i.e. status.desiredNumberScheduled)
-  // can have their pods stopped for an update at any given
-  // time. The update starts by stopping at most 30% of those DaemonSet pods
-  // and then brings up new DaemonSet pods in their place. Once the new pods
-  // are available, it then proceeds onto other DaemonSet pods, thus ensuring
-  // that at least 70% of original number of DaemonSet pods are available at
-  // all times during the update.
+  // can have their pods stopped for an update at any given time. The update
+  // starts by stopping at most 30% of those DaemonSet pods and then brings
+  // up new DaemonSet pods in their place. Once the new pods are available,
+  // it then proceeds onto other DaemonSet pods, thus ensuring that at least
+  // 70% of original number of DaemonSet pods are available at all times during
+  // the update.
   // +optional
   optional k8s.io.apimachinery.pkg.util.intstr.IntOrString maxUnavailable = 1;
+
+  // The maximum number of nodes with an existing available DaemonSet pod that
+  // can have an updated DaemonSet pod during during an update.
+  // Value can be an absolute number (ex: 5) or a percentage of desired pods (ex: 10%).
+  // This can not be 0 if MaxUnavailable is 0.
+  // Absolute number is calculated from percentage by rounding up to a minimum of 1.
+  // Default value is 0.
+  // Example: when this is set to 30%, at most 30% of the total number of nodes
+  // that should be running the daemon pod (i.e. status.desiredNumberScheduled)
+  // can have their a new pod created before the old pod is marked as deleted.
+  // The update starts by launching new pods on 30% of nodes. Once an updated
+  // pod is available (Ready for at least minReadySeconds) the old DaemonSet pod
+  // on that node is marked deleted. If the old pod becomes unavailable for any
+  // reason (Ready transitions to false, is evicted, or is drained) an updated
+  // pod is immediatedly created on that node without considering surge limits.
+  // Allowing surge implies the possibility that the resources consumed by the
+  // daemonset on any given node can double if the readiness check fails, and
+  // so resource intensive daemonsets should take into account that they may
+  // cause evictions during disruption.
+  // This is an alpha field and requires enabling DaemonSetUpdateSurge feature gate.
+  // +optional
+  optional k8s.io.apimachinery.pkg.util.intstr.IntOrString maxSurge = 2;
 }
 
 // Spec to control the desired behavior of rolling update.
diff --git a/staging/src/k8s.io/api/apps/v1/types.go b/staging/src/k8s.io/api/apps/v1/types.go
index e003a0c4f7c..48299f18ecb 100644
--- a/staging/src/k8s.io/api/apps/v1/types.go
+++ b/staging/src/k8s.io/api/apps/v1/types.go
@@ -488,19 +488,41 @@ type RollingUpdateDaemonSet struct {
 	// The maximum number of DaemonSet pods that can be unavailable during the
 	// update. Value can be an absolute number (ex: 5) or a percentage of total
 	// number of DaemonSet pods at the start of the update (ex: 10%). Absolute
-	// number is calculated from percentage by rounding up.
-	// This cannot be 0.
+	// number is calculated from percentage by rounding down to a minimum of one.
+	// This cannot be 0 if MaxSurge is 0
 	// Default value is 1.
 	// Example: when this is set to 30%, at most 30% of the total number of nodes
 	// that should be running the daemon pod (i.e. status.desiredNumberScheduled)
-	// can have their pods stopped for an update at any given
-	// time. The update starts by stopping at most 30% of those DaemonSet pods
-	// and then brings up new DaemonSet pods in their place. Once the new pods
-	// are available, it then proceeds onto other DaemonSet pods, thus ensuring
-	// that at least 70% of original number of DaemonSet pods are available at
-	// all times during the update.
+	// can have their pods stopped for an update at any given time. The update
+	// starts by stopping at most 30% of those DaemonSet pods and then brings
+	// up new DaemonSet pods in their place. Once the new pods are available,
+	// it then proceeds onto other DaemonSet pods, thus ensuring that at least
+	// 70% of original number of DaemonSet pods are available at all times during
+	// the update.
 	// +optional
 	MaxUnavailable *intstr.IntOrString `json:"maxUnavailable,omitempty" protobuf:"bytes,1,opt,name=maxUnavailable"`
+
+	// The maximum number of nodes with an existing available DaemonSet pod that
+	// can have an updated DaemonSet pod during during an update.
+	// Value can be an absolute number (ex: 5) or a percentage of desired pods (ex: 10%).
+	// This can not be 0 if MaxUnavailable is 0.
+	// Absolute number is calculated from percentage by rounding up to a minimum of 1.
+	// Default value is 0.
+	// Example: when this is set to 30%, at most 30% of the total number of nodes
+	// that should be running the daemon pod (i.e. status.desiredNumberScheduled)
+	// can have their a new pod created before the old pod is marked as deleted.
+	// The update starts by launching new pods on 30% of nodes. Once an updated
+	// pod is available (Ready for at least minReadySeconds) the old DaemonSet pod
+	// on that node is marked deleted. If the old pod becomes unavailable for any
+	// reason (Ready transitions to false, is evicted, or is drained) an updated
+	// pod is immediatedly created on that node without considering surge limits.
+	// Allowing surge implies the possibility that the resources consumed by the
+	// daemonset on any given node can double if the readiness check fails, and
+	// so resource intensive daemonsets should take into account that they may
+	// cause evictions during disruption.
+	// This is an alpha field and requires enabling DaemonSetUpdateSurge feature gate.
+	// +optional
+	MaxSurge *intstr.IntOrString `json:"maxSurge,omitempty" protobuf:"bytes,2,opt,name=maxSurge"`
 }
 
 // DaemonSetSpec is the specification of a daemon set.
diff --git a/staging/src/k8s.io/api/apps/v1/types_swagger_doc_generated.go b/staging/src/k8s.io/api/apps/v1/types_swagger_doc_generated.go
index 3f0299d0333..b9783ad20ed 100644
--- a/staging/src/k8s.io/api/apps/v1/types_swagger_doc_generated.go
+++ b/staging/src/k8s.io/api/apps/v1/types_swagger_doc_generated.go
@@ -262,7 +262,8 @@ func (ReplicaSetStatus) SwaggerDoc() map[string]string {
 
 var map_RollingUpdateDaemonSet = map[string]string{
 	"":               "Spec to control the desired behavior of daemon set rolling update.",
-	"maxUnavailable": "The maximum number of DaemonSet pods that can be unavailable during the update. Value can be an absolute number (ex: 5) or a percentage of total number of DaemonSet pods at the start of the update (ex: 10%). Absolute number is calculated from percentage by rounding up. This cannot be 0. Default value is 1. Example: when this is set to 30%, at most 30% of the total number of nodes that should be running the daemon pod (i.e. status.desiredNumberScheduled) can have their pods stopped for an update at any given time. The update starts by stopping at most 30% of those DaemonSet pods and then brings up new DaemonSet pods in their place. Once the new pods are available, it then proceeds onto other DaemonSet pods, thus ensuring that at least 70% of original number of DaemonSet pods are available at all times during the update.",
+	"maxUnavailable": "The maximum number of DaemonSet pods that can be unavailable during the update. Value can be an absolute number (ex: 5) or a percentage of total number of DaemonSet pods at the start of the update (ex: 10%). Absolute number is calculated from percentage by rounding down to a minimum of one. This cannot be 0 if MaxSurge is 0 Default value is 1. Example: when this is set to 30%, at most 30% of the total number of nodes that should be running the daemon pod (i.e. status.desiredNumberScheduled) can have their pods stopped for an update at any given time. The update starts by stopping at most 30% of those DaemonSet pods and then brings up new DaemonSet pods in their place. Once the new pods are available, it then proceeds onto other DaemonSet pods, thus ensuring that at least 70% of original number of DaemonSet pods are available at all times during the update.",
+	"maxSurge":       "The maximum number of nodes with an existing available DaemonSet pod that can have an updated DaemonSet pod during during an update. Value can be an absolute number (ex: 5) or a percentage of desired pods (ex: 10%). This can not be 0 if MaxUnavailable is 0. Absolute number is calculated from percentage by rounding up to a minimum of 1. Default value is 0. Example: when this is set to 30%, at most 30% of the total number of nodes that should be running the daemon pod (i.e. status.desiredNumberScheduled) can have their a new pod created before the old pod is marked as deleted. The update starts by launching new pods on 30% of nodes. Once an updated pod is available (Ready for at least minReadySeconds) the old DaemonSet pod on that node is marked deleted. If the old pod becomes unavailable for any reason (Ready transitions to false, is evicted, or is drained) an updated pod is immediatedly created on that node without considering surge limits. Allowing surge implies the possibility that the resources consumed by the daemonset on any given node can double if the readiness check fails, and so resource intensive daemonsets should take into account that they may cause evictions during disruption. This is an alpha field and requires enabling DaemonSetUpdateSurge feature gate.",
 }
 
 func (RollingUpdateDaemonSet) SwaggerDoc() map[string]string {
diff --git a/staging/src/k8s.io/api/apps/v1/zz_generated.deepcopy.go b/staging/src/k8s.io/api/apps/v1/zz_generated.deepcopy.go
index 7b7ff385c62..0c80548521d 100644
--- a/staging/src/k8s.io/api/apps/v1/zz_generated.deepcopy.go
+++ b/staging/src/k8s.io/api/apps/v1/zz_generated.deepcopy.go
@@ -544,6 +544,11 @@ func (in *RollingUpdateDaemonSet) DeepCopyInto(out *RollingUpdateDaemonSet) {
 		*out = new(intstr.IntOrString)
 		**out = **in
 	}
+	if in.MaxSurge != nil {
+		in, out := &in.MaxSurge, &out.MaxSurge
+		*out = new(intstr.IntOrString)
+		**out = **in
+	}
 	return
 }
 
diff --git a/staging/src/k8s.io/api/apps/v1beta2/generated.pb.go b/staging/src/k8s.io/api/apps/v1beta2/generated.pb.go
index 8a9f20052b3..0ed8138e549 100644
--- a/staging/src/k8s.io/api/apps/v1beta2/generated.pb.go
+++ b/staging/src/k8s.io/api/apps/v1beta2/generated.pb.go
@@ -957,143 +957,143 @@ func init() {
 }
 
 var fileDescriptor_42fe616264472f7e = []byte{
-	// 2171 bytes of a gzipped FileDescriptorProto
+	// 2169 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x5a, 0xcd, 0x6f, 0x1c, 0xb7,
 	0xf9, 0xd6, 0xec, 0x87, 0xb4, 0xa2, 0x2c, 0xc9, 0xa6, 0xf4, 0x93, 0x36, 0xf2, 0xaf, 0x2b, 0x63,
 	0x13, 0x38, 0x4a, 0x6c, 0xcd, 0xda, 0xca, 0x07, 0x12, 0xbb, 0x68, 0xab, 0x95, 0x52, 0xdb, 0x81,
 	0xbe, 0x42, 0x59, 0x06, 0x1a, 0xb4, 0xa8, 0xa9, 0x5d, 0x7a, 0x35, 0xd1, 0x7c, 0x61, 0x86, 0xb3,
-	0xf5, 0xa2, 0x97, 0x9e, 0x0a, 0x14, 0x28, 0xd0, 0xf6, 0xda, 0x7f, 0xa2, 0xb7, 0xa2, 0x68, 0x6f,
-	0x45, 0x50, 0xf8, 0x52, 0x20, 0xe8, 0x25, 0x39, 0x09, 0xf5, 0xe6, 0x54, 0x14, 0xbd, 0x14, 0xe8,
-	0x25, 0x40, 0x81, 0x82, 0x1c, 0xce, 0x07, 0xe7, 0xc3, 0x3b, 0x52, 0x1c, 0xa5, 0x29, 0x72, 0xd3,
-	0x92, 0xcf, 0xfb, 0xf0, 0x7d, 0xc9, 0x97, 0x7c, 0x1f, 0x72, 0x04, 0xbe, 0x73, 0xfc, 0x96, 0xab,
-	0x6a, 0x56, 0xeb, 0xd8, 0x3b, 0x24, 0x8e, 0x49, 0x28, 0x71, 0x5b, 0x7d, 0x62, 0x76, 0x2d, 0xa7,
-	0x25, 0x3a, 0xb0, 0xad, 0xb5, 0xb0, 0x6d, 0xbb, 0xad, 0xfe, 0xcd, 0x43, 0x42, 0xf1, 0x5a, 0xab,
-	0x47, 0x4c, 0xe2, 0x60, 0x4a, 0xba, 0xaa, 0xed, 0x58, 0xd4, 0x82, 0x8b, 0x3e, 0x50, 0xc5, 0xb6,
-	0xa6, 0x32, 0xa0, 0x2a, 0x80, 0x4b, 0xab, 0x3d, 0x8d, 0x1e, 0x79, 0x87, 0x6a, 0xc7, 0x32, 0x5a,
-	0x3d, 0xab, 0x67, 0xb5, 0x38, 0xfe, 0xd0, 0x7b, 0xc4, 0x7f, 0xf1, 0x1f, 0xfc, 0x2f, 0x9f, 0x67,
-	0xa9, 0x19, 0x1b, 0xb0, 0x63, 0x39, 0xa4, 0xd5, 0xbf, 0x99, 0x1c, 0x6b, 0xe9, 0xf5, 0x08, 0x63,
-	0xe0, 0xce, 0x91, 0x66, 0x12, 0x67, 0xd0, 0xb2, 0x8f, 0x7b, 0xac, 0xc1, 0x6d, 0x19, 0x84, 0xe2,
-	0x2c, 0xab, 0x56, 0x9e, 0x95, 0xe3, 0x99, 0x54, 0x33, 0x48, 0xca, 0xe0, 0xcd, 0x51, 0x06, 0x6e,
-	0xe7, 0x88, 0x18, 0x38, 0x65, 0xf7, 0x5a, 0x9e, 0x9d, 0x47, 0x35, 0xbd, 0xa5, 0x99, 0xd4, 0xa5,
-	0x4e, 0xd2, 0xa8, 0xf9, 0x2f, 0x05, 0xc0, 0x0d, 0xcb, 0xa4, 0x8e, 0xa5, 0xeb, 0xc4, 0x41, 0xa4,
-	0xaf, 0xb9, 0x9a, 0x65, 0xc2, 0x87, 0xa0, 0xc6, 0xe2, 0xe9, 0x62, 0x8a, 0xeb, 0xca, 0x15, 0x65,
-	0x65, 0x6a, 0xed, 0x86, 0x1a, 0xcd, 0x74, 0x48, 0xaf, 0xda, 0xc7, 0x3d, 0xd6, 0xe0, 0xaa, 0x0c,
-	0xad, 0xf6, 0x6f, 0xaa, 0xbb, 0x87, 0x1f, 0x90, 0x0e, 0xdd, 0x26, 0x14, 0xb7, 0xe1, 0x93, 0x93,
-	0xe5, 0xb1, 0xe1, 0xc9, 0x32, 0x88, 0xda, 0x50, 0xc8, 0x0a, 0x77, 0x41, 0x85, 0xb3, 0x97, 0x38,
-	0xfb, 0x6a, 0x2e, 0xbb, 0x08, 0x5a, 0x45, 0xf8, 0x47, 0xef, 0x3c, 0xa6, 0xc4, 0x64, 0xee, 0xb5,
-	0x2f, 0x08, 0xea, 0xca, 0x26, 0xa6, 0x18, 0x71, 0x22, 0x78, 0x1d, 0xd4, 0x1c, 0xe1, 0x7e, 0xbd,
-	0x7c, 0x45, 0x59, 0x29, 0xb7, 0x2f, 0x0a, 0x54, 0x2d, 0x08, 0x0b, 0x85, 0x88, 0xe6, 0x13, 0x05,
-	0x2c, 0xa4, 0xe3, 0xde, 0xd2, 0x5c, 0x0a, 0xbf, 0x9f, 0x8a, 0x5d, 0x2d, 0x16, 0x3b, 0xb3, 0xe6,
-	0x91, 0x87, 0x03, 0x07, 0x2d, 0xb1, 0xb8, 0xf7, 0x40, 0x55, 0xa3, 0xc4, 0x70, 0xeb, 0xa5, 0x2b,
-	0xe5, 0x95, 0xa9, 0xb5, 0x6b, 0x6a, 0x4e, 0x02, 0xab, 0x69, 0xef, 0xda, 0xd3, 0x82, 0xb7, 0x7a,
-	0x8f, 0x31, 0x20, 0x9f, 0xa8, 0xf9, 0xb3, 0x12, 0x98, 0xdc, 0xc4, 0xc4, 0xb0, 0xcc, 0x7d, 0x42,
-	0xcf, 0x61, 0xe5, 0xee, 0x82, 0x8a, 0x6b, 0x93, 0x8e, 0x58, 0xb9, 0xab, 0xb9, 0x01, 0x84, 0x3e,
-	0xed, 0xdb, 0xa4, 0x13, 0x2d, 0x19, 0xfb, 0x85, 0x38, 0x03, 0xdc, 0x03, 0xe3, 0x2e, 0xc5, 0xd4,
-	0x73, 0xf9, 0x82, 0x4d, 0xad, 0xad, 0x14, 0xe0, 0xe2, 0xf8, 0xf6, 0x8c, 0x60, 0x1b, 0xf7, 0x7f,
-	0x23, 0xc1, 0xd3, 0xfc, 0x5b, 0x09, 0xc0, 0x10, 0xbb, 0x61, 0x99, 0x5d, 0x8d, 0xb2, 0x74, 0xbe,
-	0x05, 0x2a, 0x74, 0x60, 0x13, 0x3e, 0x21, 0x93, 0xed, 0xab, 0x81, 0x2b, 0xf7, 0x07, 0x36, 0xf9,
-	0xec, 0x64, 0x79, 0x21, 0x6d, 0xc1, 0x7a, 0x10, 0xb7, 0x81, 0x5b, 0xa1, 0x93, 0x25, 0x6e, 0xfd,
-	0xba, 0x3c, 0xf4, 0x67, 0x27, 0xcb, 0x19, 0x67, 0x87, 0x1a, 0x32, 0xc9, 0x0e, 0xc2, 0x3e, 0x80,
-	0x3a, 0x76, 0xe9, 0x7d, 0x07, 0x9b, 0xae, 0x3f, 0x92, 0x66, 0x10, 0x11, 0xfe, 0xab, 0xc5, 0x16,
-	0x8a, 0x59, 0xb4, 0x97, 0x84, 0x17, 0x70, 0x2b, 0xc5, 0x86, 0x32, 0x46, 0x80, 0x57, 0xc1, 0xb8,
-	0x43, 0xb0, 0x6b, 0x99, 0xf5, 0x0a, 0x8f, 0x22, 0x9c, 0x40, 0xc4, 0x5b, 0x91, 0xe8, 0x85, 0xaf,
-	0x80, 0x09, 0x83, 0xb8, 0x2e, 0xee, 0x91, 0x7a, 0x95, 0x03, 0x67, 0x05, 0x70, 0x62, 0xdb, 0x6f,
-	0x46, 0x41, 0x7f, 0xf3, 0xb7, 0x0a, 0x98, 0x0e, 0x67, 0xee, 0x1c, 0x76, 0xce, 0x1d, 0x79, 0xe7,
-	0x34, 0x47, 0x27, 0x4b, 0xce, 0x86, 0xf9, 0xb0, 0x1c, 0x73, 0x9c, 0xa5, 0x23, 0xfc, 0x01, 0xa8,
-	0xb9, 0x44, 0x27, 0x1d, 0x6a, 0x39, 0xc2, 0xf1, 0xd7, 0x0a, 0x3a, 0x8e, 0x0f, 0x89, 0xbe, 0x2f,
-	0x4c, 0xdb, 0x17, 0x98, 0xe7, 0xc1, 0x2f, 0x14, 0x52, 0xc2, 0xf7, 0x40, 0x8d, 0x12, 0xc3, 0xd6,
-	0x31, 0x25, 0x62, 0xd7, 0xbc, 0x18, 0x77, 0x9e, 0xe5, 0x0c, 0x23, 0xdb, 0xb3, 0xba, 0xf7, 0x05,
-	0x8c, 0x6f, 0x99, 0x70, 0x32, 0x82, 0x56, 0x14, 0xd2, 0x40, 0x1b, 0xcc, 0x78, 0x76, 0x97, 0x21,
-	0x29, 0x3b, 0xce, 0x7b, 0x03, 0x91, 0x43, 0x37, 0x46, 0xcf, 0xca, 0x81, 0x64, 0xd7, 0x5e, 0x10,
-	0xa3, 0xcc, 0xc8, 0xed, 0x28, 0xc1, 0x0f, 0xd7, 0xc1, 0xac, 0xa1, 0x99, 0x88, 0xe0, 0xee, 0x60,
-	0x9f, 0x74, 0x2c, 0xb3, 0xeb, 0xf2, 0x54, 0xaa, 0xb6, 0x17, 0x05, 0xc1, 0xec, 0xb6, 0xdc, 0x8d,
-	0x92, 0x78, 0xb8, 0x05, 0xe6, 0x83, 0x03, 0xf8, 0xae, 0xe6, 0x52, 0xcb, 0x19, 0x6c, 0x69, 0x86,
-	0x46, 0xeb, 0xe3, 0x9c, 0xa7, 0x3e, 0x3c, 0x59, 0x9e, 0x47, 0x19, 0xfd, 0x28, 0xd3, 0xaa, 0xf9,
-	0xab, 0x71, 0x30, 0x9b, 0x38, 0x17, 0xe0, 0x03, 0xb0, 0xd0, 0xf1, 0x1c, 0x87, 0x98, 0x74, 0xc7,
-	0x33, 0x0e, 0x89, 0xb3, 0xdf, 0x39, 0x22, 0x5d, 0x4f, 0x27, 0x5d, 0xbe, 0xac, 0xd5, 0x76, 0x43,
-	0xf8, 0xba, 0xb0, 0x91, 0x89, 0x42, 0x39, 0xd6, 0xf0, 0x5d, 0x00, 0x4d, 0xde, 0xb4, 0xad, 0xb9,
-	0x6e, 0xc8, 0x59, 0xe2, 0x9c, 0xe1, 0x56, 0xdc, 0x49, 0x21, 0x50, 0x86, 0x15, 0xf3, 0xb1, 0x4b,
-	0x5c, 0xcd, 0x21, 0xdd, 0xa4, 0x8f, 0x65, 0xd9, 0xc7, 0xcd, 0x4c, 0x14, 0xca, 0xb1, 0x86, 0x6f,
-	0x80, 0x29, 0x7f, 0x34, 0x3e, 0xe7, 0x62, 0x71, 0xe6, 0x04, 0xd9, 0xd4, 0x4e, 0xd4, 0x85, 0xe2,
-	0x38, 0x16, 0x9a, 0x75, 0xe8, 0x12, 0xa7, 0x4f, 0xba, 0x77, 0x7c, 0x71, 0xc0, 0x2a, 0x68, 0x95,
-	0x57, 0xd0, 0x30, 0xb4, 0xdd, 0x14, 0x02, 0x65, 0x58, 0xb1, 0xd0, 0xfc, 0xac, 0x49, 0x85, 0x36,
-	0x2e, 0x87, 0x76, 0x90, 0x89, 0x42, 0x39, 0xd6, 0x2c, 0xf7, 0x7c, 0x97, 0xd7, 0xfb, 0x58, 0xd3,
-	0xf1, 0xa1, 0x4e, 0xea, 0x13, 0x72, 0xee, 0xed, 0xc8, 0xdd, 0x28, 0x89, 0x87, 0x77, 0xc0, 0x25,
-	0xbf, 0xe9, 0xc0, 0xc4, 0x21, 0x49, 0x8d, 0x93, 0xbc, 0x20, 0x48, 0x2e, 0xed, 0x24, 0x01, 0x28,
-	0x6d, 0x03, 0x6f, 0x81, 0x99, 0x8e, 0xa5, 0xeb, 0x3c, 0x1f, 0x37, 0x2c, 0xcf, 0xa4, 0xf5, 0x49,
-	0xce, 0x02, 0xd9, 0x1e, 0xda, 0x90, 0x7a, 0x50, 0x02, 0x09, 0x7f, 0x08, 0x40, 0x27, 0x28, 0x0c,
-	0x6e, 0x1d, 0x8c, 0x50, 0x00, 0xe9, 0xb2, 0x14, 0x55, 0xe6, 0xb0, 0xc9, 0x45, 0x31, 0xca, 0xe6,
-	0x87, 0x0a, 0x58, 0xcc, 0xd9, 0xe8, 0xf0, 0xdb, 0x52, 0x11, 0xbc, 0x96, 0x28, 0x82, 0x97, 0x73,
-	0xcc, 0x62, 0x95, 0xf0, 0x08, 0x4c, 0x33, 0x41, 0xa2, 0x99, 0x3d, 0x1f, 0x22, 0xce, 0xb2, 0x56,
-	0x6e, 0x00, 0x28, 0x8e, 0x8e, 0x4e, 0xe5, 0x4b, 0xc3, 0x93, 0xe5, 0x69, 0xa9, 0x0f, 0xc9, 0xc4,
-	0xcd, 0x9f, 0x97, 0x00, 0xd8, 0x24, 0xb6, 0x6e, 0x0d, 0x0c, 0x62, 0x9e, 0x87, 0xa6, 0xb9, 0x27,
-	0x69, 0x9a, 0x97, 0xf3, 0x97, 0x24, 0x74, 0x2a, 0x57, 0xd4, 0xbc, 0x97, 0x10, 0x35, 0xaf, 0x14,
-	0x21, 0x7b, 0xb6, 0xaa, 0xf9, 0xb8, 0x0c, 0xe6, 0x22, 0x70, 0x24, 0x6b, 0x6e, 0x4b, 0x2b, 0xfa,
-	0x72, 0x62, 0x45, 0x17, 0x33, 0x4c, 0xbe, 0x30, 0x5d, 0xf3, 0x01, 0x98, 0x61, 0xaa, 0xc3, 0x5f,
-	0x3f, 0xae, 0x69, 0xc6, 0x4f, 0xad, 0x69, 0xc2, 0x4a, 0xb4, 0x25, 0x31, 0xa1, 0x04, 0x73, 0x8e,
-	0x86, 0x9a, 0xf8, 0x2a, 0x6a, 0xa8, 0xdf, 0x29, 0x60, 0x26, 0x5a, 0xa6, 0x73, 0x10, 0x51, 0x77,
-	0x65, 0x11, 0xf5, 0x62, 0x81, 0xe4, 0xcc, 0x51, 0x51, 0x1f, 0x57, 0xe2, 0xae, 0x73, 0x19, 0xb5,
-	0xc2, 0xae, 0x60, 0xb6, 0xae, 0x75, 0xb0, 0x2b, 0xea, 0xed, 0x05, 0xff, 0xfa, 0xe5, 0xb7, 0xa1,
-	0xb0, 0x57, 0x12, 0x5c, 0xa5, 0x2f, 0x56, 0x70, 0x95, 0x9f, 0x8f, 0xe0, 0xfa, 0x1e, 0xa8, 0xb9,
-	0x81, 0xd4, 0xaa, 0x70, 0xca, 0x6b, 0x85, 0x36, 0xb6, 0x50, 0x59, 0x21, 0x75, 0xa8, 0xaf, 0x42,
-	0xba, 0x2c, 0x65, 0x55, 0xfd, 0x32, 0x95, 0x15, 0x4b, 0x74, 0x1b, 0x7b, 0x2e, 0xe9, 0xf2, 0x4d,
-	0x55, 0x8b, 0x12, 0x7d, 0x8f, 0xb7, 0x22, 0xd1, 0x0b, 0x0f, 0xc0, 0xa2, 0xed, 0x58, 0x3d, 0x87,
-	0xb8, 0xee, 0x26, 0xc1, 0x5d, 0x5d, 0x33, 0x49, 0x10, 0x80, 0x5f, 0x13, 0x2f, 0x0f, 0x4f, 0x96,
-	0x17, 0xf7, 0xb2, 0x21, 0x28, 0xcf, 0xb6, 0xf9, 0xc7, 0x0a, 0xb8, 0x98, 0x3c, 0x1b, 0x73, 0x64,
-	0x8a, 0x72, 0x26, 0x99, 0x72, 0x3d, 0x96, 0xa7, 0xbe, 0x86, 0x8b, 0x3d, 0x15, 0xa4, 0x72, 0x75,
-	0x1d, 0xcc, 0x0a, 0x59, 0x12, 0x74, 0x0a, 0xa1, 0x16, 0x2e, 0xcf, 0x81, 0xdc, 0x8d, 0x92, 0x78,
-	0x78, 0x1b, 0x4c, 0x3b, 0x5c, 0x79, 0x05, 0x04, 0xbe, 0x7a, 0xf9, 0x3f, 0x41, 0x30, 0x8d, 0xe2,
-	0x9d, 0x48, 0xc6, 0x32, 0xe5, 0x12, 0x09, 0x92, 0x80, 0xa0, 0x22, 0x2b, 0x97, 0xf5, 0x24, 0x00,
-	0xa5, 0x6d, 0xe0, 0x36, 0x98, 0xf3, 0xcc, 0x34, 0x95, 0x9f, 0x6b, 0x97, 0x05, 0xd5, 0xdc, 0x41,
-	0x1a, 0x82, 0xb2, 0xec, 0xe0, 0x43, 0x49, 0xcc, 0x8c, 0xf3, 0xf3, 0xe4, 0x7a, 0x81, 0x3d, 0x51,
-	0x58, 0xcd, 0x64, 0x48, 0xad, 0x5a, 0x51, 0xa9, 0xd5, 0xfc, 0x83, 0x02, 0x60, 0x7a, 0x1f, 0x8e,
-	0x7c, 0x09, 0x48, 0x59, 0xc4, 0x2a, 0xa6, 0x96, 0xad, 0x7f, 0x6e, 0x14, 0xd4, 0x3f, 0xd1, 0x81,
-	0x5a, 0x4c, 0x00, 0x89, 0x89, 0x3e, 0x9f, 0x47, 0x9d, 0xa2, 0x02, 0x28, 0x72, 0xea, 0x39, 0x08,
-	0xa0, 0x18, 0xd9, 0xb3, 0x05, 0xd0, 0xdf, 0x4b, 0x60, 0x2e, 0x02, 0x17, 0x16, 0x40, 0x19, 0x26,
-	0x5f, 0x3f, 0xec, 0x14, 0x13, 0x25, 0xd1, 0xd4, 0xfd, 0x37, 0x89, 0x92, 0xc8, 0xab, 0x1c, 0x51,
-	0xf2, 0x9b, 0x52, 0xdc, 0xf5, 0x53, 0x8a, 0x92, 0xe7, 0xf0, 0xc2, 0xf1, 0x95, 0xd3, 0x35, 0xcd,
-	0x3f, 0x95, 0xc1, 0xc5, 0xe4, 0x3e, 0x94, 0x0a, 0xa4, 0x32, 0xb2, 0x40, 0xee, 0x81, 0xf9, 0x47,
-	0x9e, 0xae, 0x0f, 0x78, 0x0c, 0xb1, 0x2a, 0xe9, 0x97, 0xd6, 0xff, 0x17, 0x96, 0xf3, 0xdf, 0xcd,
-	0xc0, 0xa0, 0x4c, 0xcb, 0x74, 0xbd, 0xac, 0x7c, 0xde, 0x7a, 0x59, 0x3d, 0x43, 0xbd, 0xcc, 0x96,
-	0x1c, 0xe5, 0x33, 0x49, 0x8e, 0xd3, 0x15, 0xcb, 0x8c, 0x83, 0x6b, 0xe4, 0xd5, 0xff, 0xa7, 0x0a,
-	0x58, 0xc8, 0xbe, 0x70, 0x43, 0x1d, 0xcc, 0x18, 0xf8, 0x71, 0xfc, 0xe1, 0x63, 0x54, 0x11, 0xf1,
-	0xa8, 0xa6, 0xab, 0xfe, 0x27, 0x23, 0xf5, 0x9e, 0x49, 0x77, 0x9d, 0x7d, 0xea, 0x68, 0x66, 0xcf,
-	0xaf, 0xbc, 0xdb, 0x12, 0x17, 0x4a, 0x70, 0x37, 0x3f, 0x55, 0xc0, 0x62, 0x4e, 0xe5, 0x3b, 0x5f,
-	0x4f, 0xe0, 0xfb, 0xa0, 0x66, 0xe0, 0xc7, 0xfb, 0x9e, 0xd3, 0xcb, 0xaa, 0xd5, 0xc5, 0xc6, 0xe1,
-	0x5b, 0x71, 0x5b, 0xb0, 0xa0, 0x90, 0xaf, 0xb9, 0x0b, 0xae, 0x48, 0x41, 0xb2, 0x9d, 0x43, 0x1e,
-	0x79, 0x3a, 0xdf, 0x44, 0x42, 0x6c, 0x5c, 0x03, 0x93, 0x36, 0x76, 0xa8, 0x16, 0x4a, 0xd5, 0x6a,
-	0x7b, 0x7a, 0x78, 0xb2, 0x3c, 0xb9, 0x17, 0x34, 0xa2, 0xa8, 0xbf, 0xf9, 0x6f, 0x05, 0x54, 0xf7,
-	0x3b, 0x58, 0x27, 0xe7, 0x50, 0xed, 0x37, 0xa5, 0x6a, 0x9f, 0xff, 0x92, 0xce, 0xfd, 0xc9, 0x2d,
-	0xf4, 0x5b, 0x89, 0x42, 0xff, 0xd2, 0x08, 0x9e, 0x67, 0xd7, 0xf8, 0xb7, 0xc1, 0x64, 0x38, 0xdc,
-	0xe9, 0x0e, 0xa0, 0xe6, 0xaf, 0x4b, 0x60, 0x2a, 0x36, 0xc4, 0x29, 0x8f, 0xaf, 0x87, 0xd2, 0x99,
-	0xcd, 0x36, 0xe6, 0x5a, 0x91, 0x40, 0xd4, 0xe0, 0x7c, 0x7e, 0xc7, 0xa4, 0x4e, 0xfc, 0x82, 0x97,
-	0x3e, 0xb6, 0xbf, 0x05, 0x66, 0x28, 0x76, 0x7a, 0x84, 0x06, 0x7d, 0x7c, 0xc2, 0x26, 0xa3, 0x07,
-	0x8f, 0xfb, 0x52, 0x2f, 0x4a, 0xa0, 0x97, 0x6e, 0x83, 0x69, 0x69, 0x30, 0x78, 0x11, 0x94, 0x8f,
-	0xc9, 0xc0, 0x97, 0x3d, 0x88, 0xfd, 0x09, 0xe7, 0x41, 0xb5, 0x8f, 0x75, 0xcf, 0xcf, 0xf3, 0x49,
-	0xe4, 0xff, 0xb8, 0x55, 0x7a, 0x4b, 0x69, 0xfe, 0x82, 0x4d, 0x4e, 0x94, 0x9c, 0xe7, 0x90, 0x5d,
-	0xef, 0x4a, 0xd9, 0x95, 0xff, 0x51, 0x2f, 0xbe, 0x65, 0xf2, 0x72, 0x0c, 0x25, 0x72, 0xec, 0xd5,
-	0x42, 0x6c, 0xcf, 0xce, 0xb4, 0x7f, 0x94, 0xc0, 0x7c, 0x0c, 0x1d, 0xc9, 0xc9, 0x6f, 0x4a, 0x72,
-	0x72, 0x25, 0x21, 0x27, 0xeb, 0x59, 0x36, 0x5f, 0xeb, 0xc9, 0xd1, 0x7a, 0xf2, 0xf7, 0x0a, 0x98,
-	0x8d, 0xcd, 0xdd, 0x39, 0x08, 0xca, 0x7b, 0xb2, 0xa0, 0x7c, 0xa9, 0x48, 0xd2, 0xe4, 0x28, 0xca,
-	0x3f, 0x57, 0x25, 0xe7, 0xff, 0xe7, 0xdf, 0xb9, 0x7e, 0x0c, 0xe6, 0xfb, 0x96, 0xee, 0x19, 0x64,
-	0x43, 0xc7, 0x9a, 0x11, 0x00, 0x98, 0x02, 0x2b, 0x27, 0xef, 0x72, 0x21, 0x3d, 0x71, 0x5c, 0xcd,
-	0xa5, 0xc4, 0xa4, 0x0f, 0x22, 0xcb, 0x48, 0xf7, 0x3d, 0xc8, 0xa0, 0x43, 0x99, 0x83, 0xc0, 0x37,
-	0xc0, 0x14, 0x53, 0x4e, 0x5a, 0x87, 0xec, 0x60, 0x23, 0x48, 0xac, 0xf0, 0x13, 0xd6, 0x7e, 0xd4,
-	0x85, 0xe2, 0x38, 0x78, 0x04, 0xe6, 0x6c, 0xab, 0xbb, 0x8d, 0x4d, 0xdc, 0x23, 0x4c, 0x66, 0xec,
-	0x59, 0xba, 0xd6, 0x19, 0xf0, 0xc7, 0xaf, 0xc9, 0xf6, 0x9b, 0xc1, 0xc3, 0xc6, 0x5e, 0x1a, 0xc2,
-	0x2e, 0x89, 0x19, 0xcd, 0x7c, 0x53, 0x67, 0x51, 0x42, 0x27, 0xf5, 0xd9, 0xd5, 0x7f, 0x76, 0x5e,
-	0x2b, 0x92, 0x61, 0x67, 0xfc, 0xf0, 0x9a, 0xf7, 0xb6, 0x57, 0x3b, 0xd3, 0x57, 0xd3, 0x7f, 0x56,
-	0xc0, 0xa5, 0xd4, 0x51, 0xf9, 0x25, 0xbe, 0xae, 0xa5, 0xa4, 0x7e, 0xf9, 0x14, 0x52, 0x7f, 0x1d,
-	0xcc, 0x8a, 0x0f, 0xb6, 0x89, 0x9b, 0x42, 0x78, 0x63, 0xdb, 0x90, 0xbb, 0x51, 0x12, 0x9f, 0xf5,
-	0xba, 0x57, 0x3d, 0xe5, 0xeb, 0x5e, 0xdc, 0x0b, 0xf1, 0x0f, 0x48, 0x7e, 0xea, 0xa5, 0xbd, 0x10,
-	0xff, 0x87, 0x94, 0xc4, 0x33, 0x85, 0xe0, 0xb3, 0x86, 0x0c, 0x13, 0xb2, 0x42, 0x38, 0x90, 0x7a,
-	0x51, 0x02, 0xfd, 0xb9, 0x3e, 0x4a, 0xe2, 0x8c, 0x8f, 0x92, 0xab, 0x45, 0xf2, 0xb9, 0xf8, 0xdd,
-	0xe4, 0x2f, 0x0a, 0x78, 0x21, 0x77, 0x23, 0xc0, 0x75, 0xa9, 0xec, 0xae, 0x26, 0xca, 0xee, 0x37,
-	0x72, 0x0d, 0x63, 0xb5, 0xd7, 0xc9, 0x7e, 0x9a, 0x7b, 0xbb, 0xd8, 0xd3, 0x5c, 0x86, 0x76, 0x1f,
-	0xfd, 0x46, 0xd7, 0x5e, 0x7d, 0xf2, 0xb4, 0x31, 0xf6, 0xd1, 0xd3, 0xc6, 0xd8, 0x27, 0x4f, 0x1b,
-	0x63, 0x3f, 0x19, 0x36, 0x94, 0x27, 0xc3, 0x86, 0xf2, 0xd1, 0xb0, 0xa1, 0x7c, 0x32, 0x6c, 0x28,
-	0x7f, 0x1d, 0x36, 0x94, 0x5f, 0x7e, 0xda, 0x18, 0x7b, 0x7f, 0x42, 0x8c, 0xf8, 0x9f, 0x00, 0x00,
-	0x00, 0xff, 0xff, 0x70, 0x2d, 0x26, 0x9d, 0xec, 0x28, 0x00, 0x00,
+	0xf5, 0xa2, 0x97, 0x5e, 0x0b, 0x14, 0x68, 0x7b, 0xed, 0x3f, 0xd1, 0x5b, 0x51, 0xb4, 0xb7, 0x22,
+	0x28, 0x7c, 0x29, 0x10, 0xf4, 0x92, 0x9c, 0x84, 0x7a, 0x73, 0x2a, 0x8a, 0x5e, 0x0a, 0xf4, 0x12,
+	0xa0, 0x40, 0x41, 0x0e, 0xe7, 0x83, 0xf3, 0xe1, 0x1d, 0x29, 0x8e, 0xd2, 0x04, 0xb9, 0x69, 0xc9,
+	0xe7, 0x7d, 0xf8, 0xbe, 0xe4, 0x4b, 0xbe, 0x0f, 0x39, 0x02, 0xdf, 0x3b, 0x7e, 0xcb, 0x55, 0x35,
+	0xab, 0x75, 0xec, 0x1d, 0x12, 0xc7, 0x24, 0x94, 0xb8, 0xad, 0x3e, 0x31, 0xbb, 0x96, 0xd3, 0x12,
+	0x1d, 0xd8, 0xd6, 0x5a, 0xd8, 0xb6, 0xdd, 0x56, 0xff, 0xe6, 0x21, 0xa1, 0x78, 0xad, 0xd5, 0x23,
+	0x26, 0x71, 0x30, 0x25, 0x5d, 0xd5, 0x76, 0x2c, 0x6a, 0xc1, 0x45, 0x1f, 0xa8, 0x62, 0x5b, 0x53,
+	0x19, 0x50, 0x15, 0xc0, 0xa5, 0xd5, 0x9e, 0x46, 0x8f, 0xbc, 0x43, 0xb5, 0x63, 0x19, 0xad, 0x9e,
+	0xd5, 0xb3, 0x5a, 0x1c, 0x7f, 0xe8, 0x3d, 0xe2, 0xbf, 0xf8, 0x0f, 0xfe, 0x97, 0xcf, 0xb3, 0xd4,
+	0x8c, 0x0d, 0xd8, 0xb1, 0x1c, 0xd2, 0xea, 0xdf, 0x4c, 0x8e, 0xb5, 0xf4, 0x7a, 0x84, 0x31, 0x70,
+	0xe7, 0x48, 0x33, 0x89, 0x33, 0x68, 0xd9, 0xc7, 0x3d, 0xd6, 0xe0, 0xb6, 0x0c, 0x42, 0x71, 0x96,
+	0x55, 0x2b, 0xcf, 0xca, 0xf1, 0x4c, 0xaa, 0x19, 0x24, 0x65, 0xf0, 0xe6, 0x28, 0x03, 0xb7, 0x73,
+	0x44, 0x0c, 0x9c, 0xb2, 0x7b, 0x2d, 0xcf, 0xce, 0xa3, 0x9a, 0xde, 0xd2, 0x4c, 0xea, 0x52, 0x27,
+	0x69, 0xd4, 0xfc, 0xb7, 0x02, 0xe0, 0x86, 0x65, 0x52, 0xc7, 0xd2, 0x75, 0xe2, 0x20, 0xd2, 0xd7,
+	0x5c, 0xcd, 0x32, 0xe1, 0x43, 0x50, 0x63, 0xf1, 0x74, 0x31, 0xc5, 0x75, 0xe5, 0x8a, 0xb2, 0x32,
+	0xb5, 0x76, 0x43, 0x8d, 0x66, 0x3a, 0xa4, 0x57, 0xed, 0xe3, 0x1e, 0x6b, 0x70, 0x55, 0x86, 0x56,
+	0xfb, 0x37, 0xd5, 0xdd, 0xc3, 0x0f, 0x48, 0x87, 0x6e, 0x13, 0x8a, 0xdb, 0xf0, 0xc9, 0xc9, 0xf2,
+	0xd8, 0xf0, 0x64, 0x19, 0x44, 0x6d, 0x28, 0x64, 0x85, 0xbb, 0xa0, 0xc2, 0xd9, 0x4b, 0x9c, 0x7d,
+	0x35, 0x97, 0x5d, 0x04, 0xad, 0x22, 0xfc, 0x93, 0x77, 0x1e, 0x53, 0x62, 0x32, 0xf7, 0xda, 0x17,
+	0x04, 0x75, 0x65, 0x13, 0x53, 0x8c, 0x38, 0x11, 0xbc, 0x0e, 0x6a, 0x8e, 0x70, 0xbf, 0x5e, 0xbe,
+	0xa2, 0xac, 0x94, 0xdb, 0x17, 0x05, 0xaa, 0x16, 0x84, 0x85, 0x42, 0x44, 0xf3, 0x89, 0x02, 0x16,
+	0xd2, 0x71, 0x6f, 0x69, 0x2e, 0x85, 0x3f, 0x4c, 0xc5, 0xae, 0x16, 0x8b, 0x9d, 0x59, 0xf3, 0xc8,
+	0xc3, 0x81, 0x83, 0x96, 0x58, 0xdc, 0x7b, 0xa0, 0xaa, 0x51, 0x62, 0xb8, 0xf5, 0xd2, 0x95, 0xf2,
+	0xca, 0xd4, 0xda, 0x35, 0x35, 0x27, 0x81, 0xd5, 0xb4, 0x77, 0xed, 0x69, 0xc1, 0x5b, 0xbd, 0xc7,
+	0x18, 0x90, 0x4f, 0xd4, 0xfc, 0x79, 0x09, 0x4c, 0x6e, 0x62, 0x62, 0x58, 0xe6, 0x3e, 0xa1, 0xe7,
+	0xb0, 0x72, 0x77, 0x41, 0xc5, 0xb5, 0x49, 0x47, 0xac, 0xdc, 0xd5, 0xdc, 0x00, 0x42, 0x9f, 0xf6,
+	0x6d, 0xd2, 0x89, 0x96, 0x8c, 0xfd, 0x42, 0x9c, 0x01, 0xee, 0x81, 0x71, 0x97, 0x62, 0xea, 0xb9,
+	0x7c, 0xc1, 0xa6, 0xd6, 0x56, 0x0a, 0x70, 0x71, 0x7c, 0x7b, 0x46, 0xb0, 0x8d, 0xfb, 0xbf, 0x91,
+	0xe0, 0x69, 0xfe, 0xbd, 0x04, 0x60, 0x88, 0xdd, 0xb0, 0xcc, 0xae, 0x46, 0x59, 0x3a, 0xdf, 0x02,
+	0x15, 0x3a, 0xb0, 0x09, 0x9f, 0x90, 0xc9, 0xf6, 0xd5, 0xc0, 0x95, 0xfb, 0x03, 0x9b, 0x7c, 0x76,
+	0xb2, 0xbc, 0x90, 0xb6, 0x60, 0x3d, 0x88, 0xdb, 0xc0, 0xad, 0xd0, 0xc9, 0x12, 0xb7, 0x7e, 0x5d,
+	0x1e, 0xfa, 0xb3, 0x93, 0xe5, 0x8c, 0xb3, 0x43, 0x0d, 0x99, 0x64, 0x07, 0x61, 0x1f, 0x40, 0x1d,
+	0xbb, 0xf4, 0xbe, 0x83, 0x4d, 0xd7, 0x1f, 0x49, 0x33, 0x88, 0x08, 0xff, 0xd5, 0x62, 0x0b, 0xc5,
+	0x2c, 0xda, 0x4b, 0xc2, 0x0b, 0xb8, 0x95, 0x62, 0x43, 0x19, 0x23, 0xc0, 0xab, 0x60, 0xdc, 0x21,
+	0xd8, 0xb5, 0xcc, 0x7a, 0x85, 0x47, 0x11, 0x4e, 0x20, 0xe2, 0xad, 0x48, 0xf4, 0xc2, 0x57, 0xc0,
+	0x84, 0x41, 0x5c, 0x17, 0xf7, 0x48, 0xbd, 0xca, 0x81, 0xb3, 0x02, 0x38, 0xb1, 0xed, 0x37, 0xa3,
+	0xa0, 0xbf, 0xf9, 0x3b, 0x05, 0x4c, 0x87, 0x33, 0x77, 0x0e, 0x3b, 0xe7, 0x8e, 0xbc, 0x73, 0x9a,
+	0xa3, 0x93, 0x25, 0x67, 0xc3, 0x7c, 0x58, 0x8e, 0x39, 0xce, 0xd2, 0x11, 0xfe, 0x08, 0xd4, 0x5c,
+	0xa2, 0x93, 0x0e, 0xb5, 0x1c, 0xe1, 0xf8, 0x6b, 0x05, 0x1d, 0xc7, 0x87, 0x44, 0xdf, 0x17, 0xa6,
+	0xed, 0x0b, 0xcc, 0xf3, 0xe0, 0x17, 0x0a, 0x29, 0xe1, 0x7b, 0xa0, 0x46, 0x89, 0x61, 0xeb, 0x98,
+	0x12, 0xb1, 0x6b, 0x5e, 0x8c, 0x3b, 0xcf, 0x72, 0x86, 0x91, 0xed, 0x59, 0xdd, 0xfb, 0x02, 0xc6,
+	0xb7, 0x4c, 0x38, 0x19, 0x41, 0x2b, 0x0a, 0x69, 0xa0, 0x0d, 0x66, 0x3c, 0xbb, 0xcb, 0x90, 0x94,
+	0x1d, 0xe7, 0xbd, 0x81, 0xc8, 0xa1, 0x1b, 0xa3, 0x67, 0xe5, 0x40, 0xb2, 0x6b, 0x2f, 0x88, 0x51,
+	0x66, 0xe4, 0x76, 0x94, 0xe0, 0x87, 0xeb, 0x60, 0xd6, 0xd0, 0x4c, 0x44, 0x70, 0x77, 0xb0, 0x4f,
+	0x3a, 0x96, 0xd9, 0x75, 0x79, 0x2a, 0x55, 0xdb, 0x8b, 0x82, 0x60, 0x76, 0x5b, 0xee, 0x46, 0x49,
+	0x3c, 0xdc, 0x02, 0xf3, 0xc1, 0x01, 0x7c, 0x57, 0x73, 0xa9, 0xe5, 0x0c, 0xb6, 0x34, 0x43, 0xa3,
+	0xf5, 0x71, 0xce, 0x53, 0x1f, 0x9e, 0x2c, 0xcf, 0xa3, 0x8c, 0x7e, 0x94, 0x69, 0xd5, 0xfc, 0xf5,
+	0x38, 0x98, 0x4d, 0x9c, 0x0b, 0xf0, 0x01, 0x58, 0xe8, 0x78, 0x8e, 0x43, 0x4c, 0xba, 0xe3, 0x19,
+	0x87, 0xc4, 0xd9, 0xef, 0x1c, 0x91, 0xae, 0xa7, 0x93, 0x2e, 0x5f, 0xd6, 0x6a, 0xbb, 0x21, 0x7c,
+	0x5d, 0xd8, 0xc8, 0x44, 0xa1, 0x1c, 0x6b, 0xf8, 0x2e, 0x80, 0x26, 0x6f, 0xda, 0xd6, 0x5c, 0x37,
+	0xe4, 0x2c, 0x71, 0xce, 0x70, 0x2b, 0xee, 0xa4, 0x10, 0x28, 0xc3, 0x8a, 0xf9, 0xd8, 0x25, 0xae,
+	0xe6, 0x90, 0x6e, 0xd2, 0xc7, 0xb2, 0xec, 0xe3, 0x66, 0x26, 0x0a, 0xe5, 0x58, 0xc3, 0x37, 0xc0,
+	0x94, 0x3f, 0x1a, 0x9f, 0x73, 0xb1, 0x38, 0x73, 0x82, 0x6c, 0x6a, 0x27, 0xea, 0x42, 0x71, 0x1c,
+	0x0b, 0xcd, 0x3a, 0x74, 0x89, 0xd3, 0x27, 0xdd, 0x3b, 0xbe, 0x38, 0x60, 0x15, 0xb4, 0xca, 0x2b,
+	0x68, 0x18, 0xda, 0x6e, 0x0a, 0x81, 0x32, 0xac, 0x58, 0x68, 0x7e, 0xd6, 0xa4, 0x42, 0x1b, 0x97,
+	0x43, 0x3b, 0xc8, 0x44, 0xa1, 0x1c, 0x6b, 0x96, 0x7b, 0xbe, 0xcb, 0xeb, 0x7d, 0xac, 0xe9, 0xf8,
+	0x50, 0x27, 0xf5, 0x09, 0x39, 0xf7, 0x76, 0xe4, 0x6e, 0x94, 0xc4, 0xc3, 0x3b, 0xe0, 0x92, 0xdf,
+	0x74, 0x60, 0xe2, 0x90, 0xa4, 0xc6, 0x49, 0x5e, 0x10, 0x24, 0x97, 0x76, 0x92, 0x00, 0x94, 0xb6,
+	0x81, 0xb7, 0xc0, 0x4c, 0xc7, 0xd2, 0x75, 0x9e, 0x8f, 0x1b, 0x96, 0x67, 0xd2, 0xfa, 0x24, 0x67,
+	0x81, 0x6c, 0x0f, 0x6d, 0x48, 0x3d, 0x28, 0x81, 0x84, 0x3f, 0x06, 0xa0, 0x13, 0x14, 0x06, 0xb7,
+	0x0e, 0x46, 0x28, 0x80, 0x74, 0x59, 0x8a, 0x2a, 0x73, 0xd8, 0xe4, 0xa2, 0x18, 0x65, 0xf3, 0x43,
+	0x05, 0x2c, 0xe6, 0x6c, 0x74, 0xf8, 0x5d, 0xa9, 0x08, 0x5e, 0x4b, 0x14, 0xc1, 0xcb, 0x39, 0x66,
+	0xb1, 0x4a, 0x78, 0x04, 0xa6, 0x99, 0x20, 0xd1, 0xcc, 0x9e, 0x0f, 0x11, 0x67, 0x59, 0x2b, 0x37,
+	0x00, 0x14, 0x47, 0x47, 0xa7, 0xf2, 0xa5, 0xe1, 0xc9, 0xf2, 0xb4, 0xd4, 0x87, 0x64, 0xe2, 0xe6,
+	0x2f, 0x4a, 0x00, 0x6c, 0x12, 0x5b, 0xb7, 0x06, 0x06, 0x31, 0xcf, 0x43, 0xd3, 0xdc, 0x93, 0x34,
+	0xcd, 0xcb, 0xf9, 0x4b, 0x12, 0x3a, 0x95, 0x2b, 0x6a, 0xde, 0x4b, 0x88, 0x9a, 0x57, 0x8a, 0x90,
+	0x3d, 0x5b, 0xd5, 0x7c, 0x5c, 0x06, 0x73, 0x11, 0x38, 0x92, 0x35, 0xb7, 0xa5, 0x15, 0x7d, 0x39,
+	0xb1, 0xa2, 0x8b, 0x19, 0x26, 0x5f, 0x98, 0xae, 0xf9, 0x00, 0xcc, 0x30, 0xd5, 0xe1, 0xaf, 0x1f,
+	0xd7, 0x34, 0xe3, 0xa7, 0xd6, 0x34, 0x61, 0x25, 0xda, 0x92, 0x98, 0x50, 0x82, 0x39, 0x47, 0x43,
+	0x4d, 0x7c, 0x15, 0x35, 0xd4, 0xef, 0x15, 0x30, 0x13, 0x2d, 0xd3, 0x39, 0x88, 0xa8, 0xbb, 0xb2,
+	0x88, 0x7a, 0xb1, 0x40, 0x72, 0xe6, 0xa8, 0xa8, 0x8f, 0x2b, 0x71, 0xd7, 0xb9, 0x8c, 0x5a, 0x61,
+	0x57, 0x30, 0x5b, 0xd7, 0x3a, 0xd8, 0x15, 0xf5, 0xf6, 0x82, 0x7f, 0xfd, 0xf2, 0xdb, 0x50, 0xd8,
+	0x2b, 0x09, 0xae, 0xd2, 0x17, 0x2b, 0xb8, 0xca, 0xcf, 0x47, 0x70, 0xfd, 0x00, 0xd4, 0xdc, 0x40,
+	0x6a, 0x55, 0x38, 0xe5, 0xb5, 0x42, 0x1b, 0x5b, 0xa8, 0xac, 0x90, 0x3a, 0xd4, 0x57, 0x21, 0x5d,
+	0x96, 0xb2, 0xaa, 0x7e, 0x99, 0xca, 0x8a, 0x25, 0xba, 0x8d, 0x3d, 0x97, 0x74, 0xf9, 0xa6, 0xaa,
+	0x45, 0x89, 0xbe, 0xc7, 0x5b, 0x91, 0xe8, 0x85, 0x07, 0x60, 0xd1, 0x76, 0xac, 0x9e, 0x43, 0x5c,
+	0x77, 0x93, 0xe0, 0xae, 0xae, 0x99, 0x24, 0x08, 0xc0, 0xaf, 0x89, 0x97, 0x87, 0x27, 0xcb, 0x8b,
+	0x7b, 0xd9, 0x10, 0x94, 0x67, 0xdb, 0xfc, 0x53, 0x05, 0x5c, 0x4c, 0x9e, 0x8d, 0x39, 0x32, 0x45,
+	0x39, 0x93, 0x4c, 0xb9, 0x1e, 0xcb, 0x53, 0x5f, 0xc3, 0xc5, 0x9e, 0x0a, 0x52, 0xb9, 0xba, 0x0e,
+	0x66, 0x85, 0x2c, 0x09, 0x3a, 0x85, 0x50, 0x0b, 0x97, 0xe7, 0x40, 0xee, 0x46, 0x49, 0x3c, 0xbc,
+	0x0d, 0xa6, 0x1d, 0xae, 0xbc, 0x02, 0x02, 0x5f, 0xbd, 0xfc, 0x9f, 0x20, 0x98, 0x46, 0xf1, 0x4e,
+	0x24, 0x63, 0x99, 0x72, 0x89, 0x04, 0x49, 0x40, 0x50, 0x91, 0x95, 0xcb, 0x7a, 0x12, 0x80, 0xd2,
+	0x36, 0x70, 0x1b, 0xcc, 0x79, 0x66, 0x9a, 0xca, 0xcf, 0xb5, 0xcb, 0x82, 0x6a, 0xee, 0x20, 0x0d,
+	0x41, 0x59, 0x76, 0xf0, 0xa1, 0x24, 0x66, 0xc6, 0xf9, 0x79, 0x72, 0xbd, 0xc0, 0x9e, 0x28, 0xac,
+	0x66, 0x32, 0xa4, 0x56, 0xad, 0xa8, 0xd4, 0x6a, 0xfe, 0x51, 0x01, 0x30, 0xbd, 0x0f, 0x47, 0xbe,
+	0x04, 0xa4, 0x2c, 0x62, 0x15, 0x53, 0xcb, 0xd6, 0x3f, 0x37, 0x0a, 0xea, 0x9f, 0xe8, 0x40, 0x2d,
+	0x26, 0x80, 0xc4, 0x44, 0x9f, 0xcf, 0xa3, 0x4e, 0x51, 0x01, 0x14, 0x39, 0xf5, 0x1c, 0x04, 0x50,
+	0x8c, 0xec, 0xd9, 0x02, 0xe8, 0x1f, 0x25, 0x30, 0x17, 0x81, 0x0b, 0x0b, 0xa0, 0x0c, 0x93, 0x6f,
+	0x1e, 0x76, 0x8a, 0x89, 0x92, 0x68, 0xea, 0xfe, 0x97, 0x44, 0x49, 0xe4, 0x55, 0x8e, 0x28, 0xf9,
+	0x6d, 0x29, 0xee, 0xfa, 0x29, 0x45, 0xc9, 0x73, 0x78, 0xe1, 0xf8, 0xca, 0xe9, 0x9a, 0xe6, 0x9f,
+	0xcb, 0xe0, 0x62, 0x72, 0x1f, 0x4a, 0x05, 0x52, 0x19, 0x59, 0x20, 0xf7, 0xc0, 0xfc, 0x23, 0x4f,
+	0xd7, 0x07, 0x3c, 0x86, 0x58, 0x95, 0xf4, 0x4b, 0xeb, 0xff, 0x0b, 0xcb, 0xf9, 0xef, 0x67, 0x60,
+	0x50, 0xa6, 0x65, 0xba, 0x5e, 0x56, 0x3e, 0x6f, 0xbd, 0xac, 0x9e, 0xa1, 0x5e, 0x66, 0x4b, 0x8e,
+	0xf2, 0x99, 0x24, 0xc7, 0xe9, 0x8a, 0x65, 0xc6, 0xc1, 0x35, 0xf2, 0xea, 0x3f, 0x54, 0xc0, 0x42,
+	0xf6, 0x85, 0x1b, 0xea, 0x60, 0xc6, 0xc0, 0x8f, 0xe3, 0x0f, 0x1f, 0xa3, 0x8a, 0x88, 0x47, 0x35,
+	0x5d, 0xf5, 0x3f, 0x19, 0xa9, 0xf7, 0x4c, 0xba, 0xeb, 0xec, 0x53, 0x47, 0x33, 0x7b, 0x7e, 0xe5,
+	0xdd, 0x96, 0xb8, 0x50, 0x82, 0x1b, 0xbe, 0x0f, 0x6a, 0x06, 0x7e, 0xbc, 0xef, 0x39, 0xbd, 0xac,
+	0x0a, 0x59, 0x6c, 0x1c, 0xbe, 0x01, 0xb6, 0x05, 0x0b, 0x0a, 0xf9, 0x9a, 0x9f, 0x2a, 0x60, 0x31,
+	0xa7, 0xaa, 0x7e, 0x8d, 0xa2, 0xdc, 0x05, 0x57, 0xa4, 0x20, 0xd9, 0xae, 0x24, 0x8f, 0x3c, 0x9d,
+	0x6f, 0x50, 0x21, 0x64, 0xae, 0x81, 0x49, 0x1b, 0x3b, 0x54, 0x0b, 0x65, 0x70, 0xb5, 0x3d, 0x3d,
+	0x3c, 0x59, 0x9e, 0xdc, 0x0b, 0x1a, 0x51, 0xd4, 0xdf, 0xfc, 0x8f, 0x02, 0xaa, 0xfb, 0x1d, 0xac,
+	0x93, 0x73, 0x50, 0x12, 0x9b, 0x92, 0x92, 0xc8, 0x7f, 0xa5, 0xe7, 0xfe, 0xe4, 0x8a, 0x88, 0xad,
+	0x84, 0x88, 0x78, 0x69, 0x04, 0xcf, 0xb3, 0xf5, 0xc3, 0xdb, 0x60, 0x32, 0x1c, 0xee, 0x74, 0x87,
+	0x5b, 0xf3, 0x37, 0x25, 0x30, 0x15, 0x1b, 0xe2, 0x94, 0x47, 0xe3, 0x43, 0xa9, 0x1e, 0xb0, 0x4d,
+	0xbf, 0x56, 0x24, 0x10, 0x35, 0x38, 0xfb, 0xdf, 0x31, 0xa9, 0x13, 0xbf, 0x3c, 0xa6, 0x4b, 0xc2,
+	0x77, 0xc0, 0x0c, 0xc5, 0x4e, 0x8f, 0xd0, 0xa0, 0x8f, 0x4f, 0xd8, 0x64, 0xf4, 0x98, 0x72, 0x5f,
+	0xea, 0x45, 0x09, 0xf4, 0xd2, 0x6d, 0x30, 0x2d, 0x0d, 0x06, 0x2f, 0x82, 0xf2, 0x31, 0x19, 0xf8,
+	0x92, 0x0a, 0xb1, 0x3f, 0xe1, 0x3c, 0xa8, 0xf6, 0xb1, 0xee, 0xf9, 0x79, 0x3e, 0x89, 0xfc, 0x1f,
+	0xb7, 0x4a, 0x6f, 0x29, 0xcd, 0x5f, 0xb2, 0xc9, 0x89, 0x92, 0xf3, 0x1c, 0xb2, 0xeb, 0x5d, 0x29,
+	0xbb, 0xf2, 0x3f, 0x18, 0xc6, 0xb7, 0x4c, 0x5e, 0x8e, 0xa1, 0x44, 0x8e, 0xbd, 0x5a, 0x88, 0xed,
+	0xd9, 0x99, 0xf6, 0xcf, 0x12, 0x98, 0x8f, 0xa1, 0x23, 0xa9, 0xfa, 0x6d, 0x49, 0xaa, 0xae, 0x24,
+	0xa4, 0x6a, 0x3d, 0xcb, 0xe6, 0x1b, 0xad, 0x3a, 0x5a, 0xab, 0xfe, 0x41, 0x01, 0xb3, 0xb1, 0xb9,
+	0x3b, 0x07, 0xb1, 0x7a, 0x4f, 0x16, 0xab, 0x2f, 0x15, 0x49, 0x9a, 0x1c, 0xb5, 0xfa, 0x97, 0xaa,
+	0xe4, 0xfc, 0xd7, 0xfe, 0x0d, 0xed, 0xa7, 0x60, 0xbe, 0x6f, 0xe9, 0x9e, 0x41, 0x36, 0x74, 0xac,
+	0x19, 0x01, 0x80, 0xa9, 0xbb, 0x72, 0xf2, 0x9e, 0x18, 0xd2, 0x13, 0xc7, 0xd5, 0x5c, 0x4a, 0x4c,
+	0xfa, 0x20, 0xb2, 0x8c, 0x34, 0xe5, 0x83, 0x0c, 0x3a, 0x94, 0x39, 0x08, 0x7c, 0x03, 0x4c, 0x31,
+	0x55, 0xa6, 0x75, 0xc8, 0x0e, 0x36, 0x82, 0xc4, 0x0a, 0x3f, 0x8f, 0xed, 0x47, 0x5d, 0x28, 0x8e,
+	0x83, 0x47, 0x60, 0xce, 0xb6, 0xba, 0xdb, 0xd8, 0xc4, 0x3d, 0xc2, 0x64, 0xc6, 0x9e, 0xa5, 0x6b,
+	0x9d, 0x01, 0x7f, 0x58, 0x9b, 0x6c, 0xbf, 0x19, 0x3c, 0x9a, 0xec, 0xa5, 0x21, 0xec, 0x02, 0x9a,
+	0xd1, 0xcc, 0x37, 0x75, 0x16, 0x25, 0x74, 0x52, 0x9f, 0x74, 0xfd, 0x27, 0xed, 0xb5, 0x22, 0x19,
+	0x76, 0xc6, 0x8f, 0xba, 0x79, 0xef, 0x86, 0xb5, 0x33, 0x7d, 0x91, 0xfd, 0x57, 0x05, 0x5c, 0x4a,
+	0x1d, 0x95, 0x5f, 0xe2, 0xcb, 0x5d, 0xea, 0x1a, 0x51, 0x3e, 0xc5, 0x35, 0x62, 0x1d, 0xcc, 0x8a,
+	0x8f, 0xc1, 0x89, 0x5b, 0x48, 0x78, 0x1b, 0xdc, 0x90, 0xbb, 0x51, 0x12, 0x9f, 0xf5, 0x72, 0x58,
+	0x3d, 0xe5, 0xcb, 0x61, 0xdc, 0x0b, 0xf1, 0xcf, 0x4d, 0x7e, 0xea, 0xa5, 0xbd, 0x10, 0xff, 0xe3,
+	0x94, 0xc4, 0x33, 0x85, 0xe0, 0xb3, 0x86, 0x0c, 0x13, 0xb2, 0x42, 0x38, 0x90, 0x7a, 0x51, 0x02,
+	0xfd, 0xb9, 0x3e, 0x78, 0xe2, 0x8c, 0x0f, 0x9e, 0xab, 0x45, 0xf2, 0xb9, 0xf8, 0xbd, 0xe7, 0xaf,
+	0x0a, 0x78, 0x21, 0x77, 0x23, 0xc0, 0x75, 0xa9, 0xec, 0xae, 0x26, 0xca, 0xee, 0xb7, 0x72, 0x0d,
+	0x63, 0xb5, 0xd7, 0xc9, 0x7e, 0xf6, 0x7b, 0xbb, 0xd8, 0xb3, 0x5f, 0x86, 0x76, 0x1f, 0xfd, 0xfe,
+	0xd7, 0x5e, 0x7d, 0xf2, 0xb4, 0x31, 0xf6, 0xd1, 0xd3, 0xc6, 0xd8, 0x27, 0x4f, 0x1b, 0x63, 0x3f,
+	0x1b, 0x36, 0x94, 0x27, 0xc3, 0x86, 0xf2, 0xd1, 0xb0, 0xa1, 0x7c, 0x32, 0x6c, 0x28, 0x7f, 0x1b,
+	0x36, 0x94, 0x5f, 0x7d, 0xda, 0x18, 0x7b, 0x7f, 0x42, 0x8c, 0xf8, 0xdf, 0x00, 0x00, 0x00, 0xff,
+	0xff, 0xd0, 0xf7, 0x24, 0x13, 0x48, 0x29, 0x00, 0x00,
 }
 
 func (m *ControllerRevision) Marshal() (dAtA []byte, err error) {
@@ -2133,6 +2133,18 @@ func (m *RollingUpdateDaemonSet) MarshalToSizedBuffer(dAtA []byte) (int, error)
 	_ = i
 	var l int
 	_ = l
+	if m.MaxSurge != nil {
+		{
+			size, err := m.MaxSurge.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintGenerated(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x12
+	}
 	if m.MaxUnavailable != nil {
 		{
 			size, err := m.MaxUnavailable.MarshalToSizedBuffer(dAtA[:i])
@@ -3081,6 +3093,10 @@ func (m *RollingUpdateDaemonSet) Size() (n int) {
 		l = m.MaxUnavailable.Size()
 		n += 1 + l + sovGenerated(uint64(l))
 	}
+	if m.MaxSurge != nil {
+		l = m.MaxSurge.Size()
+		n += 1 + l + sovGenerated(uint64(l))
+	}
 	return n
 }
 
@@ -3583,6 +3599,7 @@ func (this *RollingUpdateDaemonSet) String() string {
 	}
 	s := strings.Join([]string{`&RollingUpdateDaemonSet{`,
 		`MaxUnavailable:` + strings.Replace(fmt.Sprintf("%v", this.MaxUnavailable), "IntOrString", "intstr.IntOrString", 1) + `,`,
+		`MaxSurge:` + strings.Replace(fmt.Sprintf("%v", this.MaxSurge), "IntOrString", "intstr.IntOrString", 1) + `,`,
 		`}`,
 	}, "")
 	return s
@@ -7085,6 +7102,42 @@ func (m *RollingUpdateDaemonSet) Unmarshal(dAtA []byte) error {
 				return err
 			}
 			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field MaxSurge", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenerated
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.MaxSurge == nil {
+				m.MaxSurge = &intstr.IntOrString{}
+			}
+			if err := m.MaxSurge.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipGenerated(dAtA[iNdEx:])
diff --git a/staging/src/k8s.io/api/apps/v1beta2/generated.proto b/staging/src/k8s.io/api/apps/v1beta2/generated.proto
index 1ea7e23a812..ff306ba6a9a 100644
--- a/staging/src/k8s.io/api/apps/v1beta2/generated.proto
+++ b/staging/src/k8s.io/api/apps/v1beta2/generated.proto
@@ -487,19 +487,41 @@ message RollingUpdateDaemonSet {
   // The maximum number of DaemonSet pods that can be unavailable during the
   // update. Value can be an absolute number (ex: 5) or a percentage of total
   // number of DaemonSet pods at the start of the update (ex: 10%). Absolute
-  // number is calculated from percentage by rounding up.
-  // This cannot be 0.
+  // number is calculated from percentage by rounding down to a minimum of one.
+  // This cannot be 0 if MaxSurge is 0
   // Default value is 1.
   // Example: when this is set to 30%, at most 30% of the total number of nodes
   // that should be running the daemon pod (i.e. status.desiredNumberScheduled)
-  // can have their pods stopped for an update at any given
-  // time. The update starts by stopping at most 30% of those DaemonSet pods
-  // and then brings up new DaemonSet pods in their place. Once the new pods
-  // are available, it then proceeds onto other DaemonSet pods, thus ensuring
-  // that at least 70% of original number of DaemonSet pods are available at
-  // all times during the update.
+  // can have their pods stopped for an update at any given time. The update
+  // starts by stopping at most 30% of those DaemonSet pods and then brings
+  // up new DaemonSet pods in their place. Once the new pods are available,
+  // it then proceeds onto other DaemonSet pods, thus ensuring that at least
+  // 70% of original number of DaemonSet pods are available at all times during
+  // the update.
   // +optional
   optional k8s.io.apimachinery.pkg.util.intstr.IntOrString maxUnavailable = 1;
+
+  // The maximum number of nodes with an existing available DaemonSet pod that
+  // can have an updated DaemonSet pod during during an update.
+  // Value can be an absolute number (ex: 5) or a percentage of desired pods (ex: 10%).
+  // This can not be 0 if MaxUnavailable is 0.
+  // Absolute number is calculated from percentage by rounding up to a minimum of 1.
+  // Default value is 0.
+  // Example: when this is set to 30%, at most 30% of the total number of nodes
+  // that should be running the daemon pod (i.e. status.desiredNumberScheduled)
+  // can have their a new pod created before the old pod is marked as deleted.
+  // The update starts by launching new pods on 30% of nodes. Once an updated
+  // pod is available (Ready for at least minReadySeconds) the old DaemonSet pod
+  // on that node is marked deleted. If the old pod becomes unavailable for any
+  // reason (Ready transitions to false, is evicted, or is drained) an updated
+  // pod is immediatedly created on that node without considering surge limits.
+  // Allowing surge implies the possibility that the resources consumed by the
+  // daemonset on any given node can double if the readiness check fails, and
+  // so resource intensive daemonsets should take into account that they may
+  // cause evictions during disruption.
+  // This is an alpha field and requires enabling DaemonSetUpdateSurge feature gate.
+  // +optional
+  optional k8s.io.apimachinery.pkg.util.intstr.IntOrString maxSurge = 2;
 }
 
 // Spec to control the desired behavior of rolling update.
diff --git a/staging/src/k8s.io/api/apps/v1beta2/types.go b/staging/src/k8s.io/api/apps/v1beta2/types.go
index fc542ac1c87..316a0ad24d2 100644
--- a/staging/src/k8s.io/api/apps/v1beta2/types.go
+++ b/staging/src/k8s.io/api/apps/v1beta2/types.go
@@ -554,19 +554,41 @@ type RollingUpdateDaemonSet struct {
 	// The maximum number of DaemonSet pods that can be unavailable during the
 	// update. Value can be an absolute number (ex: 5) or a percentage of total
 	// number of DaemonSet pods at the start of the update (ex: 10%). Absolute
-	// number is calculated from percentage by rounding up.
-	// This cannot be 0.
+	// number is calculated from percentage by rounding down to a minimum of one.
+	// This cannot be 0 if MaxSurge is 0
 	// Default value is 1.
 	// Example: when this is set to 30%, at most 30% of the total number of nodes
 	// that should be running the daemon pod (i.e. status.desiredNumberScheduled)
-	// can have their pods stopped for an update at any given
-	// time. The update starts by stopping at most 30% of those DaemonSet pods
-	// and then brings up new DaemonSet pods in their place. Once the new pods
-	// are available, it then proceeds onto other DaemonSet pods, thus ensuring
-	// that at least 70% of original number of DaemonSet pods are available at
-	// all times during the update.
+	// can have their pods stopped for an update at any given time. The update
+	// starts by stopping at most 30% of those DaemonSet pods and then brings
+	// up new DaemonSet pods in their place. Once the new pods are available,
+	// it then proceeds onto other DaemonSet pods, thus ensuring that at least
+	// 70% of original number of DaemonSet pods are available at all times during
+	// the update.
 	// +optional
 	MaxUnavailable *intstr.IntOrString `json:"maxUnavailable,omitempty" protobuf:"bytes,1,opt,name=maxUnavailable"`
+
+	// The maximum number of nodes with an existing available DaemonSet pod that
+	// can have an updated DaemonSet pod during during an update.
+	// Value can be an absolute number (ex: 5) or a percentage of desired pods (ex: 10%).
+	// This can not be 0 if MaxUnavailable is 0.
+	// Absolute number is calculated from percentage by rounding up to a minimum of 1.
+	// Default value is 0.
+	// Example: when this is set to 30%, at most 30% of the total number of nodes
+	// that should be running the daemon pod (i.e. status.desiredNumberScheduled)
+	// can have their a new pod created before the old pod is marked as deleted.
+	// The update starts by launching new pods on 30% of nodes. Once an updated
+	// pod is available (Ready for at least minReadySeconds) the old DaemonSet pod
+	// on that node is marked deleted. If the old pod becomes unavailable for any
+	// reason (Ready transitions to false, is evicted, or is drained) an updated
+	// pod is immediatedly created on that node without considering surge limits.
+	// Allowing surge implies the possibility that the resources consumed by the
+	// daemonset on any given node can double if the readiness check fails, and
+	// so resource intensive daemonsets should take into account that they may
+	// cause evictions during disruption.
+	// This is an alpha field and requires enabling DaemonSetUpdateSurge feature gate.
+	// +optional
+	MaxSurge *intstr.IntOrString `json:"maxSurge,omitempty" protobuf:"bytes,2,opt,name=maxSurge"`
 }
 
 // DaemonSetSpec is the specification of a daemon set.
diff --git a/staging/src/k8s.io/api/apps/v1beta2/types_swagger_doc_generated.go b/staging/src/k8s.io/api/apps/v1beta2/types_swagger_doc_generated.go
index 822158a186b..51d55223484 100644
--- a/staging/src/k8s.io/api/apps/v1beta2/types_swagger_doc_generated.go
+++ b/staging/src/k8s.io/api/apps/v1beta2/types_swagger_doc_generated.go
@@ -262,7 +262,8 @@ func (ReplicaSetStatus) SwaggerDoc() map[string]string {
 
 var map_RollingUpdateDaemonSet = map[string]string{
 	"":               "Spec to control the desired behavior of daemon set rolling update.",
-	"maxUnavailable": "The maximum number of DaemonSet pods that can be unavailable during the update. Value can be an absolute number (ex: 5) or a percentage of total number of DaemonSet pods at the start of the update (ex: 10%). Absolute number is calculated from percentage by rounding up. This cannot be 0. Default value is 1. Example: when this is set to 30%, at most 30% of the total number of nodes that should be running the daemon pod (i.e. status.desiredNumberScheduled) can have their pods stopped for an update at any given time. The update starts by stopping at most 30% of those DaemonSet pods and then brings up new DaemonSet pods in their place. Once the new pods are available, it then proceeds onto other DaemonSet pods, thus ensuring that at least 70% of original number of DaemonSet pods are available at all times during the update.",
+	"maxUnavailable": "The maximum number of DaemonSet pods that can be unavailable during the update. Value can be an absolute number (ex: 5) or a percentage of total number of DaemonSet pods at the start of the update (ex: 10%). Absolute number is calculated from percentage by rounding down to a minimum of one. This cannot be 0 if MaxSurge is 0 Default value is 1. Example: when this is set to 30%, at most 30% of the total number of nodes that should be running the daemon pod (i.e. status.desiredNumberScheduled) can have their pods stopped for an update at any given time. The update starts by stopping at most 30% of those DaemonSet pods and then brings up new DaemonSet pods in their place. Once the new pods are available, it then proceeds onto other DaemonSet pods, thus ensuring that at least 70% of original number of DaemonSet pods are available at all times during the update.",
+	"maxSurge":       "The maximum number of nodes with an existing available DaemonSet pod that can have an updated DaemonSet pod during during an update. Value can be an absolute number (ex: 5) or a percentage of desired pods (ex: 10%). This can not be 0 if MaxUnavailable is 0. Absolute number is calculated from percentage by rounding up to a minimum of 1. Default value is 0. Example: when this is set to 30%, at most 30% of the total number of nodes that should be running the daemon pod (i.e. status.desiredNumberScheduled) can have their a new pod created before the old pod is marked as deleted. The update starts by launching new pods on 30% of nodes. Once an updated pod is available (Ready for at least minReadySeconds) the old DaemonSet pod on that node is marked deleted. If the old pod becomes unavailable for any reason (Ready transitions to false, is evicted, or is drained) an updated pod is immediatedly created on that node without considering surge limits. Allowing surge implies the possibility that the resources consumed by the daemonset on any given node can double if the readiness check fails, and so resource intensive daemonsets should take into account that they may cause evictions during disruption. This is an alpha field and requires enabling DaemonSetUpdateSurge feature gate.",
 }
 
 func (RollingUpdateDaemonSet) SwaggerDoc() map[string]string {
diff --git a/staging/src/k8s.io/api/apps/v1beta2/zz_generated.deepcopy.go b/staging/src/k8s.io/api/apps/v1beta2/zz_generated.deepcopy.go
index 127bf095f49..0a84d1b08a8 100644
--- a/staging/src/k8s.io/api/apps/v1beta2/zz_generated.deepcopy.go
+++ b/staging/src/k8s.io/api/apps/v1beta2/zz_generated.deepcopy.go
@@ -544,6 +544,11 @@ func (in *RollingUpdateDaemonSet) DeepCopyInto(out *RollingUpdateDaemonSet) {
 		*out = new(intstr.IntOrString)
 		**out = **in
 	}
+	if in.MaxSurge != nil {
+		in, out := &in.MaxSurge, &out.MaxSurge
+		*out = new(intstr.IntOrString)
+		**out = **in
+	}
 	return
 }
 
diff --git a/staging/src/k8s.io/api/extensions/v1beta1/generated.pb.go b/staging/src/k8s.io/api/extensions/v1beta1/generated.pb.go
index bd37f432c46..db2f82728e9 100644
--- a/staging/src/k8s.io/api/extensions/v1beta1/generated.pb.go
+++ b/staging/src/k8s.io/api/extensions/v1beta1/generated.pb.go
@@ -1683,241 +1683,241 @@ func init() {
 }
 
 var fileDescriptor_cdc93917efc28165 = []byte{
-	// 3743 bytes of a gzipped FileDescriptorProto
+	// 3742 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x5b, 0x4d, 0x6c, 0x1c, 0xc7,
 	0x72, 0xd6, 0xec, 0x2e, 0xb9, 0xcb, 0xe2, 0x7f, 0x93, 0x22, 0xf7, 0x49, 0x4f, 0x5c, 0xbd, 0x31,
 	0xa0, 0xc8, 0x8e, 0xb4, 0x6b, 0xc9, 0x92, 0x9e, 0x22, 0x21, 0xef, 0x99, 0x4b, 0x8a, 0x12, 0x5f,
 	0xf8, 0xb3, 0xee, 0x25, 0x65, 0xc3, 0x88, 0x1d, 0x0f, 0x77, 0x9b, 0xcb, 0x11, 0x67, 0x67, 0xc6,
-	0xd3, 0xb3, 0x34, 0x17, 0xc8, 0x21, 0x87, 0x20, 0x80, 0x81, 0x00, 0xc9, 0xc5, 0x49, 0x8e, 0x31,
-	0x02, 0xe4, 0x94, 0x20, 0xc7, 0xe4, 0x60, 0x18, 0x09, 0xe2, 0x00, 0x42, 0xe0, 0x04, 0xbe, 0xc5,
-	0x27, 0x22, 0xa6, 0x4f, 0x41, 0x4e, 0xb9, 0x05, 0x3a, 0x05, 0xdd, 0xd3, 0xf3, 0x3f, 0xc3, 0x1d,
-	0xd2, 0x12, 0x11, 0x03, 0xef, 0x24, 0x6e, 0x57, 0xd5, 0x57, 0xd5, 0xdd, 0xd5, 0x55, 0xd5, 0x3d,
-	0x25, 0x58, 0xd9, 0xbf, 0x4f, 0xab, 0xaa, 0x51, 0xdb, 0xef, 0xed, 0x10, 0x4b, 0x27, 0x36, 0xa1,
-	0xb5, 0x03, 0xa2, 0xb7, 0x0d, 0xab, 0x26, 0x08, 0x8a, 0xa9, 0xd6, 0xc8, 0xa1, 0x4d, 0x74, 0xaa,
-	0x1a, 0x3a, 0xad, 0x1d, 0xdc, 0xda, 0x21, 0xb6, 0x72, 0xab, 0xd6, 0x21, 0x3a, 0xb1, 0x14, 0x9b,
-	0xb4, 0xab, 0xa6, 0x65, 0xd8, 0x06, 0xba, 0xe2, 0xb0, 0x57, 0x15, 0x53, 0xad, 0xfa, 0xec, 0x55,
-	0xc1, 0x7e, 0xe9, 0x66, 0x47, 0xb5, 0xf7, 0x7a, 0x3b, 0xd5, 0x96, 0xd1, 0xad, 0x75, 0x8c, 0x8e,
-	0x51, 0xe3, 0x52, 0x3b, 0xbd, 0x5d, 0xfe, 0x8b, 0xff, 0xe0, 0x7f, 0x39, 0x68, 0x97, 0xe4, 0x80,
-	0xf2, 0x96, 0x61, 0x91, 0xda, 0x41, 0x4c, 0xe3, 0xa5, 0x3b, 0x3e, 0x4f, 0x57, 0x69, 0xed, 0xa9,
-	0x3a, 0xb1, 0xfa, 0x35, 0x73, 0xbf, 0xc3, 0x06, 0x68, 0xad, 0x4b, 0x6c, 0x25, 0x49, 0xaa, 0x96,
-	0x26, 0x65, 0xf5, 0x74, 0x5b, 0xed, 0x92, 0x98, 0xc0, 0xbd, 0x41, 0x02, 0xb4, 0xb5, 0x47, 0xba,
-	0x4a, 0x4c, 0xee, 0xad, 0x34, 0xb9, 0x9e, 0xad, 0x6a, 0x35, 0x55, 0xb7, 0xa9, 0x6d, 0x45, 0x85,
-	0xe4, 0x3b, 0x30, 0xb5, 0xa8, 0x69, 0xc6, 0x27, 0xa4, 0xbd, 0xd4, 0x5c, 0x5d, 0xb6, 0xd4, 0x03,
-	0x62, 0xa1, 0xab, 0x50, 0xd0, 0x95, 0x2e, 0x29, 0x4b, 0x57, 0xa5, 0xeb, 0x23, 0xf5, 0xb1, 0xe7,
-	0x47, 0x95, 0x0b, 0xc7, 0x47, 0x95, 0xc2, 0x86, 0xd2, 0x25, 0x98, 0x53, 0xe4, 0x87, 0x30, 0x2d,
-	0xa4, 0x56, 0x34, 0x72, 0xf8, 0xd4, 0xd0, 0x7a, 0x5d, 0x82, 0xae, 0xc1, 0x70, 0x9b, 0x03, 0x08,
-	0xc1, 0x09, 0x21, 0x38, 0xec, 0xc0, 0x62, 0x41, 0x95, 0x29, 0x4c, 0x0a, 0xe1, 0x27, 0x06, 0xb5,
-	0x1b, 0x8a, 0xbd, 0x87, 0x6e, 0x03, 0x98, 0x8a, 0xbd, 0xd7, 0xb0, 0xc8, 0xae, 0x7a, 0x28, 0xc4,
-	0x91, 0x10, 0x87, 0x86, 0x47, 0xc1, 0x01, 0x2e, 0x74, 0x03, 0x4a, 0x16, 0x51, 0xda, 0x9b, 0xba,
-	0xd6, 0x2f, 0xe7, 0xae, 0x4a, 0xd7, 0x4b, 0xf5, 0x29, 0x21, 0x51, 0xc2, 0x62, 0x1c, 0x7b, 0x1c,
-	0xf2, 0x67, 0x39, 0x18, 0x59, 0x56, 0x48, 0xd7, 0xd0, 0x9b, 0xc4, 0x46, 0x1f, 0x41, 0x89, 0x6d,
-	0x57, 0x5b, 0xb1, 0x15, 0xae, 0x6d, 0xf4, 0xf6, 0x9b, 0x55, 0xdf, 0x9d, 0xbc, 0xd5, 0xab, 0x9a,
-	0xfb, 0x1d, 0x36, 0x40, 0xab, 0x8c, 0xbb, 0x7a, 0x70, 0xab, 0xba, 0xb9, 0xf3, 0x8c, 0xb4, 0xec,
-	0x75, 0x62, 0x2b, 0xbe, 0x7d, 0xfe, 0x18, 0xf6, 0x50, 0xd1, 0x06, 0x14, 0xa8, 0x49, 0x5a, 0xdc,
-	0xb2, 0xd1, 0xdb, 0x37, 0xaa, 0x27, 0x3a, 0x6b, 0xd5, 0xb3, 0xac, 0x69, 0x92, 0x96, 0xbf, 0xe2,
-	0xec, 0x17, 0xe6, 0x38, 0xe8, 0x29, 0x0c, 0x53, 0x5b, 0xb1, 0x7b, 0xb4, 0x9c, 0xe7, 0x88, 0xd5,
-	0xcc, 0x88, 0x5c, 0xca, 0xdf, 0x0c, 0xe7, 0x37, 0x16, 0x68, 0xf2, 0x7f, 0xe5, 0x00, 0x79, 0xbc,
-	0x4b, 0x86, 0xde, 0x56, 0x6d, 0xd5, 0xd0, 0xd1, 0x03, 0x28, 0xd8, 0x7d, 0xd3, 0x75, 0x81, 0x6b,
-	0xae, 0x41, 0x5b, 0x7d, 0x93, 0xbc, 0x38, 0xaa, 0xcc, 0xc5, 0x25, 0x18, 0x05, 0x73, 0x19, 0xb4,
-	0xe6, 0x99, 0x9a, 0xe3, 0xd2, 0x77, 0xc2, 0xaa, 0x5f, 0x1c, 0x55, 0x12, 0x0e, 0x5b, 0xd5, 0x43,
-	0x0a, 0x1b, 0x88, 0x0e, 0x00, 0x69, 0x0a, 0xb5, 0xb7, 0x2c, 0x45, 0xa7, 0x8e, 0x26, 0xb5, 0x4b,
-	0xc4, 0x22, 0xbc, 0x91, 0x6d, 0xd3, 0x98, 0x44, 0xfd, 0x92, 0xb0, 0x02, 0xad, 0xc5, 0xd0, 0x70,
-	0x82, 0x06, 0xe6, 0xcd, 0x16, 0x51, 0xa8, 0xa1, 0x97, 0x0b, 0x61, 0x6f, 0xc6, 0x7c, 0x14, 0x0b,
-	0x2a, 0x7a, 0x1d, 0x8a, 0x5d, 0x42, 0xa9, 0xd2, 0x21, 0xe5, 0x21, 0xce, 0x38, 0x29, 0x18, 0x8b,
-	0xeb, 0xce, 0x30, 0x76, 0xe9, 0xf2, 0x17, 0x12, 0x8c, 0x7b, 0x2b, 0xb7, 0xa6, 0x52, 0x1b, 0xfd,
-	0x6e, 0xcc, 0x0f, 0xab, 0xd9, 0xa6, 0xc4, 0xa4, 0xb9, 0x17, 0x7a, 0x3e, 0xef, 0x8e, 0x04, 0x7c,
-	0x70, 0x1d, 0x86, 0x54, 0x9b, 0x74, 0xd9, 0x3e, 0xe4, 0xaf, 0x8f, 0xde, 0xbe, 0x9e, 0xd5, 0x65,
-	0xea, 0xe3, 0x02, 0x74, 0x68, 0x95, 0x89, 0x63, 0x07, 0x45, 0xfe, 0xb3, 0x42, 0xc0, 0x7c, 0xe6,
-	0x9a, 0xe8, 0x03, 0x28, 0x51, 0xa2, 0x91, 0x96, 0x6d, 0x58, 0xc2, 0xfc, 0xb7, 0x32, 0x9a, 0xaf,
-	0xec, 0x10, 0xad, 0x29, 0x44, 0xeb, 0x63, 0xcc, 0x7e, 0xf7, 0x17, 0xf6, 0x20, 0xd1, 0x3b, 0x50,
-	0xb2, 0x49, 0xd7, 0xd4, 0x14, 0x9b, 0x88, 0x73, 0xf4, 0x5a, 0x70, 0x0a, 0xcc, 0x73, 0x18, 0x58,
-	0xc3, 0x68, 0x6f, 0x09, 0x36, 0x7e, 0x7c, 0xbc, 0x25, 0x71, 0x47, 0xb1, 0x07, 0x83, 0x0e, 0x60,
-	0xa2, 0x67, 0xb6, 0x19, 0xa7, 0xcd, 0xa2, 0x60, 0xa7, 0x2f, 0x3c, 0xe9, 0x5e, 0xd6, 0xb5, 0xd9,
-	0x0e, 0x49, 0xd7, 0xe7, 0x84, 0xae, 0x89, 0xf0, 0x38, 0x8e, 0x68, 0x41, 0x8b, 0x30, 0xd9, 0x55,
-	0x75, 0x16, 0x97, 0xfa, 0x4d, 0xd2, 0x32, 0xf4, 0x36, 0xe5, 0x6e, 0x35, 0x54, 0x9f, 0x17, 0x00,
-	0x93, 0xeb, 0x61, 0x32, 0x8e, 0xf2, 0xa3, 0x5f, 0x01, 0x72, 0xa7, 0xf1, 0xd8, 0x09, 0xe2, 0xaa,
-	0xa1, 0x73, 0x9f, 0xcb, 0xfb, 0xce, 0xbd, 0x15, 0xe3, 0xc0, 0x09, 0x52, 0x68, 0x0d, 0x66, 0x2d,
-	0x72, 0xa0, 0xb2, 0x39, 0x3e, 0x51, 0xa9, 0x6d, 0x58, 0xfd, 0x35, 0xb5, 0xab, 0xda, 0xe5, 0x61,
-	0x6e, 0x53, 0xf9, 0xf8, 0xa8, 0x32, 0x8b, 0x13, 0xe8, 0x38, 0x51, 0x4a, 0xfe, 0xf3, 0x61, 0x98,
-	0x8c, 0xc4, 0x1b, 0xf4, 0x14, 0xe6, 0x5a, 0x3d, 0xcb, 0x22, 0xba, 0xbd, 0xd1, 0xeb, 0xee, 0x10,
-	0xab, 0xd9, 0xda, 0x23, 0xed, 0x9e, 0x46, 0xda, 0xdc, 0x51, 0x86, 0xea, 0x0b, 0xc2, 0xe2, 0xb9,
-	0xa5, 0x44, 0x2e, 0x9c, 0x22, 0xcd, 0x56, 0x41, 0xe7, 0x43, 0xeb, 0x2a, 0xa5, 0x1e, 0x66, 0x8e,
-	0x63, 0x7a, 0xab, 0xb0, 0x11, 0xe3, 0xc0, 0x09, 0x52, 0xcc, 0xc6, 0x36, 0xa1, 0xaa, 0x45, 0xda,
-	0x51, 0x1b, 0xf3, 0x61, 0x1b, 0x97, 0x13, 0xb9, 0x70, 0x8a, 0x34, 0xba, 0x0b, 0xa3, 0x8e, 0x36,
-	0xbe, 0x7f, 0x62, 0xa3, 0x67, 0x04, 0xd8, 0xe8, 0x86, 0x4f, 0xc2, 0x41, 0x3e, 0x36, 0x35, 0x63,
-	0x87, 0x12, 0xeb, 0x80, 0xb4, 0xd3, 0x37, 0x78, 0x33, 0xc6, 0x81, 0x13, 0xa4, 0xd8, 0xd4, 0x1c,
-	0x0f, 0x8c, 0x4d, 0x6d, 0x38, 0x3c, 0xb5, 0xed, 0x44, 0x2e, 0x9c, 0x22, 0xcd, 0xfc, 0xd8, 0x31,
-	0x79, 0xf1, 0x40, 0x51, 0x35, 0x65, 0x47, 0x23, 0xe5, 0x62, 0xd8, 0x8f, 0x37, 0xc2, 0x64, 0x1c,
-	0xe5, 0x47, 0x8f, 0x61, 0xda, 0x19, 0xda, 0xd6, 0x15, 0x0f, 0xa4, 0xc4, 0x41, 0x7e, 0x22, 0x40,
-	0xa6, 0x37, 0xa2, 0x0c, 0x38, 0x2e, 0x83, 0x1e, 0xc0, 0x44, 0xcb, 0xd0, 0x34, 0xee, 0x8f, 0x4b,
-	0x46, 0x4f, 0xb7, 0xcb, 0x23, 0x1c, 0x05, 0xb1, 0xf3, 0xb8, 0x14, 0xa2, 0xe0, 0x08, 0x27, 0x22,
-	0x00, 0x2d, 0x37, 0xe1, 0xd0, 0x32, 0xf0, 0xf8, 0x78, 0x2b, 0x6b, 0x0c, 0xf0, 0x52, 0x95, 0x5f,
-	0x03, 0x78, 0x43, 0x14, 0x07, 0x80, 0xe5, 0x7f, 0x95, 0x60, 0x3e, 0x25, 0x74, 0xa0, 0x5f, 0x86,
-	0x52, 0xec, 0x6f, 0x46, 0x52, 0xec, 0xe5, 0x14, 0xb1, 0x40, 0x9e, 0xd5, 0x61, 0xdc, 0x62, 0xb3,
-	0xd2, 0x3b, 0x0e, 0x8b, 0x88, 0x91, 0x77, 0x07, 0x4c, 0x03, 0x07, 0x65, 0xfc, 0x98, 0x3f, 0x7d,
-	0x7c, 0x54, 0x19, 0x0f, 0xd1, 0x70, 0x18, 0x5e, 0xfe, 0x8b, 0x1c, 0xc0, 0x32, 0x31, 0x35, 0xa3,
-	0xdf, 0x25, 0xfa, 0x79, 0xd4, 0x50, 0x9b, 0xa1, 0x1a, 0xea, 0xe6, 0xa0, 0xed, 0xf1, 0x4c, 0x4b,
-	0x2d, 0xa2, 0xde, 0x8d, 0x14, 0x51, 0xb5, 0xec, 0x90, 0x27, 0x57, 0x51, 0xff, 0x91, 0x87, 0x19,
-	0x9f, 0xd9, 0x2f, 0xa3, 0x1e, 0x86, 0xf6, 0xf8, 0x37, 0x22, 0x7b, 0x3c, 0x9f, 0x20, 0xf2, 0xca,
-	0xea, 0xa8, 0x67, 0x30, 0xc1, 0xaa, 0x1c, 0x67, 0x2f, 0x79, 0x0d, 0x35, 0x7c, 0xea, 0x1a, 0xca,
-	0xcb, 0x76, 0x6b, 0x21, 0x24, 0x1c, 0x41, 0x4e, 0xa9, 0xd9, 0x8a, 0x3f, 0xc6, 0x9a, 0xed, 0x4b,
-	0x09, 0x26, 0xfc, 0x6d, 0x3a, 0x87, 0xa2, 0x6d, 0x23, 0x5c, 0xb4, 0xbd, 0x9e, 0xd9, 0x45, 0x53,
-	0xaa, 0xb6, 0xff, 0x65, 0x05, 0xbe, 0xc7, 0xc4, 0x0e, 0xf8, 0x8e, 0xd2, 0xda, 0x1f, 0x7c, 0xc7,
-	0x43, 0x9f, 0x49, 0x80, 0x44, 0x16, 0x58, 0xd4, 0x75, 0xc3, 0x56, 0x9c, 0x58, 0xe9, 0x98, 0xb5,
-	0x9a, 0xd9, 0x2c, 0x57, 0x63, 0x75, 0x3b, 0x86, 0xf5, 0x48, 0xb7, 0xad, 0xbe, 0xbf, 0xc9, 0x71,
-	0x06, 0x9c, 0x60, 0x00, 0x52, 0x00, 0x2c, 0x81, 0xb9, 0x65, 0x88, 0x83, 0x7c, 0x33, 0x43, 0xcc,
-	0x63, 0x02, 0x4b, 0x86, 0xbe, 0xab, 0x76, 0xfc, 0xb0, 0x83, 0x3d, 0x20, 0x1c, 0x00, 0xbd, 0xf4,
-	0x08, 0xe6, 0x53, 0xac, 0x45, 0x53, 0x90, 0xdf, 0x27, 0x7d, 0x67, 0xd9, 0x30, 0xfb, 0x13, 0xcd,
-	0xc2, 0xd0, 0x81, 0xa2, 0xf5, 0x9c, 0xf0, 0x3b, 0x82, 0x9d, 0x1f, 0x0f, 0x72, 0xf7, 0x25, 0xf9,
-	0x8b, 0xa1, 0xa0, 0xef, 0xf0, 0x8a, 0xf9, 0x3a, 0xbb, 0xb4, 0x9a, 0x9a, 0xda, 0x52, 0xa8, 0x28,
-	0x84, 0xc6, 0x9c, 0x0b, 0xab, 0x33, 0x86, 0x3d, 0x6a, 0xa8, 0xb6, 0xce, 0xbd, 0xda, 0xda, 0x3a,
-	0xff, 0x72, 0x6a, 0xeb, 0xdf, 0x83, 0x12, 0x75, 0xab, 0xea, 0x02, 0x87, 0xbc, 0x75, 0x8a, 0xf8,
-	0x2a, 0x0a, 0x6a, 0x4f, 0x81, 0x57, 0x4a, 0x7b, 0xa0, 0x49, 0x45, 0xf4, 0xd0, 0x29, 0x8b, 0xe8,
-	0x97, 0x5a, 0xf8, 0xb2, 0x78, 0x63, 0x2a, 0x3d, 0x4a, 0xda, 0x3c, 0xb6, 0x95, 0xfc, 0x78, 0xd3,
-	0xe0, 0xa3, 0x58, 0x50, 0xd1, 0x07, 0x21, 0x97, 0x2d, 0x9d, 0xc5, 0x65, 0x27, 0xd2, 0xdd, 0x15,
-	0x6d, 0xc3, 0xbc, 0x69, 0x19, 0x1d, 0x8b, 0x50, 0xba, 0x4c, 0x94, 0xb6, 0xa6, 0xea, 0xc4, 0x5d,
-	0x1f, 0xa7, 0x22, 0xba, 0x7c, 0x7c, 0x54, 0x99, 0x6f, 0x24, 0xb3, 0xe0, 0x34, 0x59, 0xf9, 0x79,
-	0x01, 0xa6, 0xa2, 0x19, 0x30, 0xa5, 0x48, 0x95, 0xce, 0x54, 0xa4, 0xde, 0x08, 0x1c, 0x06, 0xa7,
-	0x82, 0x0f, 0xbc, 0xe0, 0xc4, 0x0e, 0xc4, 0x22, 0x4c, 0x8a, 0x68, 0xe0, 0x12, 0x45, 0x99, 0xee,
-	0xed, 0xfe, 0x76, 0x98, 0x8c, 0xa3, 0xfc, 0xe8, 0x21, 0x8c, 0x5b, 0xbc, 0xee, 0x76, 0x01, 0x9c,
-	0xda, 0xf5, 0xa2, 0x00, 0x18, 0xc7, 0x41, 0x22, 0x0e, 0xf3, 0xb2, 0xba, 0xd5, 0x2f, 0x47, 0x5d,
-	0x80, 0x42, 0xb8, 0x6e, 0x5d, 0x8c, 0x32, 0xe0, 0xb8, 0x0c, 0x5a, 0x87, 0x99, 0x9e, 0x1e, 0x87,
-	0x72, 0x5c, 0xf9, 0xb2, 0x80, 0x9a, 0xd9, 0x8e, 0xb3, 0xe0, 0x24, 0x39, 0xb4, 0x1b, 0x2a, 0x65,
-	0x87, 0x79, 0x78, 0xbe, 0x9d, 0xf9, 0xe0, 0x65, 0xae, 0x65, 0x13, 0xca, 0xed, 0x52, 0xd6, 0x72,
-	0x5b, 0xfe, 0x27, 0x29, 0x98, 0x84, 0xbc, 0x12, 0x78, 0xd0, 0x2b, 0x53, 0x4c, 0x22, 0x50, 0x1d,
-	0x19, 0xc9, 0xd5, 0xef, 0xbd, 0x53, 0x55, 0xbf, 0x7e, 0xf2, 0x1c, 0x5c, 0xfe, 0x7e, 0x2e, 0xc1,
-	0xdc, 0x4a, 0xf3, 0xb1, 0x65, 0xf4, 0x4c, 0xd7, 0x9c, 0x4d, 0xd3, 0x59, 0x9a, 0x9f, 0x43, 0xc1,
-	0xea, 0x69, 0xee, 0x3c, 0x5e, 0x73, 0xe7, 0x81, 0x7b, 0x1a, 0x9b, 0xc7, 0x4c, 0x44, 0xca, 0x99,
-	0x04, 0x13, 0x40, 0x1b, 0x30, 0x6c, 0x29, 0x7a, 0x87, 0xb8, 0x69, 0xf5, 0xda, 0x00, 0xeb, 0x57,
-	0x97, 0x31, 0x63, 0x0f, 0x14, 0x36, 0x5c, 0x1a, 0x0b, 0x14, 0xf9, 0x9f, 0x25, 0x98, 0x7c, 0xb2,
-	0xb5, 0xd5, 0x58, 0xd5, 0xf9, 0x89, 0xe6, 0x6f, 0xab, 0x57, 0xa1, 0x60, 0x2a, 0xf6, 0x5e, 0x34,
-	0xd3, 0x33, 0x1a, 0xe6, 0x14, 0x74, 0x07, 0x4a, 0xec, 0x5f, 0x66, 0x17, 0x3f, 0x52, 0x23, 0x3c,
-	0x10, 0x96, 0x1a, 0x62, 0xec, 0x45, 0xe0, 0x6f, 0xec, 0x71, 0xa2, 0xf7, 0xa0, 0xc8, 0xe2, 0x0f,
-	0xd1, 0xdb, 0x19, 0x0b, 0x74, 0x61, 0x54, 0xdd, 0x11, 0xf2, 0x6b, 0x2e, 0x31, 0x80, 0x5d, 0x38,
-	0x79, 0x1f, 0x66, 0x03, 0x93, 0x60, 0xab, 0xf8, 0x94, 0xe5, 0x54, 0xd4, 0x84, 0x21, 0xa6, 0x9d,
-	0x65, 0xce, 0x7c, 0x86, 0x27, 0xd0, 0xc8, 0x42, 0xf8, 0xf5, 0x11, 0xfb, 0x45, 0xb1, 0x83, 0x25,
-	0xaf, 0xc3, 0x38, 0x7f, 0x86, 0x36, 0x2c, 0x9b, 0x2f, 0x26, 0xba, 0x02, 0xf9, 0xae, 0xaa, 0x8b,
-	0xec, 0x3c, 0x2a, 0x64, 0xf2, 0x2c, 0xb3, 0xb0, 0x71, 0x4e, 0x56, 0x0e, 0x45, 0xbc, 0xf2, 0xc9,
-	0xca, 0x21, 0x66, 0xe3, 0xf2, 0x63, 0x28, 0x8a, 0x4d, 0x0a, 0x02, 0xe5, 0x4f, 0x06, 0xca, 0x27,
-	0x00, 0x6d, 0x42, 0x71, 0xb5, 0x51, 0xd7, 0x0c, 0xa7, 0x56, 0x6b, 0xa9, 0x6d, 0x2b, 0xba, 0x83,
-	0x4b, 0xab, 0xcb, 0x18, 0x73, 0x0a, 0x92, 0x61, 0x98, 0x1c, 0xb6, 0x88, 0x69, 0x73, 0x3f, 0x1a,
-	0xa9, 0x03, 0xf3, 0x8d, 0x47, 0x7c, 0x04, 0x0b, 0x8a, 0xfc, 0x27, 0x39, 0x28, 0x8a, 0xe5, 0x38,
-	0x87, 0xbb, 0xdb, 0x5a, 0xe8, 0xee, 0xf6, 0x46, 0x36, 0xd7, 0x48, 0xbd, 0xb8, 0x6d, 0x45, 0x2e,
-	0x6e, 0x37, 0x32, 0xe2, 0x9d, 0x7c, 0x6b, 0xfb, 0x34, 0x07, 0x13, 0x61, 0xa7, 0x44, 0x77, 0x61,
-	0x94, 0xa5, 0x29, 0xb5, 0x45, 0x36, 0xfc, 0xea, 0xd8, 0x7b, 0xba, 0x69, 0xfa, 0x24, 0x1c, 0xe4,
-	0x43, 0x1d, 0x4f, 0x8c, 0xf9, 0x91, 0x98, 0x74, 0xfa, 0x92, 0xf6, 0x6c, 0x55, 0xab, 0x3a, 0x1f,
-	0x64, 0xaa, 0xab, 0xba, 0xbd, 0x69, 0x35, 0x6d, 0x4b, 0xd5, 0x3b, 0x31, 0x45, 0xdc, 0x29, 0x83,
-	0xc8, 0xe8, 0x5d, 0x96, 0x32, 0xa9, 0xd1, 0xb3, 0x5a, 0x24, 0xa9, 0xf4, 0x75, 0xcb, 0x36, 0x76,
-	0x40, 0xdb, 0x6b, 0x46, 0x4b, 0xd1, 0x9c, 0xcd, 0xc1, 0x64, 0x97, 0x58, 0x44, 0x6f, 0x11, 0xb7,
-	0xdc, 0x74, 0x20, 0xb0, 0x07, 0x26, 0xff, 0x83, 0x04, 0xa3, 0x62, 0x2d, 0xce, 0xe1, 0x92, 0xf3,
-	0x3b, 0xe1, 0x4b, 0xce, 0xb5, 0x8c, 0x91, 0x23, 0xf9, 0x86, 0xf3, 0xd7, 0xbe, 0xe9, 0x2c, 0x56,
-	0xb0, 0xe3, 0xb2, 0x67, 0x50, 0x3b, 0x7a, 0x5c, 0xd8, 0x29, 0xc7, 0x9c, 0x82, 0x7a, 0x30, 0xa5,
-	0x46, 0x82, 0x8b, 0xd8, 0xb3, 0x5a, 0x36, 0x4b, 0x3c, 0xb1, 0x7a, 0x59, 0xc0, 0x4f, 0x45, 0x29,
-	0x38, 0xa6, 0x42, 0x26, 0x10, 0xe3, 0x42, 0xef, 0x40, 0x61, 0xcf, 0xb6, 0xcd, 0x84, 0xe7, 0xf3,
-	0x01, 0x21, 0xcd, 0x37, 0xa1, 0xc4, 0x67, 0xb7, 0xb5, 0xd5, 0xc0, 0x1c, 0x4a, 0xfe, 0xc7, 0x9c,
-	0xb7, 0x1e, 0xfc, 0xce, 0xf1, 0xb6, 0x37, 0xdb, 0x25, 0x4d, 0xa1, 0x94, 0x3b, 0xb6, 0x73, 0x3f,
-	0x9e, 0x0d, 0x18, 0xee, 0xd1, 0x70, 0x8c, 0x1b, 0x6d, 0xf9, 0xa1, 0x5e, 0x3a, 0x4b, 0xa8, 0x1f,
-	0x4d, 0x0a, 0xf3, 0xe8, 0x09, 0xe4, 0x6d, 0x2d, 0xeb, 0x3d, 0x57, 0x20, 0x6e, 0xad, 0x35, 0xfd,
-	0x58, 0xb9, 0xb5, 0xd6, 0xc4, 0x0c, 0x02, 0x6d, 0xc2, 0x10, 0x4b, 0xa7, 0x2c, 0x3a, 0xe4, 0xb3,
-	0x47, 0x1b, 0xb6, 0x82, 0xbe, 0x4b, 0xb1, 0x5f, 0x14, 0x3b, 0x38, 0xf2, 0xc7, 0x30, 0x1e, 0x0a,
-	0x21, 0xe8, 0x23, 0x18, 0xd3, 0x0c, 0xa5, 0x5d, 0x57, 0x34, 0x45, 0x6f, 0x11, 0xf7, 0x6b, 0xc7,
-	0xb5, 0xa4, 0xb3, 0xb7, 0x16, 0xe0, 0x13, 0x01, 0x68, 0x56, 0x28, 0x19, 0x0b, 0xd2, 0x70, 0x08,
-	0x51, 0x56, 0x00, 0xfc, 0x39, 0xa2, 0x0a, 0x0c, 0x31, 0x4f, 0x75, 0x52, 0xdd, 0x48, 0x7d, 0x84,
-	0x59, 0xc8, 0x1c, 0x98, 0x62, 0x67, 0x1c, 0xdd, 0x06, 0xa0, 0xa4, 0x65, 0x11, 0x9b, 0x6f, 0x67,
-	0x2e, 0xfc, 0xc5, 0xb4, 0xe9, 0x51, 0x70, 0x80, 0x4b, 0xfe, 0x17, 0x09, 0xc6, 0x37, 0x88, 0xfd,
-	0x89, 0x61, 0xed, 0x37, 0x0c, 0x4d, 0x6d, 0xf5, 0xcf, 0x21, 0x0f, 0xe0, 0x50, 0x1e, 0x78, 0x73,
-	0xc0, 0xce, 0x84, 0xac, 0x4b, 0xcb, 0x06, 0xf2, 0x97, 0x12, 0xcc, 0x87, 0x38, 0x1f, 0xf9, 0x87,
-	0x7f, 0x1b, 0x86, 0x4c, 0xc3, 0xb2, 0xdd, 0x1a, 0xe1, 0x54, 0x0a, 0x59, 0x84, 0x0d, 0x54, 0x09,
-	0x0c, 0x06, 0x3b, 0x68, 0x68, 0x0d, 0x72, 0xb6, 0x21, 0x5c, 0xf5, 0x74, 0x98, 0x84, 0x58, 0x75,
-	0x10, 0x98, 0xb9, 0x2d, 0x03, 0xe7, 0x6c, 0x83, 0x6d, 0x44, 0x39, 0xc4, 0x15, 0x0c, 0x5f, 0xaf,
-	0x68, 0x06, 0x18, 0x0a, 0xbb, 0x96, 0xd1, 0x3d, 0xf3, 0x1c, 0xbc, 0x8d, 0x58, 0xb1, 0x8c, 0x2e,
-	0xe6, 0x58, 0xf2, 0x57, 0x12, 0x4c, 0x87, 0x38, 0xcf, 0x21, 0x75, 0xbc, 0x13, 0x4e, 0x1d, 0x37,
-	0x4e, 0x33, 0x91, 0x94, 0x04, 0xf2, 0x55, 0x2e, 0x32, 0x0d, 0x36, 0x61, 0xb4, 0x0b, 0xa3, 0xa6,
-	0xd1, 0x6e, 0xbe, 0x84, 0xef, 0x9b, 0x93, 0x2c, 0xa5, 0x37, 0x7c, 0x2c, 0x1c, 0x04, 0x46, 0x87,
-	0x30, 0xad, 0x2b, 0x5d, 0x42, 0x4d, 0xa5, 0x45, 0x9a, 0x2f, 0xe1, 0xc5, 0xe7, 0x22, 0xff, 0x80,
-	0x12, 0x45, 0xc4, 0x71, 0x25, 0x68, 0x1d, 0x8a, 0xaa, 0xc9, 0x4b, 0x4c, 0x51, 0x4b, 0x0c, 0xcc,
-	0xc3, 0x4e, 0x41, 0xea, 0xc4, 0x73, 0xf1, 0x03, 0xbb, 0x18, 0xf2, 0xdf, 0x44, 0xbd, 0x81, 0x57,
-	0x2c, 0x8f, 0xa1, 0xc4, 0x3b, 0x4d, 0x5a, 0x86, 0xe6, 0x7e, 0xea, 0xe0, 0x97, 0x0b, 0x31, 0xf6,
-	0xe2, 0xa8, 0x72, 0x39, 0xe1, 0x15, 0xdb, 0x25, 0x63, 0x4f, 0x18, 0x6d, 0x40, 0xc1, 0xfc, 0x21,
-	0xc5, 0x15, 0x4f, 0x93, 0xbc, 0xa2, 0xe2, 0x38, 0xf2, 0x1f, 0xe6, 0x23, 0xe6, 0xf2, 0x64, 0xf9,
-	0xec, 0xa5, 0xed, 0xba, 0x57, 0xcc, 0xa5, 0xee, 0xfc, 0x0e, 0x14, 0x45, 0xaa, 0x15, 0xce, 0xfc,
-	0xf3, 0xd3, 0x38, 0x73, 0x30, 0x8b, 0x79, 0x77, 0x29, 0x77, 0xd0, 0x05, 0x46, 0x1f, 0xc2, 0x30,
-	0x71, 0x54, 0x38, 0xb9, 0xf1, 0xde, 0x69, 0x54, 0xf8, 0x71, 0xd5, 0xaf, 0xa1, 0xc5, 0x98, 0x40,
-	0x45, 0xbf, 0x64, 0xeb, 0xc5, 0x78, 0x59, 0xc9, 0x49, 0xcb, 0x05, 0x9e, 0xae, 0xae, 0x38, 0xd3,
-	0xf6, 0x86, 0x5f, 0x1c, 0x55, 0xc0, 0xff, 0x89, 0x83, 0x12, 0xf2, 0xbf, 0x49, 0x30, 0xcd, 0x57,
-	0xa8, 0xd5, 0xb3, 0x54, 0xbb, 0x7f, 0x6e, 0x89, 0xe9, 0x69, 0x28, 0x31, 0xdd, 0x19, 0xb0, 0x2c,
-	0x31, 0x0b, 0x53, 0x93, 0xd3, 0xd7, 0x12, 0x5c, 0x8c, 0x71, 0x9f, 0x43, 0x5c, 0xdc, 0x0e, 0xc7,
-	0xc5, 0x37, 0x4f, 0x3b, 0xa1, 0x94, 0xd8, 0xf8, 0x3f, 0xd3, 0x09, 0xd3, 0xe1, 0x27, 0xe5, 0x36,
-	0x80, 0x69, 0xa9, 0x07, 0xaa, 0x46, 0x3a, 0xe2, 0xab, 0x7e, 0x29, 0xd0, 0xb3, 0xe5, 0x51, 0x70,
-	0x80, 0x0b, 0x51, 0x98, 0x6b, 0x93, 0x5d, 0xa5, 0xa7, 0xd9, 0x8b, 0xed, 0xf6, 0x92, 0x62, 0x2a,
-	0x3b, 0xaa, 0xa6, 0xda, 0xaa, 0x78, 0xff, 0x18, 0xa9, 0x3f, 0x74, 0xbe, 0xb6, 0x27, 0x71, 0xbc,
-	0x38, 0xaa, 0x5c, 0x49, 0xfa, 0xdc, 0xe5, 0xb2, 0xf4, 0x71, 0x0a, 0x34, 0xea, 0x43, 0xd9, 0x22,
-	0x1f, 0xf7, 0x54, 0x8b, 0xb4, 0x97, 0x2d, 0xc3, 0x0c, 0xa9, 0xcd, 0x73, 0xb5, 0xbf, 0x7d, 0x7c,
-	0x54, 0x29, 0xe3, 0x14, 0x9e, 0xc1, 0x8a, 0x53, 0xe1, 0xd1, 0x33, 0x98, 0x51, 0x44, 0x77, 0x5d,
-	0x50, 0xab, 0x73, 0x4a, 0xee, 0x1f, 0x1f, 0x55, 0x66, 0x16, 0xe3, 0xe4, 0xc1, 0x0a, 0x93, 0x40,
-	0x51, 0x0d, 0x8a, 0x07, 0xbc, 0x11, 0x8f, 0x96, 0x87, 0x38, 0x3e, 0x4b, 0x04, 0x45, 0xa7, 0x37,
-	0x8f, 0x61, 0x0e, 0xaf, 0x34, 0xf9, 0xe9, 0x73, 0xb9, 0xd8, 0x5d, 0x97, 0xd5, 0x92, 0xe2, 0xc4,
-	0xf3, 0x27, 0xf0, 0x92, 0x1f, 0xb5, 0x9e, 0xf8, 0x24, 0x1c, 0xe4, 0x43, 0x1f, 0xc0, 0xc8, 0x9e,
-	0x78, 0x30, 0xa1, 0xe5, 0x62, 0xa6, 0x24, 0x1c, 0x7a, 0x60, 0xa9, 0x4f, 0x0b, 0x15, 0x23, 0xee,
-	0x30, 0xc5, 0x3e, 0x22, 0x7a, 0x1d, 0x8a, 0xfc, 0xc7, 0xea, 0x32, 0x7f, 0x5f, 0x2c, 0xf9, 0xb1,
-	0xed, 0x89, 0x33, 0x8c, 0x5d, 0xba, 0xcb, 0xba, 0xda, 0x58, 0xe2, 0xef, 0xdc, 0x11, 0xd6, 0xd5,
-	0xc6, 0x12, 0x76, 0xe9, 0xe8, 0x23, 0x28, 0x52, 0xb2, 0xa6, 0xea, 0xbd, 0xc3, 0x32, 0x64, 0xfa,
-	0x4a, 0xde, 0x7c, 0xc4, 0xb9, 0x23, 0x2f, 0x7d, 0xbe, 0x06, 0x41, 0xc7, 0x2e, 0x2c, 0xda, 0x83,
-	0x11, 0xab, 0xa7, 0x2f, 0xd2, 0x6d, 0x4a, 0xac, 0xf2, 0x28, 0xd7, 0x31, 0x28, 0x9c, 0x63, 0x97,
-	0x3f, 0xaa, 0xc5, 0x5b, 0x21, 0x8f, 0x03, 0xfb, 0xe0, 0x68, 0x0f, 0x80, 0xff, 0xe0, 0x8f, 0x8a,
-	0xe5, 0x39, 0xae, 0xea, 0x7e, 0x16, 0x55, 0x49, 0x6f, 0x97, 0xe2, 0xc3, 0x82, 0x47, 0xc6, 0x01,
-	0x6c, 0xf4, 0xc7, 0x12, 0x20, 0xda, 0x33, 0x4d, 0x8d, 0x74, 0x89, 0x6e, 0x2b, 0x1a, 0x1f, 0xa5,
-	0xe5, 0x31, 0xae, 0xf2, 0xed, 0x41, 0x2b, 0x18, 0x13, 0x8c, 0xaa, 0xf6, 0xbe, 0x17, 0xc4, 0x59,
-	0x71, 0x82, 0x5e, 0xb6, 0x89, 0xbb, 0x62, 0xd6, 0xe3, 0x99, 0x36, 0x31, 0xf9, 0xb9, 0xd6, 0xdf,
-	0x44, 0x41, 0xc7, 0x2e, 0x2c, 0x7a, 0x0a, 0x73, 0x6e, 0xc7, 0x28, 0x36, 0x0c, 0x7b, 0x45, 0xd5,
-	0x08, 0xed, 0x53, 0x9b, 0x74, 0xcb, 0x13, 0xdc, 0xc1, 0xbc, 0xb6, 0x19, 0x9c, 0xc8, 0x85, 0x53,
-	0xa4, 0x51, 0x17, 0x2a, 0x6e, 0x70, 0x62, 0x27, 0xd7, 0x8b, 0x8e, 0x8f, 0x68, 0x4b, 0xd1, 0x9c,
-	0x4f, 0x28, 0x93, 0x5c, 0xc1, 0x6b, 0xc7, 0x47, 0x95, 0xca, 0xf2, 0xc9, 0xac, 0x78, 0x10, 0x16,
-	0x7a, 0x0f, 0xca, 0x4a, 0x9a, 0x9e, 0x29, 0xae, 0xe7, 0xa7, 0x2c, 0xe2, 0xa5, 0x2a, 0x48, 0x95,
-	0x46, 0x36, 0x4c, 0x29, 0xe1, 0xde, 0x5d, 0x5a, 0x9e, 0xce, 0xf4, 0x1a, 0x1b, 0x69, 0xf9, 0xf5,
-	0x1f, 0x4e, 0x22, 0x04, 0x8a, 0x63, 0x1a, 0xd0, 0xef, 0x03, 0x52, 0xa2, 0xed, 0xc6, 0xb4, 0x8c,
-	0x32, 0x25, 0xba, 0x58, 0x9f, 0xb2, 0xef, 0x76, 0x31, 0x12, 0xc5, 0x09, 0x7a, 0x58, 0x81, 0xae,
-	0x44, 0x5a, 0xa4, 0x69, 0x79, 0x9e, 0x2b, 0xaf, 0x65, 0x53, 0xee, 0xc9, 0x05, 0xbe, 0x14, 0x45,
-	0x11, 0x71, 0x5c, 0x09, 0x5a, 0x83, 0x59, 0x31, 0xb8, 0xad, 0x53, 0x65, 0x97, 0x34, 0xfb, 0xb4,
-	0x65, 0x6b, 0xb4, 0x3c, 0xc3, 0xe3, 0x3b, 0xff, 0x5a, 0xb9, 0x98, 0x40, 0xc7, 0x89, 0x52, 0xe8,
-	0x6d, 0x98, 0xda, 0x35, 0xac, 0x1d, 0xb5, 0xdd, 0x26, 0xba, 0x8b, 0x34, 0xcb, 0x91, 0xf8, 0x3b,
-	0xd0, 0x4a, 0x84, 0x86, 0x63, 0xdc, 0x88, 0xc2, 0x45, 0x81, 0xdc, 0xb0, 0x8c, 0xd6, 0xba, 0xd1,
-	0xd3, 0x6d, 0xa7, 0xec, 0xbb, 0xe8, 0xa5, 0xd1, 0x8b, 0x8b, 0x49, 0x0c, 0x2f, 0x8e, 0x2a, 0x57,
-	0x93, 0xab, 0x7c, 0x9f, 0x09, 0x27, 0x63, 0x23, 0x13, 0xc6, 0x44, 0xe3, 0x3b, 0x7f, 0x90, 0x2a,
-	0x97, 0xf9, 0xd1, 0x7f, 0x30, 0x38, 0xe0, 0x79, 0x22, 0xd1, 0xf3, 0x3f, 0x75, 0x7c, 0x54, 0x19,
-	0x0b, 0x32, 0xe0, 0x90, 0x06, 0xde, 0xe8, 0x24, 0x3e, 0xaf, 0x9d, 0x4f, 0xb3, 0xf8, 0xe9, 0x1a,
-	0x9d, 0x7c, 0xd3, 0x5e, 0x5a, 0xa3, 0x53, 0x00, 0xf2, 0xe4, 0x27, 0xf3, 0xff, 0xce, 0xc1, 0x8c,
-	0xcf, 0x9c, 0xb9, 0xd1, 0x29, 0x41, 0xe4, 0xd7, 0x0d, 0xe3, 0xd9, 0x9a, 0x8f, 0xfc, 0xa5, 0xfb,
-	0xff, 0xd7, 0x7c, 0xe4, 0xdb, 0x96, 0x72, 0x7b, 0xf8, 0xbb, 0x5c, 0x70, 0x02, 0xa7, 0xec, 0x80,
-	0x79, 0x09, 0x3d, 0xd3, 0x3f, 0xba, 0x26, 0x1a, 0xf9, 0xeb, 0x3c, 0x4c, 0x45, 0x4f, 0x63, 0xa8,
-	0x51, 0x42, 0x1a, 0xd8, 0x28, 0xd1, 0x80, 0xd9, 0xdd, 0x9e, 0xa6, 0xf5, 0xf9, 0x1c, 0x02, 0xdd,
-	0x12, 0xce, 0x27, 0xcb, 0x9f, 0x0a, 0xc9, 0xd9, 0x95, 0x04, 0x1e, 0x9c, 0x28, 0x19, 0xef, 0x9b,
-	0x28, 0xfc, 0xd0, 0xbe, 0x89, 0xa1, 0x33, 0xf4, 0x4d, 0x24, 0xb7, 0x9e, 0xe4, 0xcf, 0xd4, 0x7a,
-	0x72, 0x96, 0xa6, 0x89, 0x84, 0x20, 0x36, 0xb0, 0x01, 0xf8, 0x17, 0x30, 0x11, 0x6e, 0xe4, 0x71,
-	0xf6, 0xd2, 0xe9, 0x25, 0x12, 0x9f, 0x86, 0x03, 0x7b, 0xe9, 0x8c, 0x63, 0x8f, 0x43, 0xfe, 0x23,
-	0x09, 0xe6, 0x92, 0x1b, 0x76, 0x91, 0x06, 0x13, 0x5d, 0xe5, 0x30, 0xd8, 0x44, 0x2d, 0x9d, 0xf1,
-	0x65, 0x8c, 0x77, 0x70, 0xac, 0x87, 0xb0, 0x70, 0x04, 0x5b, 0xfe, 0x5e, 0x82, 0xf9, 0x94, 0xde,
-	0x89, 0xf3, 0xb5, 0x04, 0xbd, 0x0f, 0xa5, 0xae, 0x72, 0xd8, 0xec, 0x59, 0x1d, 0x72, 0xe6, 0xb7,
-	0x40, 0x7e, 0xa0, 0xd7, 0x05, 0x0a, 0xf6, 0xf0, 0xe4, 0xbf, 0x92, 0xe0, 0x27, 0xa9, 0x57, 0x25,
-	0x74, 0x2f, 0xd4, 0xe6, 0x21, 0x47, 0xda, 0x3c, 0x50, 0x5c, 0xf0, 0x15, 0x75, 0x79, 0x7c, 0x2e,
-	0x41, 0x39, 0xed, 0xee, 0x88, 0xee, 0x86, 0x8c, 0xfc, 0x59, 0xc4, 0xc8, 0xe9, 0x98, 0xdc, 0x2b,
-	0xb2, 0xf1, 0xdf, 0x25, 0xb8, 0x7c, 0x42, 0x0d, 0xe6, 0x5d, 0x51, 0x48, 0x3b, 0xc8, 0xc5, 0x9f,
-	0xad, 0xc5, 0x37, 0x2f, 0xff, 0x8a, 0x92, 0xc0, 0x83, 0x53, 0xa5, 0xd1, 0x36, 0xcc, 0x8b, 0xfb,
-	0x51, 0x94, 0x26, 0xca, 0x0b, 0xde, 0x0d, 0xb7, 0x9c, 0xcc, 0x82, 0xd3, 0x64, 0xe5, 0xbf, 0x95,
-	0x60, 0x2e, 0xf9, 0x51, 0x00, 0xbd, 0x15, 0x5a, 0xf2, 0x4a, 0x64, 0xc9, 0x27, 0x23, 0x52, 0x62,
-	0xc1, 0x3f, 0x84, 0x09, 0xf1, 0x74, 0x20, 0x60, 0x84, 0x33, 0xcb, 0x49, 0x19, 0x44, 0x40, 0xb8,
-	0x05, 0x2c, 0x3f, 0x26, 0xe1, 0x31, 0x1c, 0x41, 0x93, 0x3f, 0xcd, 0xc1, 0x50, 0xb3, 0xa5, 0x68,
-	0xe4, 0x1c, 0xea, 0xd7, 0x5f, 0x85, 0xea, 0xd7, 0x41, 0xff, 0xcf, 0x8c, 0x5b, 0x95, 0x5a, 0xba,
-	0xe2, 0x48, 0xe9, 0xfa, 0x46, 0x26, 0xb4, 0x93, 0xab, 0xd6, 0xdf, 0x82, 0x11, 0x4f, 0xe9, 0xe9,
-	0x92, 0xa9, 0xfc, 0x97, 0x39, 0x18, 0x0d, 0xa8, 0x38, 0x65, 0x2a, 0xde, 0x0d, 0xd5, 0x1f, 0xf9,
-	0x0c, 0x0f, 0x35, 0x01, 0x5d, 0x55, 0xb7, 0xe2, 0x70, 0xfa, 0xa4, 0xfd, 0xce, 0xd8, 0x78, 0x21,
-	0xf2, 0x0b, 0x98, 0xb0, 0x15, 0xab, 0x43, 0x6c, 0xef, 0xc3, 0x85, 0xd3, 0xc7, 0xe5, 0x35, 0xec,
-	0x6f, 0x85, 0xa8, 0x38, 0xc2, 0x7d, 0xe9, 0x21, 0x8c, 0x87, 0x94, 0x9d, 0xaa, 0xcd, 0xf9, 0xef,
-	0x25, 0xf8, 0xd9, 0xc0, 0xc7, 0x1e, 0x54, 0x0f, 0x1d, 0x92, 0x6a, 0xe4, 0x90, 0x2c, 0xa4, 0x03,
-	0xbc, 0xba, 0x76, 0xb9, 0xfa, 0xcd, 0xe7, 0xdf, 0x2d, 0x5c, 0xf8, 0xe6, 0xbb, 0x85, 0x0b, 0xdf,
-	0x7e, 0xb7, 0x70, 0xe1, 0x0f, 0x8e, 0x17, 0xa4, 0xe7, 0xc7, 0x0b, 0xd2, 0x37, 0xc7, 0x0b, 0xd2,
-	0xb7, 0xc7, 0x0b, 0xd2, 0x7f, 0x1e, 0x2f, 0x48, 0x7f, 0xfa, 0xfd, 0xc2, 0x85, 0xf7, 0x8b, 0x02,
-	0xee, 0xff, 0x02, 0x00, 0x00, 0xff, 0xff, 0x98, 0xf4, 0xad, 0x8a, 0xba, 0x3e, 0x00, 0x00,
+	0xd3, 0xb3, 0x34, 0x17, 0xc8, 0x21, 0x87, 0x5c, 0x0c, 0x04, 0x48, 0x2e, 0x4e, 0x72, 0x8c, 0x11,
+	0x20, 0xa7, 0x04, 0x39, 0x26, 0x07, 0xc3, 0x48, 0x10, 0x07, 0x10, 0x02, 0x27, 0xf0, 0x2d, 0x3e,
+	0x11, 0x31, 0x7d, 0x0a, 0x72, 0xca, 0x2d, 0xd0, 0x29, 0xe8, 0x9e, 0x9e, 0xff, 0x19, 0xee, 0x90,
+	0x96, 0x88, 0x38, 0x78, 0x27, 0x71, 0xbb, 0xaa, 0xbe, 0xaa, 0xee, 0xae, 0xae, 0xaa, 0xee, 0x29,
+	0xc1, 0xca, 0xfe, 0x7d, 0x5a, 0x55, 0x8d, 0xda, 0x7e, 0x6f, 0x87, 0x58, 0x3a, 0xb1, 0x09, 0xad,
+	0x1d, 0x10, 0xbd, 0x6d, 0x58, 0x35, 0x41, 0x50, 0x4c, 0xb5, 0x46, 0x0e, 0x6d, 0xa2, 0x53, 0xd5,
+	0xd0, 0x69, 0xed, 0xe0, 0xd6, 0x0e, 0xb1, 0x95, 0x5b, 0xb5, 0x0e, 0xd1, 0x89, 0xa5, 0xd8, 0xa4,
+	0x5d, 0x35, 0x2d, 0xc3, 0x36, 0xd0, 0x15, 0x87, 0xbd, 0xaa, 0x98, 0x6a, 0xd5, 0x67, 0xaf, 0x0a,
+	0xf6, 0x4b, 0x37, 0x3b, 0xaa, 0xbd, 0xd7, 0xdb, 0xa9, 0xb6, 0x8c, 0x6e, 0xad, 0x63, 0x74, 0x8c,
+	0x1a, 0x97, 0xda, 0xe9, 0xed, 0xf2, 0x5f, 0xfc, 0x07, 0xff, 0xcb, 0x41, 0xbb, 0x24, 0x07, 0x94,
+	0xb7, 0x0c, 0x8b, 0xd4, 0x0e, 0x62, 0x1a, 0x2f, 0xdd, 0xf1, 0x79, 0xba, 0x4a, 0x6b, 0x4f, 0xd5,
+	0x89, 0xd5, 0xaf, 0x99, 0xfb, 0x1d, 0x36, 0x40, 0x6b, 0x5d, 0x62, 0x2b, 0x49, 0x52, 0xb5, 0x34,
+	0x29, 0xab, 0xa7, 0xdb, 0x6a, 0x97, 0xc4, 0x04, 0xee, 0x0d, 0x12, 0xa0, 0xad, 0x3d, 0xd2, 0x55,
+	0x62, 0x72, 0x6f, 0xa5, 0xc9, 0xf5, 0x6c, 0x55, 0xab, 0xa9, 0xba, 0x4d, 0x6d, 0x2b, 0x2a, 0x24,
+	0xdf, 0x81, 0xa9, 0x45, 0x4d, 0x33, 0x3e, 0x21, 0xed, 0xa5, 0xe6, 0xea, 0xb2, 0xa5, 0x1e, 0x10,
+	0x0b, 0x5d, 0x85, 0x82, 0xae, 0x74, 0x49, 0x59, 0xba, 0x2a, 0x5d, 0x1f, 0xa9, 0x8f, 0x3d, 0x3f,
+	0xaa, 0x5c, 0x38, 0x3e, 0xaa, 0x14, 0x36, 0x94, 0x2e, 0xc1, 0x9c, 0x22, 0x3f, 0x84, 0x69, 0x21,
+	0xb5, 0xa2, 0x91, 0xc3, 0xa7, 0x86, 0xd6, 0xeb, 0x12, 0x74, 0x0d, 0x86, 0xdb, 0x1c, 0x40, 0x08,
+	0x4e, 0x08, 0xc1, 0x61, 0x07, 0x16, 0x0b, 0xaa, 0x4c, 0x61, 0x52, 0x08, 0x3f, 0x31, 0xa8, 0xdd,
+	0x50, 0xec, 0x3d, 0x74, 0x1b, 0xc0, 0x54, 0xec, 0xbd, 0x86, 0x45, 0x76, 0xd5, 0x43, 0x21, 0x8e,
+	0x84, 0x38, 0x34, 0x3c, 0x0a, 0x0e, 0x70, 0xa1, 0x1b, 0x50, 0xb2, 0x88, 0xd2, 0xde, 0xd4, 0xb5,
+	0x7e, 0x39, 0x77, 0x55, 0xba, 0x5e, 0xaa, 0x4f, 0x09, 0x89, 0x12, 0x16, 0xe3, 0xd8, 0xe3, 0x90,
+	0x3f, 0xcb, 0xc1, 0xc8, 0xb2, 0x42, 0xba, 0x86, 0xde, 0x24, 0x36, 0xfa, 0x08, 0x4a, 0x6c, 0xbb,
+	0xda, 0x8a, 0xad, 0x70, 0x6d, 0xa3, 0xb7, 0xdf, 0xac, 0xfa, 0xee, 0xe4, 0xad, 0x5e, 0xd5, 0xdc,
+	0xef, 0xb0, 0x01, 0x5a, 0x65, 0xdc, 0xd5, 0x83, 0x5b, 0xd5, 0xcd, 0x9d, 0x67, 0xa4, 0x65, 0xaf,
+	0x13, 0x5b, 0xf1, 0xed, 0xf3, 0xc7, 0xb0, 0x87, 0x8a, 0x36, 0xa0, 0x40, 0x4d, 0xd2, 0xe2, 0x96,
+	0x8d, 0xde, 0xbe, 0x51, 0x3d, 0xd1, 0x59, 0xab, 0x9e, 0x65, 0x4d, 0x93, 0xb4, 0xfc, 0x15, 0x67,
+	0xbf, 0x30, 0xc7, 0x41, 0x4f, 0x61, 0x98, 0xda, 0x8a, 0xdd, 0xa3, 0xe5, 0x3c, 0x47, 0xac, 0x66,
+	0x46, 0xe4, 0x52, 0xfe, 0x66, 0x38, 0xbf, 0xb1, 0x40, 0x93, 0xff, 0x33, 0x07, 0xc8, 0xe3, 0x5d,
+	0x32, 0xf4, 0xb6, 0x6a, 0xab, 0x86, 0x8e, 0x1e, 0x40, 0xc1, 0xee, 0x9b, 0xae, 0x0b, 0x5c, 0x73,
+	0x0d, 0xda, 0xea, 0x9b, 0xe4, 0xc5, 0x51, 0x65, 0x2e, 0x2e, 0xc1, 0x28, 0x98, 0xcb, 0xa0, 0x35,
+	0xcf, 0xd4, 0x1c, 0x97, 0xbe, 0x13, 0x56, 0xfd, 0xe2, 0xa8, 0x92, 0x70, 0xd8, 0xaa, 0x1e, 0x52,
+	0xd8, 0x40, 0x74, 0x00, 0x48, 0x53, 0xa8, 0xbd, 0x65, 0x29, 0x3a, 0x75, 0x34, 0xa9, 0x5d, 0x22,
+	0x16, 0xe1, 0x8d, 0x6c, 0x9b, 0xc6, 0x24, 0xea, 0x97, 0x84, 0x15, 0x68, 0x2d, 0x86, 0x86, 0x13,
+	0x34, 0x30, 0x6f, 0xb6, 0x88, 0x42, 0x0d, 0xbd, 0x5c, 0x08, 0x7b, 0x33, 0xe6, 0xa3, 0x58, 0x50,
+	0xd1, 0xeb, 0x50, 0xec, 0x12, 0x4a, 0x95, 0x0e, 0x29, 0x0f, 0x71, 0xc6, 0x49, 0xc1, 0x58, 0x5c,
+	0x77, 0x86, 0xb1, 0x4b, 0x97, 0xbf, 0x90, 0x60, 0xdc, 0x5b, 0xb9, 0x35, 0x95, 0xda, 0xe8, 0x77,
+	0x63, 0x7e, 0x58, 0xcd, 0x36, 0x25, 0x26, 0xcd, 0xbd, 0xd0, 0xf3, 0x79, 0x77, 0x24, 0xe0, 0x83,
+	0xeb, 0x30, 0xa4, 0xda, 0xa4, 0xcb, 0xf6, 0x21, 0x7f, 0x7d, 0xf4, 0xf6, 0xf5, 0xac, 0x2e, 0x53,
+	0x1f, 0x17, 0xa0, 0x43, 0xab, 0x4c, 0x1c, 0x3b, 0x28, 0xf2, 0x9f, 0x16, 0x02, 0xe6, 0x33, 0xd7,
+	0x44, 0x1f, 0x40, 0x89, 0x12, 0x8d, 0xb4, 0x6c, 0xc3, 0x12, 0xe6, 0xbf, 0x95, 0xd1, 0x7c, 0x65,
+	0x87, 0x68, 0x4d, 0x21, 0x5a, 0x1f, 0x63, 0xf6, 0xbb, 0xbf, 0xb0, 0x07, 0x89, 0xde, 0x81, 0x92,
+	0x4d, 0xba, 0xa6, 0xa6, 0xd8, 0x44, 0x9c, 0xa3, 0xd7, 0x82, 0x53, 0x60, 0x9e, 0xc3, 0xc0, 0x1a,
+	0x46, 0x7b, 0x4b, 0xb0, 0xf1, 0xe3, 0xe3, 0x2d, 0x89, 0x3b, 0x8a, 0x3d, 0x18, 0x74, 0x00, 0x13,
+	0x3d, 0xb3, 0xcd, 0x38, 0x6d, 0x16, 0x05, 0x3b, 0x7d, 0xe1, 0x49, 0xf7, 0xb2, 0xae, 0xcd, 0x76,
+	0x48, 0xba, 0x3e, 0x27, 0x74, 0x4d, 0x84, 0xc7, 0x71, 0x44, 0x0b, 0x5a, 0x84, 0xc9, 0xae, 0xaa,
+	0xb3, 0xb8, 0xd4, 0x6f, 0x92, 0x96, 0xa1, 0xb7, 0x29, 0x77, 0xab, 0xa1, 0xfa, 0xbc, 0x00, 0x98,
+	0x5c, 0x0f, 0x93, 0x71, 0x94, 0x1f, 0xfd, 0x0a, 0x90, 0x3b, 0x8d, 0xc7, 0x4e, 0x10, 0x57, 0x0d,
+	0x9d, 0xfb, 0x5c, 0xde, 0x77, 0xee, 0xad, 0x18, 0x07, 0x4e, 0x90, 0x42, 0x6b, 0x30, 0x6b, 0x91,
+	0x03, 0x95, 0xcd, 0xf1, 0x89, 0x4a, 0x6d, 0xc3, 0xea, 0xaf, 0xa9, 0x5d, 0xd5, 0x2e, 0x0f, 0x73,
+	0x9b, 0xca, 0xc7, 0x47, 0x95, 0x59, 0x9c, 0x40, 0xc7, 0x89, 0x52, 0xf2, 0x9f, 0x0d, 0xc3, 0x64,
+	0x24, 0xde, 0xa0, 0xa7, 0x30, 0xd7, 0xea, 0x59, 0x16, 0xd1, 0xed, 0x8d, 0x5e, 0x77, 0x87, 0x58,
+	0xcd, 0xd6, 0x1e, 0x69, 0xf7, 0x34, 0xd2, 0xe6, 0x8e, 0x32, 0x54, 0x5f, 0x10, 0x16, 0xcf, 0x2d,
+	0x25, 0x72, 0xe1, 0x14, 0x69, 0xb6, 0x0a, 0x3a, 0x1f, 0x5a, 0x57, 0x29, 0xf5, 0x30, 0x73, 0x1c,
+	0xd3, 0x5b, 0x85, 0x8d, 0x18, 0x07, 0x4e, 0x90, 0x62, 0x36, 0xb6, 0x09, 0x55, 0x2d, 0xd2, 0x8e,
+	0xda, 0x98, 0x0f, 0xdb, 0xb8, 0x9c, 0xc8, 0x85, 0x53, 0xa4, 0xd1, 0x5d, 0x18, 0x75, 0xb4, 0xf1,
+	0xfd, 0x13, 0x1b, 0x3d, 0x23, 0xc0, 0x46, 0x37, 0x7c, 0x12, 0x0e, 0xf2, 0xb1, 0xa9, 0x19, 0x3b,
+	0x94, 0x58, 0x07, 0xa4, 0x9d, 0xbe, 0xc1, 0x9b, 0x31, 0x0e, 0x9c, 0x20, 0xc5, 0xa6, 0xe6, 0x78,
+	0x60, 0x6c, 0x6a, 0xc3, 0xe1, 0xa9, 0x6d, 0x27, 0x72, 0xe1, 0x14, 0x69, 0xe6, 0xc7, 0x8e, 0xc9,
+	0x8b, 0x07, 0x8a, 0xaa, 0x29, 0x3b, 0x1a, 0x29, 0x17, 0xc3, 0x7e, 0xbc, 0x11, 0x26, 0xe3, 0x28,
+	0x3f, 0x7a, 0x0c, 0xd3, 0xce, 0xd0, 0xb6, 0xae, 0x78, 0x20, 0x25, 0x0e, 0xf2, 0x13, 0x01, 0x32,
+	0xbd, 0x11, 0x65, 0xc0, 0x71, 0x19, 0xf4, 0x00, 0x26, 0x5a, 0x86, 0xa6, 0x71, 0x7f, 0x5c, 0x32,
+	0x7a, 0xba, 0x5d, 0x1e, 0xe1, 0x28, 0x88, 0x9d, 0xc7, 0xa5, 0x10, 0x05, 0x47, 0x38, 0x11, 0x01,
+	0x68, 0xb9, 0x09, 0x87, 0x96, 0x81, 0xc7, 0xc7, 0x5b, 0x59, 0x63, 0x80, 0x97, 0xaa, 0xfc, 0x1a,
+	0xc0, 0x1b, 0xa2, 0x38, 0x00, 0x2c, 0xff, 0x8b, 0x04, 0xf3, 0x29, 0xa1, 0x03, 0xfd, 0x32, 0x94,
+	0x62, 0x7f, 0x33, 0x92, 0x62, 0x2f, 0xa7, 0x88, 0x05, 0xf2, 0xac, 0x0e, 0xe3, 0x16, 0x9b, 0x95,
+	0xde, 0x71, 0x58, 0x44, 0x8c, 0xbc, 0x3b, 0x60, 0x1a, 0x38, 0x28, 0xe3, 0xc7, 0xfc, 0xe9, 0xe3,
+	0xa3, 0xca, 0x78, 0x88, 0x86, 0xc3, 0xf0, 0xf2, 0x9f, 0xe7, 0x00, 0x96, 0x89, 0xa9, 0x19, 0xfd,
+	0x2e, 0xd1, 0xcf, 0xa3, 0x86, 0xda, 0x0c, 0xd5, 0x50, 0x37, 0x07, 0x6d, 0x8f, 0x67, 0x5a, 0x6a,
+	0x11, 0xf5, 0x6e, 0xa4, 0x88, 0xaa, 0x65, 0x87, 0x3c, 0xb9, 0x8a, 0xfa, 0xf7, 0x3c, 0xcc, 0xf8,
+	0xcc, 0x7e, 0x19, 0xf5, 0x30, 0xb4, 0xc7, 0xbf, 0x11, 0xd9, 0xe3, 0xf9, 0x04, 0x91, 0x57, 0x56,
+	0x47, 0x3d, 0x83, 0x09, 0x56, 0xe5, 0x38, 0x7b, 0xc9, 0x6b, 0xa8, 0xe1, 0x53, 0xd7, 0x50, 0x5e,
+	0xb6, 0x5b, 0x0b, 0x21, 0xe1, 0x08, 0x72, 0x4a, 0xcd, 0x56, 0xfc, 0x31, 0xd6, 0x6c, 0x5f, 0x4a,
+	0x30, 0xe1, 0x6f, 0xd3, 0x39, 0x14, 0x6d, 0x1b, 0xe1, 0xa2, 0xed, 0xf5, 0xcc, 0x2e, 0x9a, 0x52,
+	0xb5, 0xfd, 0x0f, 0x2b, 0xf0, 0x3d, 0x26, 0x76, 0xc0, 0x77, 0x94, 0xd6, 0xfe, 0xe0, 0x3b, 0x1e,
+	0xfa, 0x4c, 0x02, 0x24, 0xb2, 0xc0, 0xa2, 0xae, 0x1b, 0xb6, 0xe2, 0xc4, 0x4a, 0xc7, 0xac, 0xd5,
+	0xcc, 0x66, 0xb9, 0x1a, 0xab, 0xdb, 0x31, 0xac, 0x47, 0xba, 0x6d, 0xf5, 0xfd, 0x4d, 0x8e, 0x33,
+	0xe0, 0x04, 0x03, 0x90, 0x02, 0x60, 0x09, 0xcc, 0x2d, 0x43, 0x1c, 0xe4, 0x9b, 0x19, 0x62, 0x1e,
+	0x13, 0x58, 0x32, 0xf4, 0x5d, 0xb5, 0xe3, 0x87, 0x1d, 0xec, 0x01, 0xe1, 0x00, 0xe8, 0xa5, 0x47,
+	0x30, 0x9f, 0x62, 0x2d, 0x9a, 0x82, 0xfc, 0x3e, 0xe9, 0x3b, 0xcb, 0x86, 0xd9, 0x9f, 0x68, 0x16,
+	0x86, 0x0e, 0x14, 0xad, 0xe7, 0x84, 0xdf, 0x11, 0xec, 0xfc, 0x78, 0x90, 0xbb, 0x2f, 0xc9, 0x5f,
+	0x0c, 0x05, 0x7d, 0x87, 0x57, 0xcc, 0xd7, 0xd9, 0xa5, 0xd5, 0xd4, 0xd4, 0x96, 0x42, 0x45, 0x21,
+	0x34, 0xe6, 0x5c, 0x58, 0x9d, 0x31, 0xec, 0x51, 0x43, 0xb5, 0x75, 0xee, 0xd5, 0xd6, 0xd6, 0xf9,
+	0x97, 0x53, 0x5b, 0xff, 0x1e, 0x94, 0xa8, 0x5b, 0x55, 0x17, 0x38, 0xe4, 0xad, 0x53, 0xc4, 0x57,
+	0x51, 0x50, 0x7b, 0x0a, 0xbc, 0x52, 0xda, 0x03, 0x4d, 0x2a, 0xa2, 0x87, 0x4e, 0x59, 0x44, 0xbf,
+	0xd4, 0xc2, 0x97, 0xc5, 0x1b, 0x53, 0xe9, 0x51, 0xd2, 0xe6, 0xb1, 0xad, 0xe4, 0xc7, 0x9b, 0x06,
+	0x1f, 0xc5, 0x82, 0x8a, 0x3e, 0x08, 0xb9, 0x6c, 0xe9, 0x2c, 0x2e, 0x3b, 0x91, 0xee, 0xae, 0x68,
+	0x1b, 0xe6, 0x4d, 0xcb, 0xe8, 0x58, 0x84, 0xd2, 0x65, 0xa2, 0xb4, 0x35, 0x55, 0x27, 0xee, 0xfa,
+	0x38, 0x15, 0xd1, 0xe5, 0xe3, 0xa3, 0xca, 0x7c, 0x23, 0x99, 0x05, 0xa7, 0xc9, 0xca, 0xcf, 0x0b,
+	0x30, 0x15, 0xcd, 0x80, 0x29, 0x45, 0xaa, 0x74, 0xa6, 0x22, 0xf5, 0x46, 0xe0, 0x30, 0x38, 0x15,
+	0x7c, 0xe0, 0x05, 0x27, 0x76, 0x20, 0x16, 0x61, 0x52, 0x44, 0x03, 0x97, 0x28, 0xca, 0x74, 0x6f,
+	0xf7, 0xb7, 0xc3, 0x64, 0x1c, 0xe5, 0x47, 0x0f, 0x61, 0xdc, 0xe2, 0x75, 0xb7, 0x0b, 0xe0, 0xd4,
+	0xae, 0x17, 0x05, 0xc0, 0x38, 0x0e, 0x12, 0x71, 0x98, 0x97, 0xd5, 0xad, 0x7e, 0x39, 0xea, 0x02,
+	0x14, 0xc2, 0x75, 0xeb, 0x62, 0x94, 0x01, 0xc7, 0x65, 0xd0, 0x3a, 0xcc, 0xf4, 0xf4, 0x38, 0x94,
+	0xe3, 0xca, 0x97, 0x05, 0xd4, 0xcc, 0x76, 0x9c, 0x05, 0x27, 0xc9, 0xa1, 0xdd, 0x50, 0x29, 0x3b,
+	0xcc, 0xc3, 0xf3, 0xed, 0xcc, 0x07, 0x2f, 0x73, 0x2d, 0x9b, 0x50, 0x6e, 0x97, 0xb2, 0x96, 0xdb,
+	0xf2, 0x3f, 0x4a, 0xc1, 0x24, 0xe4, 0x95, 0xc0, 0x83, 0x5e, 0x99, 0x62, 0x12, 0x81, 0xea, 0xc8,
+	0x48, 0xae, 0x7e, 0xef, 0x9d, 0xaa, 0xfa, 0xf5, 0x93, 0xe7, 0xe0, 0xf2, 0xf7, 0x73, 0x09, 0xe6,
+	0x56, 0x9a, 0x8f, 0x2d, 0xa3, 0x67, 0xba, 0xe6, 0x6c, 0x9a, 0xce, 0xd2, 0xfc, 0x1c, 0x0a, 0x56,
+	0x4f, 0x73, 0xe7, 0xf1, 0x9a, 0x3b, 0x0f, 0xdc, 0xd3, 0xd8, 0x3c, 0x66, 0x22, 0x52, 0xce, 0x24,
+	0x98, 0x00, 0xda, 0x80, 0x61, 0x4b, 0xd1, 0x3b, 0xc4, 0x4d, 0xab, 0xd7, 0x06, 0x58, 0xbf, 0xba,
+	0x8c, 0x19, 0x7b, 0xa0, 0xb0, 0xe1, 0xd2, 0x58, 0xa0, 0xc8, 0xff, 0x24, 0xc1, 0xe4, 0x93, 0xad,
+	0xad, 0xc6, 0xaa, 0xce, 0x4f, 0x34, 0x7f, 0x5b, 0xbd, 0x0a, 0x05, 0x53, 0xb1, 0xf7, 0xa2, 0x99,
+	0x9e, 0xd1, 0x30, 0xa7, 0xa0, 0x3b, 0x50, 0x62, 0xff, 0x32, 0xbb, 0xf8, 0x91, 0x1a, 0xe1, 0x81,
+	0xb0, 0xd4, 0x10, 0x63, 0x2f, 0x02, 0x7f, 0x63, 0x8f, 0x13, 0xbd, 0x07, 0x45, 0x16, 0x7f, 0x88,
+	0xde, 0xce, 0x58, 0xa0, 0x0b, 0xa3, 0xea, 0x8e, 0x90, 0x5f, 0x73, 0x89, 0x01, 0xec, 0xc2, 0xc9,
+	0xfb, 0x30, 0x1b, 0x98, 0x04, 0x5b, 0xc5, 0xa7, 0x2c, 0xa7, 0xa2, 0x26, 0x0c, 0x31, 0xed, 0x2c,
+	0x73, 0xe6, 0x33, 0x3c, 0x81, 0x46, 0x16, 0xc2, 0xaf, 0x8f, 0xd8, 0x2f, 0x8a, 0x1d, 0x2c, 0x79,
+	0x1d, 0xc6, 0xf9, 0x33, 0xb4, 0x61, 0xd9, 0x7c, 0x31, 0xd1, 0x15, 0xc8, 0x77, 0x55, 0x5d, 0x64,
+	0xe7, 0x51, 0x21, 0x93, 0x67, 0x99, 0x85, 0x8d, 0x73, 0xb2, 0x72, 0x28, 0xe2, 0x95, 0x4f, 0x56,
+	0x0e, 0x31, 0x1b, 0x97, 0x1f, 0x43, 0x51, 0x6c, 0x52, 0x10, 0x28, 0x7f, 0x32, 0x50, 0x3e, 0x01,
+	0x68, 0x13, 0x8a, 0xab, 0x8d, 0xba, 0x66, 0x38, 0xb5, 0x5a, 0x4b, 0x6d, 0x5b, 0xd1, 0x1d, 0x5c,
+	0x5a, 0x5d, 0xc6, 0x98, 0x53, 0x90, 0x0c, 0xc3, 0xe4, 0xb0, 0x45, 0x4c, 0x9b, 0xfb, 0xd1, 0x48,
+	0x1d, 0x98, 0x6f, 0x3c, 0xe2, 0x23, 0x58, 0x50, 0xe4, 0x3f, 0xce, 0x41, 0x51, 0x2c, 0xc7, 0x39,
+	0xdc, 0xdd, 0xd6, 0x42, 0x77, 0xb7, 0x37, 0xb2, 0xb9, 0x46, 0xea, 0xc5, 0x6d, 0x2b, 0x72, 0x71,
+	0xbb, 0x91, 0x11, 0xef, 0xe4, 0x5b, 0xdb, 0xa7, 0x39, 0x98, 0x08, 0x3b, 0x25, 0xba, 0x0b, 0xa3,
+	0x2c, 0x4d, 0xa9, 0x2d, 0xb2, 0xe1, 0x57, 0xc7, 0xde, 0xd3, 0x4d, 0xd3, 0x27, 0xe1, 0x20, 0x1f,
+	0xea, 0x78, 0x62, 0xcc, 0x8f, 0xc4, 0xa4, 0xd3, 0x97, 0xb4, 0x67, 0xab, 0x5a, 0xd5, 0xf9, 0x20,
+	0x53, 0x5d, 0xd5, 0xed, 0x4d, 0xab, 0x69, 0x5b, 0xaa, 0xde, 0x89, 0x29, 0xe2, 0x4e, 0x19, 0x44,
+	0x46, 0xef, 0xb2, 0x94, 0x49, 0x8d, 0x9e, 0xd5, 0x22, 0x49, 0xa5, 0xaf, 0x5b, 0xb6, 0xb1, 0x03,
+	0xda, 0x5e, 0x33, 0x5a, 0x8a, 0xe6, 0x6c, 0x0e, 0x26, 0xbb, 0xc4, 0x22, 0x7a, 0x8b, 0xb8, 0xe5,
+	0xa6, 0x03, 0x81, 0x3d, 0x30, 0xf9, 0xef, 0x25, 0x18, 0x15, 0x6b, 0x71, 0x0e, 0x97, 0x9c, 0xdf,
+	0x09, 0x5f, 0x72, 0xae, 0x65, 0x8c, 0x1c, 0xc9, 0x37, 0x9c, 0xbf, 0xf2, 0x4d, 0x67, 0xb1, 0x82,
+	0x1d, 0x97, 0x3d, 0x83, 0xda, 0xd1, 0xe3, 0xc2, 0x4e, 0x39, 0xe6, 0x14, 0xd4, 0x83, 0x29, 0x35,
+	0x12, 0x5c, 0xc4, 0x9e, 0xd5, 0xb2, 0x59, 0xe2, 0x89, 0xd5, 0xcb, 0x02, 0x7e, 0x2a, 0x4a, 0xc1,
+	0x31, 0x15, 0x32, 0x81, 0x18, 0x17, 0x7a, 0x07, 0x0a, 0x7b, 0xb6, 0x6d, 0x26, 0x3c, 0x9f, 0x0f,
+	0x08, 0x69, 0xbe, 0x09, 0x25, 0x3e, 0xbb, 0xad, 0xad, 0x06, 0xe6, 0x50, 0xf2, 0x3f, 0xe4, 0xbc,
+	0xf5, 0xe0, 0x77, 0x8e, 0xb7, 0xbd, 0xd9, 0x2e, 0x69, 0x0a, 0xa5, 0xdc, 0xb1, 0x9d, 0xfb, 0xf1,
+	0x6c, 0xc0, 0x70, 0x8f, 0x86, 0x63, 0xdc, 0x68, 0xcb, 0x0f, 0xf5, 0xd2, 0x59, 0x42, 0xfd, 0x68,
+	0x52, 0x98, 0x47, 0x4f, 0x20, 0x6f, 0x6b, 0x59, 0xef, 0xb9, 0x02, 0x71, 0x6b, 0xad, 0xe9, 0xc7,
+	0xca, 0xad, 0xb5, 0x26, 0x66, 0x10, 0x68, 0x13, 0x86, 0x58, 0x3a, 0x65, 0xd1, 0x21, 0x9f, 0x3d,
+	0xda, 0xb0, 0x15, 0xf4, 0x5d, 0x8a, 0xfd, 0xa2, 0xd8, 0xc1, 0x91, 0x3f, 0x86, 0xf1, 0x50, 0x08,
+	0x41, 0x1f, 0xc1, 0x98, 0x66, 0x28, 0xed, 0xba, 0xa2, 0x29, 0x7a, 0x8b, 0xb8, 0x5f, 0x3b, 0xae,
+	0x25, 0x9d, 0xbd, 0xb5, 0x00, 0x9f, 0x08, 0x40, 0xb3, 0x42, 0xc9, 0x58, 0x90, 0x86, 0x43, 0x88,
+	0xb2, 0x02, 0xe0, 0xcf, 0x11, 0x55, 0x60, 0x88, 0x79, 0xaa, 0x93, 0xea, 0x46, 0xea, 0x23, 0xcc,
+	0x42, 0xe6, 0xc0, 0x14, 0x3b, 0xe3, 0xe8, 0x36, 0x00, 0x25, 0x2d, 0x8b, 0xd8, 0x7c, 0x3b, 0x73,
+	0xe1, 0x2f, 0xa6, 0x4d, 0x8f, 0x82, 0x03, 0x5c, 0xf2, 0x3f, 0x4b, 0x30, 0xbe, 0x41, 0xec, 0x4f,
+	0x0c, 0x6b, 0xbf, 0x61, 0x68, 0x6a, 0xab, 0x7f, 0x0e, 0x79, 0x00, 0x87, 0xf2, 0xc0, 0x9b, 0x03,
+	0x76, 0x26, 0x64, 0x5d, 0x5a, 0x36, 0x90, 0xbf, 0x94, 0x60, 0x3e, 0xc4, 0xf9, 0xc8, 0x3f, 0xfc,
+	0xdb, 0x30, 0x64, 0x1a, 0x96, 0xed, 0xd6, 0x08, 0xa7, 0x52, 0xc8, 0x22, 0x6c, 0xa0, 0x4a, 0x60,
+	0x30, 0xd8, 0x41, 0x43, 0x6b, 0x90, 0xb3, 0x0d, 0xe1, 0xaa, 0xa7, 0xc3, 0x24, 0xc4, 0xaa, 0x83,
+	0xc0, 0xcc, 0x6d, 0x19, 0x38, 0x67, 0x1b, 0x6c, 0x23, 0xca, 0x21, 0xae, 0x60, 0xf8, 0x7a, 0x45,
+	0x33, 0xc0, 0x50, 0xd8, 0xb5, 0x8c, 0xee, 0x99, 0xe7, 0xe0, 0x6d, 0xc4, 0x8a, 0x65, 0x74, 0x31,
+	0xc7, 0x92, 0xbf, 0x92, 0x60, 0x3a, 0xc4, 0x79, 0x0e, 0xa9, 0xe3, 0x9d, 0x70, 0xea, 0xb8, 0x71,
+	0x9a, 0x89, 0xa4, 0x24, 0x90, 0xaf, 0x72, 0x91, 0x69, 0xb0, 0x09, 0xa3, 0x5d, 0x18, 0x35, 0x8d,
+	0x76, 0xf3, 0x25, 0x7c, 0xdf, 0x9c, 0x64, 0x29, 0xbd, 0xe1, 0x63, 0xe1, 0x20, 0x30, 0x3a, 0x84,
+	0x69, 0x5d, 0xe9, 0x12, 0x6a, 0x2a, 0x2d, 0xd2, 0x7c, 0x09, 0x2f, 0x3e, 0x17, 0xf9, 0x07, 0x94,
+	0x28, 0x22, 0x8e, 0x2b, 0x41, 0xeb, 0x50, 0x54, 0x4d, 0x5e, 0x62, 0x8a, 0x5a, 0x62, 0x60, 0x1e,
+	0x76, 0x0a, 0x52, 0x27, 0x9e, 0x8b, 0x1f, 0xd8, 0xc5, 0x90, 0xff, 0x3a, 0xea, 0x0d, 0xbc, 0x62,
+	0x79, 0x0c, 0x25, 0xde, 0x69, 0xd2, 0x32, 0x34, 0xf7, 0x53, 0x07, 0xbf, 0x5c, 0x88, 0xb1, 0x17,
+	0x47, 0x95, 0xcb, 0x09, 0xaf, 0xd8, 0x2e, 0x19, 0x7b, 0xc2, 0x68, 0x03, 0x0a, 0xe6, 0x0f, 0x29,
+	0xae, 0x78, 0x9a, 0xe4, 0x15, 0x15, 0xc7, 0x91, 0xff, 0x30, 0x1f, 0x31, 0x97, 0x27, 0xcb, 0x67,
+	0x2f, 0x6d, 0xd7, 0xbd, 0x62, 0x2e, 0x75, 0xe7, 0x77, 0xa0, 0x28, 0x52, 0xad, 0x70, 0xe6, 0x9f,
+	0x9f, 0xc6, 0x99, 0x83, 0x59, 0xcc, 0xbb, 0x4b, 0xb9, 0x83, 0x2e, 0x30, 0xfa, 0x10, 0x86, 0x89,
+	0xa3, 0xc2, 0xc9, 0x8d, 0xf7, 0x4e, 0xa3, 0xc2, 0x8f, 0xab, 0x7e, 0x0d, 0x2d, 0xc6, 0x04, 0x2a,
+	0xfa, 0x25, 0x5b, 0x2f, 0xc6, 0xcb, 0x4a, 0x4e, 0x5a, 0x2e, 0xf0, 0x74, 0x75, 0xc5, 0x99, 0xb6,
+	0x37, 0xfc, 0xe2, 0xa8, 0x02, 0xfe, 0x4f, 0x1c, 0x94, 0x90, 0xff, 0x55, 0x82, 0x69, 0xbe, 0x42,
+	0xad, 0x9e, 0xa5, 0xda, 0xfd, 0x73, 0x4b, 0x4c, 0x4f, 0x43, 0x89, 0xe9, 0xce, 0x80, 0x65, 0x89,
+	0x59, 0x98, 0x9a, 0x9c, 0xbe, 0x96, 0xe0, 0x62, 0x8c, 0xfb, 0x1c, 0xe2, 0xe2, 0x76, 0x38, 0x2e,
+	0xbe, 0x79, 0xda, 0x09, 0xa5, 0xc4, 0xc6, 0xff, 0x9e, 0x4e, 0x98, 0x0e, 0x3f, 0x29, 0xb7, 0x01,
+	0x4c, 0x4b, 0x3d, 0x50, 0x35, 0xd2, 0x11, 0x5f, 0xf5, 0x4b, 0x81, 0x9e, 0x2d, 0x8f, 0x82, 0x03,
+	0x5c, 0x88, 0xc2, 0x5c, 0x9b, 0xec, 0x2a, 0x3d, 0xcd, 0x5e, 0x6c, 0xb7, 0x97, 0x14, 0x53, 0xd9,
+	0x51, 0x35, 0xd5, 0x56, 0xc5, 0xfb, 0xc7, 0x48, 0xfd, 0xa1, 0xf3, 0xb5, 0x3d, 0x89, 0xe3, 0xc5,
+	0x51, 0xe5, 0x4a, 0xd2, 0xe7, 0x2e, 0x97, 0xa5, 0x8f, 0x53, 0xa0, 0x51, 0x1f, 0xca, 0x16, 0xf9,
+	0xb8, 0xa7, 0x5a, 0xa4, 0xbd, 0x6c, 0x19, 0x66, 0x48, 0x6d, 0x9e, 0xab, 0xfd, 0xed, 0xe3, 0xa3,
+	0x4a, 0x19, 0xa7, 0xf0, 0x0c, 0x56, 0x9c, 0x0a, 0x8f, 0x9e, 0xc1, 0x8c, 0x22, 0xba, 0xeb, 0x82,
+	0x5a, 0x9d, 0x53, 0x72, 0xff, 0xf8, 0xa8, 0x32, 0xb3, 0x18, 0x27, 0x0f, 0x56, 0x98, 0x04, 0x8a,
+	0x6a, 0x50, 0x3c, 0xe0, 0x8d, 0x78, 0xb4, 0x3c, 0xc4, 0xf1, 0x59, 0x22, 0x28, 0x3a, 0xbd, 0x79,
+	0x0c, 0x73, 0x78, 0xa5, 0xc9, 0x4f, 0x9f, 0xcb, 0xc5, 0xee, 0xba, 0xac, 0x96, 0x14, 0x27, 0x9e,
+	0x3f, 0x81, 0x97, 0xfc, 0xa8, 0xf5, 0xc4, 0x27, 0xe1, 0x20, 0x1f, 0xfa, 0x00, 0x46, 0xf6, 0xc4,
+	0x83, 0x09, 0x2d, 0x17, 0x33, 0x25, 0xe1, 0xd0, 0x03, 0x4b, 0x7d, 0x5a, 0xa8, 0x18, 0x71, 0x87,
+	0x29, 0xf6, 0x11, 0xd1, 0xeb, 0x50, 0xe4, 0x3f, 0x56, 0x97, 0xf9, 0xfb, 0x62, 0xc9, 0x8f, 0x6d,
+	0x4f, 0x9c, 0x61, 0xec, 0xd2, 0x5d, 0xd6, 0xd5, 0xc6, 0x12, 0x7f, 0xe7, 0x8e, 0xb0, 0xae, 0x36,
+	0x96, 0xb0, 0x4b, 0x47, 0x1f, 0x41, 0x91, 0x92, 0x35, 0x55, 0xef, 0x1d, 0x96, 0x21, 0xd3, 0x57,
+	0xf2, 0xe6, 0x23, 0xce, 0x1d, 0x79, 0xe9, 0xf3, 0x35, 0x08, 0x3a, 0x76, 0x61, 0xd1, 0x1e, 0x8c,
+	0x58, 0x3d, 0x7d, 0x91, 0x6e, 0x53, 0x62, 0x95, 0x47, 0xb9, 0x8e, 0x41, 0xe1, 0x1c, 0xbb, 0xfc,
+	0x51, 0x2d, 0xde, 0x0a, 0x79, 0x1c, 0xd8, 0x07, 0x47, 0x7b, 0x00, 0xfc, 0x07, 0x7f, 0x54, 0x2c,
+	0xcf, 0x71, 0x55, 0xf7, 0xb3, 0xa8, 0x4a, 0x7a, 0xbb, 0x14, 0x1f, 0x16, 0x3c, 0x32, 0x0e, 0x60,
+	0xa3, 0x3f, 0x92, 0x00, 0xd1, 0x9e, 0x69, 0x6a, 0xa4, 0x4b, 0x74, 0x5b, 0xd1, 0xf8, 0x28, 0x2d,
+	0x8f, 0x71, 0x95, 0x6f, 0x0f, 0x5a, 0xc1, 0x98, 0x60, 0x54, 0xb5, 0xf7, 0xbd, 0x20, 0xce, 0x8a,
+	0x13, 0xf4, 0xb2, 0x4d, 0xdc, 0x15, 0xb3, 0x1e, 0xcf, 0xb4, 0x89, 0xc9, 0xcf, 0xb5, 0xfe, 0x26,
+	0x0a, 0x3a, 0x76, 0x61, 0xd1, 0x53, 0x98, 0x73, 0x3b, 0x46, 0xb1, 0x61, 0xd8, 0x2b, 0xaa, 0x46,
+	0x68, 0x9f, 0xda, 0xa4, 0x5b, 0x9e, 0xe0, 0x0e, 0xe6, 0xb5, 0xcd, 0xe0, 0x44, 0x2e, 0x9c, 0x22,
+	0x8d, 0xba, 0x50, 0x71, 0x83, 0x13, 0x3b, 0xb9, 0x5e, 0x74, 0x7c, 0x44, 0x5b, 0x8a, 0xe6, 0x7c,
+	0x42, 0x99, 0xe4, 0x0a, 0x5e, 0x3b, 0x3e, 0xaa, 0x54, 0x96, 0x4f, 0x66, 0xc5, 0x83, 0xb0, 0xd0,
+	0x7b, 0x50, 0x56, 0xd2, 0xf4, 0x4c, 0x71, 0x3d, 0x3f, 0x65, 0x11, 0x2f, 0x55, 0x41, 0xaa, 0x34,
+	0xb2, 0x61, 0x4a, 0x09, 0xf7, 0xee, 0xd2, 0xf2, 0x74, 0xa6, 0xd7, 0xd8, 0x48, 0xcb, 0xaf, 0xff,
+	0x70, 0x12, 0x21, 0x50, 0x1c, 0xd3, 0x80, 0x7e, 0x1f, 0x90, 0x12, 0x6d, 0x37, 0xa6, 0x65, 0x94,
+	0x29, 0xd1, 0xc5, 0xfa, 0x94, 0x7d, 0xb7, 0x8b, 0x91, 0x28, 0x4e, 0xd0, 0xc3, 0x0a, 0x74, 0x25,
+	0xd2, 0x22, 0x4d, 0xcb, 0xf3, 0x5c, 0x79, 0x2d, 0x9b, 0x72, 0x4f, 0x2e, 0xf0, 0xa5, 0x28, 0x8a,
+	0x88, 0xe3, 0x4a, 0xd0, 0x1a, 0xcc, 0x8a, 0xc1, 0x6d, 0x9d, 0x2a, 0xbb, 0xa4, 0xd9, 0xa7, 0x2d,
+	0x5b, 0xa3, 0xe5, 0x19, 0x1e, 0xdf, 0xf9, 0xd7, 0xca, 0xc5, 0x04, 0x3a, 0x4e, 0x94, 0x42, 0x6f,
+	0xc3, 0xd4, 0xae, 0x61, 0xed, 0xa8, 0xed, 0x36, 0xd1, 0x5d, 0xa4, 0x59, 0x8e, 0xc4, 0xdf, 0x81,
+	0x56, 0x22, 0x34, 0x1c, 0xe3, 0x46, 0x14, 0x2e, 0x0a, 0xe4, 0x86, 0x65, 0xb4, 0xd6, 0x8d, 0x9e,
+	0x6e, 0x3b, 0x65, 0xdf, 0x45, 0x2f, 0x8d, 0x5e, 0x5c, 0x4c, 0x62, 0x78, 0x71, 0x54, 0xb9, 0x9a,
+	0x5c, 0xe5, 0xfb, 0x4c, 0x38, 0x19, 0x1b, 0x99, 0x30, 0x26, 0x1a, 0xdf, 0xf9, 0x83, 0x54, 0xb9,
+	0xcc, 0x8f, 0xfe, 0x83, 0xc1, 0x01, 0xcf, 0x13, 0x89, 0x9e, 0xff, 0xa9, 0xe3, 0xa3, 0xca, 0x58,
+	0x90, 0x01, 0x87, 0x34, 0xf0, 0x46, 0x27, 0xf1, 0x79, 0xed, 0x7c, 0x9a, 0xc5, 0x4f, 0xd7, 0xe8,
+	0xe4, 0x9b, 0xf6, 0xd2, 0x1a, 0x9d, 0x02, 0x90, 0x27, 0x3f, 0x99, 0xff, 0x57, 0x0e, 0x66, 0x7c,
+	0xe6, 0xcc, 0x8d, 0x4e, 0x09, 0x22, 0xbf, 0x6e, 0x18, 0xcf, 0xd6, 0x7c, 0xe4, 0x2f, 0xdd, 0xff,
+	0xbd, 0xe6, 0x23, 0xdf, 0xb6, 0x94, 0xdb, 0xc3, 0xdf, 0xe6, 0x82, 0x13, 0x38, 0x65, 0x07, 0xcc,
+	0x4b, 0xe8, 0x99, 0xfe, 0xd1, 0x35, 0xd1, 0xc8, 0x5f, 0xe7, 0x61, 0x2a, 0x7a, 0x1a, 0x43, 0x8d,
+	0x12, 0xd2, 0xc0, 0x46, 0x89, 0x06, 0xcc, 0xee, 0xf6, 0x34, 0xad, 0xcf, 0xe7, 0x10, 0xe8, 0x96,
+	0x70, 0x3e, 0x59, 0xfe, 0x54, 0x48, 0xce, 0xae, 0x24, 0xf0, 0xe0, 0x44, 0xc9, 0x78, 0xdf, 0x44,
+	0xe1, 0x87, 0xf6, 0x4d, 0x0c, 0x9d, 0xa1, 0x6f, 0x22, 0xb9, 0xf5, 0x24, 0x7f, 0xa6, 0xd6, 0x93,
+	0xb3, 0x34, 0x4d, 0x24, 0x04, 0xb1, 0x81, 0x0d, 0xc0, 0xbf, 0x80, 0x89, 0x70, 0x23, 0x8f, 0xb3,
+	0x97, 0x4e, 0x2f, 0x91, 0xf8, 0x34, 0x1c, 0xd8, 0x4b, 0x67, 0x1c, 0x7b, 0x1c, 0xf2, 0xb1, 0x04,
+	0x73, 0xc9, 0x0d, 0xbb, 0x48, 0x83, 0x89, 0xae, 0x72, 0x18, 0x6c, 0xa2, 0x96, 0xce, 0xf8, 0x32,
+	0xc6, 0x3b, 0x38, 0xd6, 0x43, 0x58, 0x38, 0x82, 0x8d, 0xde, 0x87, 0x52, 0x57, 0x39, 0x6c, 0xf6,
+	0xac, 0x0e, 0x39, 0xf3, 0x0b, 0x1c, 0x3f, 0x46, 0xeb, 0x02, 0x05, 0x7b, 0x78, 0xf2, 0xf7, 0x12,
+	0xcc, 0xa7, 0xf4, 0x65, 0xfc, 0x3f, 0x9a, 0xe5, 0x5f, 0x4a, 0xf0, 0x93, 0xd4, 0x6b, 0x18, 0xba,
+	0x17, 0x6a, 0x21, 0x91, 0x23, 0x2d, 0x24, 0x28, 0x2e, 0xf8, 0x8a, 0x3a, 0x48, 0x3e, 0x97, 0xa0,
+	0x9c, 0x76, 0x2f, 0x45, 0x77, 0x43, 0x46, 0xfe, 0x2c, 0x62, 0xe4, 0x74, 0x4c, 0xee, 0x15, 0xd9,
+	0xf8, 0x6f, 0x12, 0x5c, 0x3e, 0xa1, 0xbe, 0xf3, 0xae, 0x3f, 0xa4, 0x1d, 0xe4, 0xe2, 0x4f, 0xe2,
+	0xe2, 0x7b, 0x9a, 0x7f, 0xfd, 0x49, 0xe0, 0xc1, 0xa9, 0xd2, 0x68, 0x1b, 0xe6, 0xc5, 0xdd, 0x2b,
+	0x4a, 0x13, 0xa5, 0x0b, 0xef, 0xb4, 0x5b, 0x4e, 0x66, 0xc1, 0x69, 0xb2, 0xf2, 0xdf, 0x48, 0x30,
+	0x97, 0xfc, 0xe0, 0x80, 0xde, 0x0a, 0x2d, 0x79, 0x25, 0xb2, 0xe4, 0x93, 0x11, 0x29, 0xb1, 0xe0,
+	0x1f, 0xc2, 0x84, 0x78, 0x96, 0x10, 0x30, 0xc2, 0x99, 0xe5, 0xa4, 0xec, 0x24, 0x20, 0xdc, 0xe2,
+	0x98, 0x1f, 0x93, 0xf0, 0x18, 0x8e, 0xa0, 0xc9, 0x9f, 0xe6, 0x60, 0xa8, 0xd9, 0x52, 0x34, 0x72,
+	0x0e, 0xb5, 0xf1, 0xaf, 0x42, 0xb5, 0xf1, 0xa0, 0xff, 0xc3, 0xc6, 0xad, 0x4a, 0x2d, 0x8b, 0x71,
+	0xa4, 0x2c, 0x7e, 0x23, 0x13, 0xda, 0xc9, 0x15, 0xf1, 0x6f, 0xc1, 0x88, 0xa7, 0xf4, 0x74, 0x89,
+	0x5a, 0xfe, 0x8b, 0x1c, 0x8c, 0x06, 0x54, 0x9c, 0x32, 0xcd, 0xef, 0x86, 0x6a, 0x9b, 0x7c, 0x86,
+	0x47, 0xa0, 0x80, 0xae, 0xaa, 0x5b, 0xcd, 0x38, 0x3d, 0xd8, 0x7e, 0xd7, 0x6d, 0xbc, 0xc8, 0xf9,
+	0x05, 0x4c, 0xd8, 0x8a, 0xd5, 0x21, 0xb6, 0xf7, 0x51, 0xc4, 0xe9, 0x11, 0xf3, 0xfe, 0x33, 0xc0,
+	0x56, 0x88, 0x8a, 0x23, 0xdc, 0x97, 0x1e, 0xc2, 0x78, 0x48, 0xd9, 0xa9, 0x5a, 0xa8, 0xff, 0x4e,
+	0x82, 0x9f, 0x0d, 0x7c, 0x48, 0x42, 0xf5, 0xd0, 0x21, 0xa9, 0x46, 0x0e, 0xc9, 0x42, 0x3a, 0xc0,
+	0xab, 0x6b, 0xc5, 0xab, 0xdf, 0x7c, 0xfe, 0xdd, 0xc2, 0x85, 0x6f, 0xbe, 0x5b, 0xb8, 0xf0, 0xed,
+	0x77, 0x0b, 0x17, 0xfe, 0xe0, 0x78, 0x41, 0x7a, 0x7e, 0xbc, 0x20, 0x7d, 0x73, 0xbc, 0x20, 0x7d,
+	0x7b, 0xbc, 0x20, 0xfd, 0xc7, 0xf1, 0x82, 0xf4, 0x27, 0xdf, 0x2f, 0x5c, 0x78, 0xbf, 0x28, 0xe0,
+	0xfe, 0x37, 0x00, 0x00, 0xff, 0xff, 0xe5, 0x2f, 0x59, 0xc3, 0x16, 0x3f, 0x00, 0x00,
 }
 
 func (m *AllowedCSIDriver) Marshal() (dAtA []byte, err error) {
@@ -4378,6 +4378,18 @@ func (m *RollingUpdateDaemonSet) MarshalToSizedBuffer(dAtA []byte) (int, error)
 	_ = i
 	var l int
 	_ = l
+	if m.MaxSurge != nil {
+		{
+			size, err := m.MaxSurge.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintGenerated(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x12
+	}
 	if m.MaxUnavailable != nil {
 		{
 			size, err := m.MaxUnavailable.MarshalToSizedBuffer(dAtA[:i])
@@ -5684,6 +5696,10 @@ func (m *RollingUpdateDaemonSet) Size() (n int) {
 		l = m.MaxUnavailable.Size()
 		n += 1 + l + sovGenerated(uint64(l))
 	}
+	if m.MaxSurge != nil {
+		l = m.MaxSurge.Size()
+		n += 1 + l + sovGenerated(uint64(l))
+	}
 	return n
 }
 
@@ -6546,6 +6562,7 @@ func (this *RollingUpdateDaemonSet) String() string {
 	}
 	s := strings.Join([]string{`&RollingUpdateDaemonSet{`,
 		`MaxUnavailable:` + strings.Replace(fmt.Sprintf("%v", this.MaxUnavailable), "IntOrString", "intstr.IntOrString", 1) + `,`,
+		`MaxSurge:` + strings.Replace(fmt.Sprintf("%v", this.MaxSurge), "IntOrString", "intstr.IntOrString", 1) + `,`,
 		`}`,
 	}, "")
 	return s
@@ -14029,6 +14046,42 @@ func (m *RollingUpdateDaemonSet) Unmarshal(dAtA []byte) error {
 				return err
 			}
 			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field MaxSurge", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenerated
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.MaxSurge == nil {
+				m.MaxSurge = &intstr.IntOrString{}
+			}
+			if err := m.MaxSurge.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipGenerated(dAtA[iNdEx:])
diff --git a/staging/src/k8s.io/api/extensions/v1beta1/generated.proto b/staging/src/k8s.io/api/extensions/v1beta1/generated.proto
index a4ca5b563ae..e5823499e8f 100644
--- a/staging/src/k8s.io/api/extensions/v1beta1/generated.proto
+++ b/staging/src/k8s.io/api/extensions/v1beta1/generated.proto
@@ -1082,19 +1082,41 @@ message RollingUpdateDaemonSet {
   // The maximum number of DaemonSet pods that can be unavailable during the
   // update. Value can be an absolute number (ex: 5) or a percentage of total
   // number of DaemonSet pods at the start of the update (ex: 10%). Absolute
-  // number is calculated from percentage by rounding up.
-  // This cannot be 0.
+  // number is calculated from percentage by rounding down to a minimum of one.
+  // This cannot be 0 if MaxSurge is 0
   // Default value is 1.
   // Example: when this is set to 30%, at most 30% of the total number of nodes
   // that should be running the daemon pod (i.e. status.desiredNumberScheduled)
-  // can have their pods stopped for an update at any given
-  // time. The update starts by stopping at most 30% of those DaemonSet pods
-  // and then brings up new DaemonSet pods in their place. Once the new pods
-  // are available, it then proceeds onto other DaemonSet pods, thus ensuring
-  // that at least 70% of original number of DaemonSet pods are available at
-  // all times during the update.
+  // can have their pods stopped for an update at any given time. The update
+  // starts by stopping at most 30% of those DaemonSet pods and then brings
+  // up new DaemonSet pods in their place. Once the new pods are available,
+  // it then proceeds onto other DaemonSet pods, thus ensuring that at least
+  // 70% of original number of DaemonSet pods are available at all times during
+  // the update.
   // +optional
   optional k8s.io.apimachinery.pkg.util.intstr.IntOrString maxUnavailable = 1;
+
+  // The maximum number of nodes with an existing available DaemonSet pod that
+  // can have an updated DaemonSet pod during during an update.
+  // Value can be an absolute number (ex: 5) or a percentage of desired pods (ex: 10%).
+  // This can not be 0 if MaxUnavailable is 0.
+  // Absolute number is calculated from percentage by rounding up to a minimum of 1.
+  // Default value is 0.
+  // Example: when this is set to 30%, at most 30% of the total number of nodes
+  // that should be running the daemon pod (i.e. status.desiredNumberScheduled)
+  // can have their a new pod created before the old pod is marked as deleted.
+  // The update starts by launching new pods on 30% of nodes. Once an updated
+  // pod is available (Ready for at least minReadySeconds) the old DaemonSet pod
+  // on that node is marked deleted. If the old pod becomes unavailable for any
+  // reason (Ready transitions to false, is evicted, or is drained) an updated
+  // pod is immediatedly created on that node without considering surge limits.
+  // Allowing surge implies the possibility that the resources consumed by the
+  // daemonset on any given node can double if the readiness check fails, and
+  // so resource intensive daemonsets should take into account that they may
+  // cause evictions during disruption.
+  // This is an alpha field and requires enabling DaemonSetUpdateSurge feature gate.
+  // +optional
+  optional k8s.io.apimachinery.pkg.util.intstr.IntOrString maxSurge = 2;
 }
 
 // Spec to control the desired behavior of rolling update.
diff --git a/staging/src/k8s.io/api/extensions/v1beta1/types.go b/staging/src/k8s.io/api/extensions/v1beta1/types.go
index bd75c51bcca..0c22a0a69e5 100644
--- a/staging/src/k8s.io/api/extensions/v1beta1/types.go
+++ b/staging/src/k8s.io/api/extensions/v1beta1/types.go
@@ -357,19 +357,41 @@ type RollingUpdateDaemonSet struct {
 	// The maximum number of DaemonSet pods that can be unavailable during the
 	// update. Value can be an absolute number (ex: 5) or a percentage of total
 	// number of DaemonSet pods at the start of the update (ex: 10%). Absolute
-	// number is calculated from percentage by rounding up.
-	// This cannot be 0.
+	// number is calculated from percentage by rounding down to a minimum of one.
+	// This cannot be 0 if MaxSurge is 0
 	// Default value is 1.
 	// Example: when this is set to 30%, at most 30% of the total number of nodes
 	// that should be running the daemon pod (i.e. status.desiredNumberScheduled)
-	// can have their pods stopped for an update at any given
-	// time. The update starts by stopping at most 30% of those DaemonSet pods
-	// and then brings up new DaemonSet pods in their place. Once the new pods
-	// are available, it then proceeds onto other DaemonSet pods, thus ensuring
-	// that at least 70% of original number of DaemonSet pods are available at
-	// all times during the update.
+	// can have their pods stopped for an update at any given time. The update
+	// starts by stopping at most 30% of those DaemonSet pods and then brings
+	// up new DaemonSet pods in their place. Once the new pods are available,
+	// it then proceeds onto other DaemonSet pods, thus ensuring that at least
+	// 70% of original number of DaemonSet pods are available at all times during
+	// the update.
 	// +optional
 	MaxUnavailable *intstr.IntOrString `json:"maxUnavailable,omitempty" protobuf:"bytes,1,opt,name=maxUnavailable"`
+
+	// The maximum number of nodes with an existing available DaemonSet pod that
+	// can have an updated DaemonSet pod during during an update.
+	// Value can be an absolute number (ex: 5) or a percentage of desired pods (ex: 10%).
+	// This can not be 0 if MaxUnavailable is 0.
+	// Absolute number is calculated from percentage by rounding up to a minimum of 1.
+	// Default value is 0.
+	// Example: when this is set to 30%, at most 30% of the total number of nodes
+	// that should be running the daemon pod (i.e. status.desiredNumberScheduled)
+	// can have their a new pod created before the old pod is marked as deleted.
+	// The update starts by launching new pods on 30% of nodes. Once an updated
+	// pod is available (Ready for at least minReadySeconds) the old DaemonSet pod
+	// on that node is marked deleted. If the old pod becomes unavailable for any
+	// reason (Ready transitions to false, is evicted, or is drained) an updated
+	// pod is immediatedly created on that node without considering surge limits.
+	// Allowing surge implies the possibility that the resources consumed by the
+	// daemonset on any given node can double if the readiness check fails, and
+	// so resource intensive daemonsets should take into account that they may
+	// cause evictions during disruption.
+	// This is an alpha field and requires enabling DaemonSetUpdateSurge feature gate.
+	// +optional
+	MaxSurge *intstr.IntOrString `json:"maxSurge,omitempty" protobuf:"bytes,2,opt,name=maxSurge"`
 }
 
 // DaemonSetSpec is the specification of a daemon set.
diff --git a/staging/src/k8s.io/api/extensions/v1beta1/types_swagger_doc_generated.go b/staging/src/k8s.io/api/extensions/v1beta1/types_swagger_doc_generated.go
index 0ef3c00593e..b309224f837 100644
--- a/staging/src/k8s.io/api/extensions/v1beta1/types_swagger_doc_generated.go
+++ b/staging/src/k8s.io/api/extensions/v1beta1/types_swagger_doc_generated.go
@@ -555,7 +555,8 @@ func (RollbackConfig) SwaggerDoc() map[string]string {
 
 var map_RollingUpdateDaemonSet = map[string]string{
 	"":               "Spec to control the desired behavior of daemon set rolling update.",
-	"maxUnavailable": "The maximum number of DaemonSet pods that can be unavailable during the update. Value can be an absolute number (ex: 5) or a percentage of total number of DaemonSet pods at the start of the update (ex: 10%). Absolute number is calculated from percentage by rounding up. This cannot be 0. Default value is 1. Example: when this is set to 30%, at most 30% of the total number of nodes that should be running the daemon pod (i.e. status.desiredNumberScheduled) can have their pods stopped for an update at any given time. The update starts by stopping at most 30% of those DaemonSet pods and then brings up new DaemonSet pods in their place. Once the new pods are available, it then proceeds onto other DaemonSet pods, thus ensuring that at least 70% of original number of DaemonSet pods are available at all times during the update.",
+	"maxUnavailable": "The maximum number of DaemonSet pods that can be unavailable during the update. Value can be an absolute number (ex: 5) or a percentage of total number of DaemonSet pods at the start of the update (ex: 10%). Absolute number is calculated from percentage by rounding down to a minimum of one. This cannot be 0 if MaxSurge is 0 Default value is 1. Example: when this is set to 30%, at most 30% of the total number of nodes that should be running the daemon pod (i.e. status.desiredNumberScheduled) can have their pods stopped for an update at any given time. The update starts by stopping at most 30% of those DaemonSet pods and then brings up new DaemonSet pods in their place. Once the new pods are available, it then proceeds onto other DaemonSet pods, thus ensuring that at least 70% of original number of DaemonSet pods are available at all times during the update.",
+	"maxSurge":       "The maximum number of nodes with an existing available DaemonSet pod that can have an updated DaemonSet pod during during an update. Value can be an absolute number (ex: 5) or a percentage of desired pods (ex: 10%). This can not be 0 if MaxUnavailable is 0. Absolute number is calculated from percentage by rounding up to a minimum of 1. Default value is 0. Example: when this is set to 30%, at most 30% of the total number of nodes that should be running the daemon pod (i.e. status.desiredNumberScheduled) can have their a new pod created before the old pod is marked as deleted. The update starts by launching new pods on 30% of nodes. Once an updated pod is available (Ready for at least minReadySeconds) the old DaemonSet pod on that node is marked deleted. If the old pod becomes unavailable for any reason (Ready transitions to false, is evicted, or is drained) an updated pod is immediatedly created on that node without considering surge limits. Allowing surge implies the possibility that the resources consumed by the daemonset on any given node can double if the readiness check fails, and so resource intensive daemonsets should take into account that they may cause evictions during disruption. This is an alpha field and requires enabling DaemonSetUpdateSurge feature gate.",
 }
 
 func (RollingUpdateDaemonSet) SwaggerDoc() map[string]string {
diff --git a/staging/src/k8s.io/api/extensions/v1beta1/zz_generated.deepcopy.go b/staging/src/k8s.io/api/extensions/v1beta1/zz_generated.deepcopy.go
index 913f4851453..7b4776c0e26 100644
--- a/staging/src/k8s.io/api/extensions/v1beta1/zz_generated.deepcopy.go
+++ b/staging/src/k8s.io/api/extensions/v1beta1/zz_generated.deepcopy.go
@@ -1272,6 +1272,11 @@ func (in *RollingUpdateDaemonSet) DeepCopyInto(out *RollingUpdateDaemonSet) {
 		*out = new(intstr.IntOrString)
 		**out = **in
 	}
+	if in.MaxSurge != nil {
+		in, out := &in.MaxSurge, &out.MaxSurge
+		*out = new(intstr.IntOrString)
+		**out = **in
+	}
 	return
 }
 
diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1.DaemonSet.json b/staging/src/k8s.io/api/testdata/HEAD/apps.v1.DaemonSet.json
index 895d9776fff..be2d1283400 100644
--- a/staging/src/k8s.io/api/testdata/HEAD/apps.v1.DaemonSet.json
+++ b/staging/src/k8s.io/api/testdata/HEAD/apps.v1.DaemonSet.json
@@ -1468,7 +1468,8 @@
     "updateStrategy": {
       "type": "翘ǼZ熝Ʊ宷泐ɻvŰ`Ǧɝ憑ǖ菐u",
       "rollingUpdate": {
-        "maxUnavailable": 2
+        "maxUnavailable": 2,
+        "maxSurge": 3
       }
     },
     "minReadySeconds": -985724127,
diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1.DaemonSet.pb b/staging/src/k8s.io/api/testdata/HEAD/apps.v1.DaemonSet.pb
index 996e38326a1..0e125062a89 100644
Binary files a/staging/src/k8s.io/api/testdata/HEAD/apps.v1.DaemonSet.pb and b/staging/src/k8s.io/api/testdata/HEAD/apps.v1.DaemonSet.pb differ
diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1.DaemonSet.yaml b/staging/src/k8s.io/api/testdata/HEAD/apps.v1.DaemonSet.yaml
index 75d339eabd5..5359a92be38 100644
--- a/staging/src/k8s.io/api/testdata/HEAD/apps.v1.DaemonSet.yaml
+++ b/staging/src/k8s.io/api/testdata/HEAD/apps.v1.DaemonSet.yaml
@@ -1004,6 +1004,7 @@ spec:
           volumePath: "101"
   updateStrategy:
     rollingUpdate:
+      maxSurge: 3
       maxUnavailable: 2
     type: 翘ǼZ熝Ʊ宷泐ɻvŰ`Ǧɝ憑ǖ菐u
 status:
diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.DaemonSet.json b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.DaemonSet.json
index 95f6b420cf8..6457e8d64da 100644
--- a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.DaemonSet.json
+++ b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.DaemonSet.json
@@ -1468,7 +1468,8 @@
     "updateStrategy": {
       "type": "翘ǼZ熝Ʊ宷泐ɻvŰ`Ǧɝ憑ǖ菐u",
       "rollingUpdate": {
-        "maxUnavailable": 2
+        "maxUnavailable": 2,
+        "maxSurge": 3
       }
     },
     "minReadySeconds": -985724127,
diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.DaemonSet.pb b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.DaemonSet.pb
index df357baa253..9d25068d758 100644
Binary files a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.DaemonSet.pb and b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.DaemonSet.pb differ
diff --git a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.DaemonSet.yaml b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.DaemonSet.yaml
index c660842e9ea..251a695867e 100644
--- a/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.DaemonSet.yaml
+++ b/staging/src/k8s.io/api/testdata/HEAD/apps.v1beta2.DaemonSet.yaml
@@ -1004,6 +1004,7 @@ spec:
           volumePath: "101"
   updateStrategy:
     rollingUpdate:
+      maxSurge: 3
       maxUnavailable: 2
     type: 翘ǼZ熝Ʊ宷泐ɻvŰ`Ǧɝ憑ǖ菐u
 status:
diff --git a/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.DaemonSet.json b/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.DaemonSet.json
index 190d1b9b75e..59cf1ba9ce3 100644
--- a/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.DaemonSet.json
+++ b/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.DaemonSet.json
@@ -1468,7 +1468,8 @@
     "updateStrategy": {
       "type": "翘ǼZ熝Ʊ宷泐ɻvŰ`Ǧɝ憑ǖ菐u",
       "rollingUpdate": {
-        "maxUnavailable": 2
+        "maxUnavailable": 2,
+        "maxSurge": 3
       }
     },
     "minReadySeconds": -985724127,
diff --git a/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.DaemonSet.pb b/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.DaemonSet.pb
index 9fd117dfd23..8131da18196 100644
Binary files a/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.DaemonSet.pb and b/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.DaemonSet.pb differ
diff --git a/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.DaemonSet.yaml b/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.DaemonSet.yaml
index 8bbf559d876..ca9655dfe23 100644
--- a/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.DaemonSet.yaml
+++ b/staging/src/k8s.io/api/testdata/HEAD/extensions.v1beta1.DaemonSet.yaml
@@ -1005,6 +1005,7 @@ spec:
   templateGeneration: -8308852022291575505
   updateStrategy:
     rollingUpdate:
+      maxSurge: 3
       maxUnavailable: 2
     type: 翘ǼZ熝Ʊ宷泐ɻvŰ`Ǧɝ憑ǖ菐u
 status: