diff --git a/api/openapi-spec/swagger.json b/api/openapi-spec/swagger.json
index 2f971a5f7f7..a0e56f04040 100644
--- a/api/openapi-spec/swagger.json
+++ b/api/openapi-spec/swagger.json
@@ -34450,6 +34450,10 @@
"description": "IP address allocated to the pod. Routable at least within the cluster. Empty if not yet allocated.",
"type": "string"
},
+ "qosClass": {
+ "description": "The Quality of Service (QOS) classification assigned to the pod based on resource requirements See PodQOSClass type for available QOS classes More info: https://github.com/kubernetes/kubernetes/blob/master/docs/design/resource-qos.md",
+ "type": "string"
+ },
"reason": {
"description": "A brief CamelCase message indicating details about why the pod is in this state. e.g. 'OutOfDisk'",
"type": "string"
diff --git a/api/swagger-spec/v1.json b/api/swagger-spec/v1.json
index f6b607a6d55..495246b59cf 100644
--- a/api/swagger-spec/v1.json
+++ b/api/swagger-spec/v1.json
@@ -19103,6 +19103,10 @@
"$ref": "v1.ContainerStatus"
},
"description": "The list has one entry per container in the manifest. Each entry is currently the output of `docker inspect`. More info: http://kubernetes.io/docs/user-guide/pod-states#container-statuses"
+ },
+ "qosClass": {
+ "type": "string",
+ "description": "The Quality of Service (QOS) classification assigned to the pod based on resource requirements See PodQOSClass type for available QOS classes More info: https://github.com/kubernetes/kubernetes/blob/master/docs/design/resource-qos.md"
}
}
},
diff --git a/docs/api-reference/v1/definitions.html b/docs/api-reference/v1/definitions.html
index 79d7d926657..8a367ec3594 100755
--- a/docs/api-reference/v1/definitions.html
+++ b/docs/api-reference/v1/definitions.html
@@ -4239,6 +4239,13 @@ The resulting set of endpoints can be viewed as:
v1.ContainerStatus array |
|
+
+qosClass |
+The Quality of Service (QOS) classification assigned to the pod based on resource requirements See PodQOSClass type for available QOS classes More info: https://github.com/kubernetes/kubernetes/blob/master/docs/design/resource-qos.md |
+false |
+string |
+ |
+
@@ -8620,7 +8627,7 @@ Examples:
diff --git a/pkg/api/types.go b/pkg/api/types.go
index fde330f0504..9dd6ed27ea2 100644
--- a/pkg/api/types.go
+++ b/pkg/api/types.go
@@ -1894,6 +1894,18 @@ type PodSecurityContext struct {
FSGroup *int64
}
+// PodQOSClass defines the supported qos classes of Pods.
+type PodQOSClass string
+
+const (
+ // PodQOSGuaranteed is the Guaranteed qos class.
+ PodQOSGuaranteed PodQOSClass = "Guaranteed"
+ // PodQOSBurstable is the Burstable qos class.
+ PodQOSBurstable PodQOSClass = "Burstable"
+ // PodQOSBestEffort is the BestEffort qos class.
+ PodQOSBestEffort PodQOSClass = "BestEffort"
+)
+
// PodStatus represents information about the status of a pod. Status may trail the actual
// state of a system.
type PodStatus struct {
@@ -1917,6 +1929,8 @@ type PodStatus struct {
// This is before the Kubelet pulled the container image(s) for the pod.
// +optional
StartTime *metav1.Time
+ // +optional
+ QOSClass PodQOSClass `json:"qosClass,omitempty"`
// The list has one entry per init container in the manifest. The most recent successful
// init container will have ready = true, the most recently started container will have
diff --git a/pkg/api/v1/generated.pb.go b/pkg/api/v1/generated.pb.go
index 68282646b09..b4ef7319928 100644
--- a/pkg/api/v1/generated.pb.go
+++ b/pkg/api/v1/generated.pb.go
@@ -6087,6 +6087,10 @@ func (m *PodStatus) MarshalTo(data []byte) (int, error) {
i += n
}
}
+ data[i] = 0x4a
+ i++
+ i = encodeVarintGenerated(data, i, uint64(len(m.QOSClass)))
+ i += copy(data[i:], m.QOSClass)
return i, nil
}
@@ -10114,6 +10118,8 @@ func (m *PodStatus) Size() (n int) {
n += 1 + l + sovGenerated(uint64(l))
}
}
+ l = len(m.QOSClass)
+ n += 1 + l + sovGenerated(uint64(l))
return n
}
@@ -12438,6 +12444,7 @@ func (this *PodStatus) String() string {
`PodIP:` + fmt.Sprintf("%v", this.PodIP) + `,`,
`StartTime:` + strings.Replace(fmt.Sprintf("%v", this.StartTime), "Time", "k8s_io_kubernetes_pkg_apis_meta_v1.Time", 1) + `,`,
`ContainerStatuses:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ContainerStatuses), "ContainerStatus", "ContainerStatus", 1), `&`, ``, 1) + `,`,
+ `QOSClass:` + fmt.Sprintf("%v", this.QOSClass) + `,`,
`}`,
}, "")
return s
@@ -31284,6 +31291,35 @@ func (m *PodStatus) Unmarshal(data []byte) error {
return err
}
iNdEx = postIndex
+ case 9:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field QOSClass", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenerated
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := data[iNdEx]
+ iNdEx++
+ stringLen |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenerated
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.QOSClass = PodQOSClass(data[iNdEx:postIndex])
+ iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipGenerated(data[iNdEx:])
@@ -39144,630 +39180,632 @@ var (
)
var fileDescriptorGenerated = []byte{
- // 9989 bytes of a gzipped FileDescriptorProto
+ // 10019 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xec, 0x7d, 0x6d, 0x8c, 0x24, 0xc7,
- 0x75, 0x98, 0x7a, 0x66, 0xbf, 0xe6, 0xed, 0xe7, 0xd5, 0x7d, 0x70, 0xb9, 0x22, 0x6f, 0x4f, 0x4d,
+ 0x75, 0x98, 0x7a, 0x66, 0xbf, 0xe6, 0xed, 0xe7, 0xd5, 0x7d, 0x70, 0xb9, 0x26, 0x6f, 0x4f, 0x4d,
0x91, 0x3a, 0x92, 0xc7, 0x5d, 0xdd, 0x91, 0x14, 0x29, 0x91, 0xa1, 0xb4, 0xbb, 0xb3, 0x7b, 0xb7,
- 0xba, 0xdb, 0xbb, 0x61, 0xcd, 0xde, 0x1d, 0x25, 0x11, 0x92, 0x7a, 0xa7, 0x6b, 0x77, 0x5b, 0xd7,
- 0xdb, 0x3d, 0xec, 0xee, 0xd9, 0xbb, 0x95, 0x62, 0xc0, 0x91, 0x19, 0x1b, 0x81, 0x04, 0x47, 0x41,
- 0x20, 0x24, 0x40, 0x12, 0x44, 0x09, 0x90, 0xc0, 0x89, 0x61, 0x2b, 0x8a, 0x94, 0x40, 0x8a, 0x65,
- 0x03, 0x41, 0x6c, 0x47, 0x41, 0xe2, 0x40, 0xfa, 0x13, 0x1b, 0x36, 0xb0, 0x31, 0xd7, 0xf9, 0x97,
- 0xfc, 0x08, 0x90, 0x5f, 0x39, 0x18, 0x49, 0x50, 0x9f, 0x5d, 0xd5, 0xd3, 0xb3, 0xdd, 0x73, 0xbc,
- 0x39, 0x53, 0x46, 0xfe, 0xcd, 0xbc, 0xf7, 0xea, 0xd5, 0x47, 0xbf, 0x7a, 0xf5, 0xea, 0xd5, 0xab,
- 0x57, 0x70, 0xe1, 0xce, 0xab, 0xf1, 0x82, 0x17, 0x2e, 0xde, 0xe9, 0x6c, 0x91, 0x28, 0x20, 0x09,
- 0x89, 0x17, 0xdb, 0x77, 0x76, 0x16, 0x9d, 0xb6, 0xb7, 0xb8, 0x7f, 0x71, 0x71, 0x87, 0x04, 0x24,
- 0x72, 0x12, 0xe2, 0x2e, 0xb4, 0xa3, 0x30, 0x09, 0xd1, 0x13, 0x9c, 0x7a, 0x21, 0xa5, 0x5e, 0x68,
- 0xdf, 0xd9, 0x59, 0x70, 0xda, 0xde, 0xc2, 0xfe, 0xc5, 0xb9, 0x17, 0x76, 0xbc, 0x64, 0xb7, 0xb3,
- 0xb5, 0xd0, 0x0a, 0xf7, 0x16, 0x77, 0xc2, 0x9d, 0x70, 0x91, 0x15, 0xda, 0xea, 0x6c, 0xb3, 0x7f,
- 0xec, 0x0f, 0xfb, 0xc5, 0x99, 0xcd, 0x5d, 0xea, 0x5d, 0x75, 0x44, 0xe2, 0xb0, 0x13, 0xb5, 0x48,
- 0xb6, 0x01, 0xc7, 0x94, 0x89, 0x17, 0xf7, 0x48, 0xe2, 0xe4, 0x34, 0x7a, 0xee, 0x85, 0xfc, 0x32,
- 0x51, 0x27, 0x48, 0xbc, 0xbd, 0xee, 0x2a, 0x5e, 0x3a, 0x9e, 0x3c, 0x6e, 0xed, 0x92, 0x3d, 0xa7,
- 0xab, 0xd4, 0xc5, 0xfc, 0x52, 0x9d, 0xc4, 0xf3, 0x17, 0xbd, 0x20, 0x89, 0x93, 0x28, 0x5b, 0xc4,
- 0xfe, 0x43, 0x0b, 0xce, 0x2d, 0xdd, 0x6e, 0xae, 0xfa, 0x4e, 0x9c, 0x78, 0xad, 0x65, 0x3f, 0x6c,
- 0xdd, 0x69, 0x26, 0x61, 0x44, 0x6e, 0x85, 0x7e, 0x67, 0x8f, 0x34, 0xd9, 0x00, 0xa0, 0x0b, 0x30,
- 0xb6, 0xcf, 0xfe, 0xaf, 0xd7, 0x67, 0xad, 0x73, 0xd6, 0xf9, 0xda, 0xf2, 0xcc, 0x4f, 0x0e, 0xe7,
- 0x3f, 0x74, 0x74, 0x38, 0x3f, 0x76, 0x4b, 0xc0, 0xb1, 0xa2, 0x40, 0xcf, 0xc0, 0xc8, 0x76, 0xbc,
- 0x79, 0xd0, 0x26, 0xb3, 0x15, 0x46, 0x3b, 0x25, 0x68, 0x47, 0xd6, 0x9a, 0x14, 0x8a, 0x05, 0x16,
- 0x2d, 0x42, 0xad, 0xed, 0x44, 0x89, 0x97, 0x78, 0x61, 0x30, 0x5b, 0x3d, 0x67, 0x9d, 0x1f, 0x5e,
- 0x3e, 0x21, 0x48, 0x6b, 0x0d, 0x89, 0xc0, 0x29, 0x0d, 0x6d, 0x46, 0x44, 0x1c, 0xf7, 0x46, 0xe0,
- 0x1f, 0xcc, 0x0e, 0x9d, 0xb3, 0xce, 0x8f, 0xa5, 0xcd, 0xc0, 0x02, 0x8e, 0x15, 0x85, 0xfd, 0xc3,
- 0x0a, 0x8c, 0x2d, 0x6d, 0x6f, 0x7b, 0x81, 0x97, 0x1c, 0xa0, 0x2f, 0xc3, 0x44, 0x10, 0xba, 0x44,
- 0xfe, 0x67, 0xbd, 0x18, 0xbf, 0xf4, 0xdc, 0xc2, 0x71, 0xa2, 0xb4, 0x70, 0x5d, 0x2b, 0xb1, 0x3c,
- 0x73, 0x74, 0x38, 0x3f, 0xa1, 0x43, 0xb0, 0xc1, 0x11, 0xbd, 0x0d, 0xe3, 0xed, 0xd0, 0x55, 0x15,
- 0x54, 0x58, 0x05, 0xcf, 0x1e, 0x5f, 0x41, 0x23, 0x2d, 0xb0, 0x3c, 0x7d, 0x74, 0x38, 0x3f, 0xae,
- 0x01, 0xb0, 0xce, 0x0e, 0xf9, 0x30, 0x4d, 0xff, 0x06, 0x89, 0xa7, 0x6a, 0xa8, 0xb2, 0x1a, 0x5e,
- 0x28, 0xae, 0x41, 0x2b, 0xb4, 0x7c, 0xf2, 0xe8, 0x70, 0x7e, 0x3a, 0x03, 0xc4, 0x59, 0xd6, 0xf6,
- 0x57, 0x61, 0x6a, 0x29, 0x49, 0x9c, 0xd6, 0x2e, 0x71, 0xf9, 0xf7, 0x45, 0x2f, 0xc1, 0x50, 0xe0,
- 0xec, 0x11, 0xf1, 0xf5, 0xcf, 0x89, 0x61, 0x1f, 0xba, 0xee, 0xec, 0x91, 0xfb, 0x87, 0xf3, 0x33,
- 0x37, 0x03, 0xef, 0x9d, 0x8e, 0x90, 0x19, 0x0a, 0xc3, 0x8c, 0x1a, 0x5d, 0x02, 0x70, 0xc9, 0xbe,
- 0xd7, 0x22, 0x0d, 0x27, 0xd9, 0x15, 0xd2, 0x80, 0x44, 0x59, 0xa8, 0x2b, 0x0c, 0xd6, 0xa8, 0xec,
- 0xaf, 0x5b, 0x50, 0x5b, 0xda, 0x0f, 0x3d, 0xb7, 0x11, 0xba, 0x31, 0xea, 0xc0, 0x74, 0x3b, 0x22,
- 0xdb, 0x24, 0x52, 0xa0, 0x59, 0xeb, 0x5c, 0xf5, 0xfc, 0xf8, 0xa5, 0x4b, 0x05, 0xfd, 0x36, 0x0b,
- 0xad, 0x06, 0x49, 0x74, 0xb0, 0xfc, 0x98, 0xa8, 0x7a, 0x3a, 0x83, 0xc5, 0xd9, 0x3a, 0xec, 0xbf,
- 0x55, 0x81, 0xd3, 0x4b, 0x5f, 0xed, 0x44, 0xa4, 0xee, 0xc5, 0x77, 0xb2, 0x53, 0xc1, 0xf5, 0xe2,
- 0x3b, 0xd7, 0xd3, 0xc1, 0x50, 0x32, 0x58, 0x17, 0x70, 0xac, 0x28, 0xd0, 0x0b, 0x30, 0x4a, 0x7f,
- 0xdf, 0xc4, 0xeb, 0xa2, 0xf7, 0x27, 0x05, 0xf1, 0x78, 0xdd, 0x49, 0x9c, 0x3a, 0x47, 0x61, 0x49,
- 0x83, 0x36, 0x60, 0xbc, 0xe5, 0xb4, 0x76, 0xbd, 0x60, 0x67, 0x23, 0x74, 0x09, 0xfb, 0xc2, 0xb5,
- 0xe5, 0xe7, 0x29, 0xf9, 0x4a, 0x0a, 0xbe, 0x7f, 0x38, 0x3f, 0xcb, 0xdb, 0x26, 0x58, 0x68, 0x38,
- 0xac, 0x97, 0x47, 0xb6, 0x9a, 0x88, 0x43, 0x8c, 0x13, 0xe4, 0x4c, 0xc2, 0xf3, 0xda, 0x9c, 0x1a,
- 0x66, 0x73, 0x6a, 0xa2, 0xc7, 0x7c, 0xfa, 0xe7, 0x96, 0x18, 0x93, 0x35, 0xcf, 0x37, 0xd5, 0xc3,
- 0x25, 0x80, 0x98, 0xb4, 0x22, 0x92, 0x68, 0xa3, 0xa2, 0x3e, 0x73, 0x53, 0x61, 0xb0, 0x46, 0x45,
- 0x27, 0x7f, 0xbc, 0xeb, 0x44, 0x4c, 0x5a, 0xc4, 0xd8, 0xa8, 0xc9, 0xdf, 0x94, 0x08, 0x9c, 0xd2,
- 0x18, 0x93, 0xbf, 0x5a, 0x38, 0xf9, 0xff, 0x8d, 0x05, 0xa3, 0xcb, 0x5e, 0xe0, 0x7a, 0xc1, 0x0e,
- 0x7a, 0x0b, 0xc6, 0xa8, 0x56, 0x76, 0x9d, 0xc4, 0x11, 0xf3, 0xfe, 0xfc, 0xf1, 0xc2, 0x73, 0x63,
- 0xeb, 0x2b, 0xa4, 0x95, 0x6c, 0x90, 0xc4, 0x49, 0xbb, 0x91, 0xc2, 0xb0, 0xe2, 0x86, 0x6e, 0xc2,
- 0x48, 0xe2, 0x44, 0x3b, 0x24, 0x11, 0xd3, 0xfd, 0x85, 0x32, 0x7c, 0x31, 0x15, 0x35, 0x12, 0xb4,
- 0x48, 0xaa, 0x18, 0x37, 0x19, 0x13, 0x2c, 0x98, 0xd9, 0x2d, 0x98, 0x58, 0x71, 0xda, 0xce, 0x96,
- 0xe7, 0x7b, 0x89, 0x47, 0x62, 0xf4, 0x31, 0xa8, 0x3a, 0xae, 0xcb, 0x04, 0xbf, 0xb6, 0x7c, 0xfa,
- 0xe8, 0x70, 0xbe, 0xba, 0xe4, 0xba, 0xf7, 0x0f, 0xe7, 0x41, 0x51, 0x1d, 0x60, 0x4a, 0x81, 0x9e,
- 0x83, 0x21, 0x37, 0x0a, 0xdb, 0xb3, 0x15, 0x46, 0x79, 0x86, 0xce, 0xd0, 0x7a, 0x14, 0xb6, 0x33,
- 0xa4, 0x8c, 0xc6, 0xfe, 0xbd, 0x0a, 0xa0, 0x15, 0xd2, 0xde, 0x5d, 0x6b, 0x1a, 0xdf, 0xf2, 0x3c,
- 0x8c, 0xed, 0x85, 0x81, 0x97, 0x84, 0x51, 0x2c, 0x2a, 0x64, 0xf2, 0xb0, 0x21, 0x60, 0x58, 0x61,
- 0xd1, 0x39, 0x18, 0x6a, 0xa7, 0xd3, 0x7a, 0x42, 0xaa, 0x04, 0x36, 0xa1, 0x19, 0x86, 0x52, 0x74,
- 0x62, 0x12, 0x09, 0x39, 0x56, 0x14, 0x37, 0x63, 0x12, 0x61, 0x86, 0x49, 0x25, 0x87, 0xca, 0x94,
- 0x90, 0xd2, 0x8c, 0xe4, 0x50, 0x0c, 0xd6, 0xa8, 0xd0, 0x97, 0xa0, 0xc6, 0xff, 0x61, 0xb2, 0xcd,
- 0x44, 0xb6, 0x50, 0x19, 0x5c, 0x0b, 0x5b, 0x8e, 0x9f, 0x1d, 0xfc, 0x49, 0x26, 0x69, 0x92, 0x11,
- 0x4e, 0x79, 0x1a, 0x92, 0x36, 0x52, 0x28, 0x69, 0x7f, 0xd7, 0x02, 0xb4, 0xe2, 0x05, 0x2e, 0x89,
- 0x1e, 0xc1, 0x92, 0xd9, 0xdf, 0x24, 0xf8, 0x13, 0xda, 0xb4, 0x70, 0xaf, 0x1d, 0x06, 0x24, 0x48,
- 0x56, 0xc2, 0xc0, 0xe5, 0xcb, 0xe8, 0xa7, 0x60, 0x28, 0xa1, 0x55, 0xf1, 0x66, 0x3d, 0x23, 0x3f,
- 0x0b, 0xad, 0xe0, 0xfe, 0xe1, 0xfc, 0x99, 0xee, 0x12, 0xac, 0x09, 0xac, 0x0c, 0xfa, 0x24, 0x8c,
- 0xc4, 0x89, 0x93, 0x74, 0x62, 0xd1, 0xd0, 0x8f, 0xc8, 0x86, 0x36, 0x19, 0xf4, 0xfe, 0xe1, 0xfc,
- 0xb4, 0x2a, 0xc6, 0x41, 0x58, 0x14, 0x40, 0xcf, 0xc2, 0xe8, 0x1e, 0x89, 0x63, 0x67, 0x47, 0x2a,
- 0xb6, 0x69, 0x51, 0x76, 0x74, 0x83, 0x83, 0xb1, 0xc4, 0xa3, 0xa7, 0x60, 0x98, 0x44, 0x51, 0x18,
- 0x09, 0x89, 0x98, 0x14, 0x84, 0xc3, 0xab, 0x14, 0x88, 0x39, 0xce, 0xfe, 0x99, 0x05, 0xd3, 0xaa,
- 0xad, 0xbc, 0xae, 0x01, 0x4e, 0x75, 0x17, 0xa0, 0x25, 0x3b, 0x16, 0xb3, 0x09, 0x36, 0x7e, 0xe9,
- 0xe3, 0xc7, 0xf3, 0xee, 0x1e, 0xc8, 0xb4, 0x0e, 0x05, 0x8a, 0xb1, 0xc6, 0xd7, 0xfe, 0x3d, 0x0b,
- 0x4e, 0x66, 0xfa, 0x74, 0xcd, 0x8b, 0x13, 0xf4, 0xf9, 0xae, 0x7e, 0x5d, 0xe8, 0x5d, 0x77, 0xbc,
- 0x40, 0x69, 0x99, 0xe0, 0x7b, 0x31, 0xef, 0x9b, 0x92, 0x12, 0x09, 0xd1, 0x7a, 0x86, 0x61, 0xd8,
- 0x4b, 0xc8, 0x9e, 0xec, 0xd4, 0x0b, 0x25, 0x3b, 0xc5, 0x5b, 0x97, 0x7e, 0x9b, 0x75, 0xca, 0x03,
- 0x73, 0x56, 0xf6, 0xff, 0xb2, 0xa0, 0xb6, 0x12, 0x06, 0xdb, 0xde, 0xce, 0x86, 0xd3, 0x1e, 0xe0,
- 0x57, 0x69, 0xc2, 0x10, 0xe3, 0xca, 0x9b, 0x7e, 0xb1, 0xa8, 0xe9, 0xa2, 0x41, 0x0b, 0x74, 0xe5,
- 0xe4, 0x26, 0x81, 0x52, 0x4a, 0x14, 0x84, 0x19, 0xb3, 0xb9, 0x57, 0xa0, 0xa6, 0x08, 0xd0, 0x0c,
- 0x54, 0xef, 0x10, 0x6e, 0x2f, 0xd6, 0x30, 0xfd, 0x89, 0x4e, 0xc1, 0xf0, 0xbe, 0xe3, 0x77, 0xc4,
- 0x54, 0xc5, 0xfc, 0xcf, 0xa7, 0x2a, 0xaf, 0x5a, 0xf6, 0x8f, 0x2d, 0x38, 0xa5, 0x2a, 0xb9, 0x4a,
- 0x0e, 0x9a, 0xc4, 0x27, 0xad, 0x24, 0x8c, 0xd0, 0xbb, 0x16, 0x9c, 0xf2, 0x73, 0x94, 0x90, 0x18,
- 0x8d, 0x07, 0x51, 0x5f, 0x4f, 0x88, 0x86, 0x9f, 0xca, 0xc3, 0xe2, 0xdc, 0xda, 0xd0, 0x93, 0xbc,
- 0x2f, 0x7c, 0xe6, 0x8e, 0x0b, 0x06, 0xd5, 0xab, 0xe4, 0x80, 0x75, 0xcc, 0xfe, 0x91, 0x05, 0x93,
- 0xaa, 0xf9, 0x03, 0x17, 0xbb, 0x6b, 0xa6, 0xd8, 0x7d, 0xac, 0xe4, 0xb7, 0xeb, 0x21, 0x70, 0xff,
- 0xb0, 0x02, 0xa7, 0x15, 0x8d, 0xa1, 0x88, 0x3f, 0x20, 0x63, 0xdf, 0x5f, 0x77, 0xaf, 0x92, 0x83,
- 0xcd, 0x90, 0xae, 0xa4, 0xf9, 0xdd, 0x45, 0x17, 0x61, 0xdc, 0x25, 0xdb, 0x4e, 0xc7, 0x4f, 0x94,
- 0xa1, 0x38, 0xcc, 0x77, 0x10, 0xf5, 0x14, 0x8c, 0x75, 0x1a, 0xfb, 0x0f, 0x6a, 0x6c, 0x4a, 0x26,
- 0x8e, 0x17, 0x90, 0x88, 0x2e, 0xcd, 0x9a, 0x3d, 0x3f, 0xa1, 0xdb, 0xf3, 0xc2, 0x76, 0x7f, 0x0a,
- 0x86, 0xbd, 0x3d, 0xaa, 0xac, 0x2b, 0xa6, 0x0e, 0x5e, 0xa7, 0x40, 0xcc, 0x71, 0xe8, 0x69, 0x18,
- 0x6d, 0x85, 0x7b, 0x7b, 0x4e, 0xe0, 0xce, 0x56, 0x99, 0xb1, 0x30, 0x4e, 0xf5, 0xf9, 0x0a, 0x07,
- 0x61, 0x89, 0x43, 0x4f, 0xc0, 0x90, 0x13, 0xed, 0xc4, 0xb3, 0x43, 0x8c, 0x66, 0x8c, 0xd6, 0xb4,
- 0x14, 0xed, 0xc4, 0x98, 0x41, 0xa9, 0x11, 0x70, 0x37, 0x8c, 0xee, 0x78, 0xc1, 0x4e, 0xdd, 0x8b,
- 0xd8, 0x8a, 0xae, 0x19, 0x01, 0xb7, 0x15, 0x06, 0x6b, 0x54, 0xa8, 0x01, 0xc3, 0xed, 0x30, 0x4a,
- 0xe2, 0xd9, 0x11, 0x36, 0x9c, 0xcf, 0x17, 0x4a, 0x0f, 0xef, 0x77, 0x23, 0x8c, 0x92, 0xb4, 0x2b,
- 0xf4, 0x5f, 0x8c, 0x39, 0x23, 0xb4, 0x02, 0x55, 0x12, 0xec, 0xcf, 0x8e, 0x32, 0x7e, 0x1f, 0x3d,
- 0x9e, 0xdf, 0x6a, 0xb0, 0x7f, 0xcb, 0x89, 0xd2, 0x29, 0xb4, 0x1a, 0xec, 0x63, 0x5a, 0x1a, 0xb5,
- 0xa0, 0x26, 0xbd, 0x06, 0xf1, 0xec, 0x58, 0x19, 0x01, 0xc3, 0x82, 0x1c, 0x93, 0x77, 0x3a, 0x5e,
- 0x44, 0xf6, 0x48, 0x90, 0xc4, 0xa9, 0x25, 0x2c, 0xb1, 0x31, 0x4e, 0xf9, 0xa2, 0x16, 0x4c, 0x70,
- 0xc3, 0x61, 0x23, 0xec, 0x04, 0x49, 0x3c, 0x5b, 0x63, 0x4d, 0x2e, 0xd8, 0x6a, 0xde, 0x4a, 0x4b,
- 0x2c, 0x9f, 0x12, 0xec, 0x27, 0x34, 0x60, 0x8c, 0x0d, 0xa6, 0xe8, 0x6d, 0x98, 0xf4, 0xbd, 0x7d,
- 0x12, 0x90, 0x38, 0x6e, 0x44, 0xe1, 0x16, 0x99, 0x05, 0xd6, 0x9b, 0xa7, 0x8a, 0xb6, 0x5d, 0xe1,
- 0x16, 0x59, 0x3e, 0x71, 0x74, 0x38, 0x3f, 0x79, 0x4d, 0x2f, 0x8d, 0x4d, 0x66, 0xe8, 0x4b, 0x30,
- 0x45, 0xad, 0x14, 0x2f, 0x65, 0x3f, 0x5e, 0x9e, 0x3d, 0x3a, 0x3a, 0x9c, 0x9f, 0xc2, 0x46, 0x71,
- 0x9c, 0x61, 0x87, 0x36, 0xa1, 0xe6, 0x7b, 0xdb, 0xa4, 0x75, 0xd0, 0xf2, 0xc9, 0xec, 0x04, 0xe3,
- 0x5d, 0x30, 0xe5, 0xae, 0x49, 0x72, 0x6e, 0x19, 0xaa, 0xbf, 0x38, 0x65, 0x84, 0x6e, 0xc1, 0x99,
- 0x84, 0x44, 0x7b, 0x5e, 0xe0, 0xd0, 0xe5, 0x5a, 0x98, 0x2d, 0x6c, 0x6f, 0x3b, 0xc9, 0xa4, 0xf6,
- 0xac, 0x18, 0xd8, 0x33, 0x9b, 0xb9, 0x54, 0xb8, 0x47, 0x69, 0x74, 0x03, 0xa6, 0xd9, 0x7c, 0x6a,
- 0x74, 0x7c, 0xbf, 0x11, 0xfa, 0x5e, 0xeb, 0x60, 0x76, 0x8a, 0x31, 0x7c, 0x5a, 0xee, 0x58, 0xd7,
- 0x4d, 0x34, 0xb5, 0xe8, 0xd3, 0x7f, 0x38, 0x5b, 0x1a, 0xf9, 0x30, 0x1d, 0x93, 0x56, 0x27, 0xf2,
- 0x92, 0x03, 0x2a, 0xfb, 0xe4, 0x5e, 0x32, 0x3b, 0x5d, 0x66, 0x87, 0xd2, 0x34, 0x0b, 0x71, 0x77,
- 0x41, 0x06, 0x88, 0xb3, 0xac, 0xa9, 0xaa, 0x88, 0x13, 0xd7, 0x0b, 0x66, 0x67, 0x98, 0x49, 0xaa,
- 0xe6, 0x57, 0x93, 0x02, 0x31, 0xc7, 0xb1, 0x0d, 0x1f, 0xfd, 0x71, 0x83, 0xea, 0xde, 0x13, 0x8c,
- 0x30, 0xdd, 0xf0, 0x49, 0x04, 0x4e, 0x69, 0xe8, 0x6a, 0x95, 0x24, 0x07, 0xb3, 0x88, 0x91, 0xaa,
- 0xa9, 0xb6, 0xb9, 0xf9, 0x39, 0x4c, 0xe1, 0xf6, 0x16, 0x4c, 0xa9, 0x69, 0xcd, 0x46, 0x07, 0xcd,
- 0xc3, 0x30, 0xd5, 0x5c, 0x72, 0xdf, 0x52, 0xa3, 0x4d, 0xa0, 0x0a, 0x2d, 0xc6, 0x1c, 0xce, 0x9a,
- 0xe0, 0x7d, 0x95, 0x2c, 0x1f, 0x24, 0x84, 0xdb, 0xaf, 0x55, 0xad, 0x09, 0x12, 0x81, 0x53, 0x1a,
- 0xfb, 0xff, 0xf0, 0x15, 0x31, 0xd5, 0x1d, 0x25, 0xf4, 0xe6, 0x05, 0x18, 0xdb, 0x0d, 0xe3, 0x84,
- 0x52, 0xb3, 0x3a, 0x86, 0xd3, 0x55, 0xf0, 0x8a, 0x80, 0x63, 0x45, 0x81, 0x5e, 0x83, 0xc9, 0x96,
- 0x5e, 0x81, 0x50, 0xe5, 0xa7, 0x45, 0x11, 0xb3, 0x76, 0x6c, 0xd2, 0xa2, 0x57, 0x61, 0x8c, 0x39,
- 0xf1, 0x5a, 0xa1, 0x2f, 0x2c, 0x65, 0xb9, 0x32, 0x8d, 0x35, 0x04, 0xfc, 0xbe, 0xf6, 0x1b, 0x2b,
- 0x6a, 0xba, 0xdf, 0xa0, 0x4d, 0x58, 0x6f, 0x08, 0x75, 0xab, 0xf6, 0x1b, 0x57, 0x18, 0x14, 0x0b,
- 0xac, 0xfd, 0x2f, 0x2a, 0xda, 0x28, 0x53, 0x8b, 0x8f, 0xa0, 0xcf, 0xc3, 0xe8, 0x5d, 0xc7, 0x4b,
- 0xbc, 0x60, 0x47, 0xac, 0xa0, 0x2f, 0x96, 0xd4, 0xbd, 0xac, 0xf8, 0x6d, 0x5e, 0x94, 0xaf, 0x13,
- 0xe2, 0x0f, 0x96, 0x0c, 0x29, 0xef, 0xa8, 0x13, 0x04, 0x94, 0x77, 0xa5, 0x7f, 0xde, 0x98, 0x17,
- 0xe5, 0xbc, 0xc5, 0x1f, 0x2c, 0x19, 0xa2, 0x6d, 0x00, 0x39, 0xfb, 0x88, 0x2b, 0x9c, 0x67, 0x9f,
- 0xe8, 0x87, 0xfd, 0xa6, 0x2a, 0xbd, 0x3c, 0x45, 0x57, 0xa6, 0xf4, 0x3f, 0xd6, 0x38, 0xdb, 0x11,
- 0x33, 0x44, 0xba, 0x9b, 0x85, 0x3e, 0x47, 0x27, 0x80, 0x13, 0x25, 0xc4, 0x5d, 0x4a, 0x8a, 0xcd,
- 0xe0, 0xd4, 0x9a, 0xda, 0xf4, 0xf6, 0x88, 0x3e, 0x55, 0x04, 0x0b, 0x9c, 0x72, 0xb3, 0xbf, 0x5f,
- 0x85, 0xd9, 0x5e, 0x8d, 0xa5, 0x02, 0x49, 0xee, 0x79, 0xc9, 0x0a, 0x35, 0x14, 0x2c, 0x53, 0x20,
- 0x57, 0x05, 0x1c, 0x2b, 0x0a, 0x2a, 0x19, 0xb1, 0xb7, 0x13, 0x38, 0xbe, 0x10, 0x5e, 0x25, 0x19,
- 0x4d, 0x06, 0xc5, 0x02, 0x4b, 0xe9, 0x22, 0xe2, 0xc4, 0xc2, 0x73, 0xab, 0x49, 0x10, 0x66, 0x50,
- 0x2c, 0xb0, 0xfa, 0xae, 0x6f, 0xa8, 0x60, 0xd7, 0x67, 0x0c, 0xd0, 0xf0, 0xc3, 0x1c, 0x20, 0xf4,
- 0x36, 0xc0, 0xb6, 0x17, 0x78, 0xf1, 0x2e, 0xe3, 0x3d, 0xd2, 0x27, 0x6f, 0x65, 0x8c, 0xac, 0x29,
- 0x1e, 0x58, 0xe3, 0x87, 0x5e, 0x86, 0x71, 0x35, 0x31, 0xd7, 0xeb, 0xb3, 0xa3, 0xa6, 0xa7, 0x2f,
- 0xd5, 0x52, 0x75, 0xac, 0xd3, 0xd9, 0x5f, 0xc9, 0x4a, 0x8a, 0x98, 0x0f, 0xda, 0xd8, 0x5a, 0x65,
- 0xc7, 0xb6, 0x72, 0xfc, 0xd8, 0xda, 0xff, 0xa5, 0x4a, 0x37, 0xcb, 0x5a, 0x65, 0x9d, 0xb8, 0x84,
- 0x2e, 0x7b, 0x93, 0x2a, 0x76, 0x27, 0x21, 0x62, 0x36, 0x5e, 0xe8, 0x67, 0xba, 0xe8, 0xcb, 0x00,
- 0x9d, 0x05, 0x9c, 0x13, 0xda, 0x85, 0x9a, 0xef, 0xc4, 0x6c, 0xf7, 0x48, 0xc4, 0x2c, 0xec, 0x8f,
- 0x6d, 0x6a, 0x7c, 0x3b, 0x71, 0xa2, 0xad, 0xb3, 0xbc, 0x96, 0x94, 0x39, 0x5d, 0x95, 0xa8, 0x51,
- 0x20, 0x8f, 0x0a, 0x54, 0x73, 0xa8, 0xe5, 0x70, 0x80, 0x39, 0x0e, 0xbd, 0x0a, 0x13, 0x11, 0x61,
- 0x72, 0xb2, 0x42, 0xed, 0x1e, 0x26, 0x76, 0xc3, 0xa9, 0x81, 0x84, 0x35, 0x1c, 0x36, 0x28, 0x53,
- 0xfb, 0x78, 0xe4, 0x18, 0xfb, 0xf8, 0x59, 0x18, 0x65, 0x3f, 0x94, 0x54, 0xa8, 0x2f, 0xb4, 0xce,
- 0xc1, 0x58, 0xe2, 0xb3, 0x42, 0x34, 0x56, 0x52, 0x88, 0x9e, 0x83, 0xa9, 0xba, 0x43, 0xf6, 0xc2,
- 0x60, 0x35, 0x70, 0xdb, 0xa1, 0x17, 0x24, 0x68, 0x16, 0x86, 0xd8, 0x4a, 0xc2, 0xe7, 0xfa, 0x10,
- 0xe5, 0x80, 0x87, 0xa8, 0x8d, 0x6b, 0xff, 0x5f, 0x0b, 0x26, 0xeb, 0xc4, 0x27, 0x09, 0xb9, 0xd1,
- 0x66, 0xfe, 0x06, 0xb4, 0x06, 0x68, 0x27, 0x72, 0x5a, 0xa4, 0x41, 0x22, 0x2f, 0x74, 0x9b, 0xa4,
- 0x15, 0x06, 0xcc, 0xc3, 0x4e, 0x97, 0xc6, 0x33, 0x47, 0x87, 0xf3, 0xe8, 0x72, 0x17, 0x16, 0xe7,
- 0x94, 0x40, 0x2e, 0x4c, 0xb6, 0x23, 0x62, 0x38, 0x48, 0xac, 0x62, 0xb3, 0xbc, 0xa1, 0x17, 0xe1,
- 0x56, 0xa3, 0x01, 0xc2, 0x26, 0x53, 0xf4, 0x19, 0x98, 0x09, 0xa3, 0xf6, 0xae, 0x13, 0xd4, 0x49,
- 0x9b, 0x04, 0x2e, 0x35, 0x95, 0x85, 0x17, 0xec, 0xd4, 0xd1, 0xe1, 0xfc, 0xcc, 0x8d, 0x0c, 0x0e,
- 0x77, 0x51, 0xdb, 0xbf, 0x5e, 0x81, 0xd3, 0xf5, 0xf0, 0x6e, 0x70, 0xd7, 0x89, 0xdc, 0xa5, 0xc6,
- 0x3a, 0xb7, 0x7f, 0x99, 0x57, 0x51, 0x7a, 0x33, 0xad, 0x9e, 0xde, 0xcc, 0x2f, 0xc0, 0xd8, 0xb6,
- 0x47, 0x7c, 0x17, 0x93, 0x6d, 0xd1, 0xbd, 0x8b, 0x65, 0xbc, 0x18, 0x6b, 0xb4, 0x8c, 0xf4, 0x04,
- 0x70, 0x67, 0xea, 0x9a, 0x60, 0x83, 0x15, 0x43, 0xd4, 0x81, 0x19, 0x69, 0xe0, 0x4b, 0xac, 0x98,
- 0x1d, 0x2f, 0x96, 0xdb, 0x3f, 0x98, 0xd5, 0xb0, 0xf1, 0xc0, 0x19, 0x86, 0xb8, 0xab, 0x0a, 0xba,
- 0x31, 0xdb, 0xa3, 0xeb, 0xc2, 0x10, 0x93, 0x15, 0xb6, 0x31, 0x63, 0x3b, 0x47, 0x06, 0xb5, 0xff,
- 0xa9, 0x05, 0x8f, 0x75, 0x8d, 0x96, 0xd8, 0x56, 0xbf, 0x25, 0xf7, 0xb3, 0xfc, 0x38, 0xa6, 0xa0,
- 0x95, 0xb9, 0x63, 0x5e, 0x6e, 0x6f, 0x5b, 0x29, 0xb1, 0xb7, 0xbd, 0x01, 0xa7, 0x56, 0xf7, 0xda,
- 0xc9, 0x41, 0xdd, 0x33, 0x9d, 0xb0, 0xaf, 0xc0, 0xc8, 0x1e, 0x71, 0xbd, 0xce, 0x9e, 0xf8, 0xac,
- 0xf3, 0x52, 0x91, 0x6e, 0x30, 0xe8, 0xfd, 0xc3, 0xf9, 0xc9, 0x66, 0x12, 0x46, 0xce, 0x0e, 0xe1,
- 0x00, 0x2c, 0xc8, 0xed, 0xf7, 0x2c, 0x98, 0x96, 0x13, 0x6a, 0xc9, 0x75, 0x23, 0x12, 0xc7, 0x68,
- 0x0e, 0x2a, 0x5e, 0x5b, 0x30, 0x02, 0xc1, 0xa8, 0xb2, 0xde, 0xc0, 0x15, 0xaf, 0x8d, 0x3e, 0x0f,
- 0x35, 0xee, 0xbb, 0x4f, 0x85, 0xa3, 0xcf, 0xb3, 0x00, 0xb6, 0xe9, 0xd8, 0x94, 0x3c, 0x70, 0xca,
- 0x4e, 0x1a, 0x94, 0x4c, 0x55, 0x57, 0x4d, 0x4f, 0xf2, 0x15, 0x01, 0xc7, 0x8a, 0x02, 0x9d, 0x87,
- 0xb1, 0x20, 0x74, 0xf9, 0xb1, 0x0a, 0x5f, 0x70, 0x99, 0xc8, 0x5d, 0x17, 0x30, 0xac, 0xb0, 0xf6,
- 0x37, 0x2d, 0x98, 0x90, 0x7d, 0x2c, 0x69, 0xdb, 0xd2, 0x49, 0x92, 0xda, 0xb5, 0xe9, 0x24, 0xa1,
- 0xb6, 0x29, 0xc3, 0x18, 0x26, 0x69, 0xb5, 0x1f, 0x93, 0xd4, 0xfe, 0x51, 0x05, 0xa6, 0x64, 0x73,
- 0x9a, 0x9d, 0xad, 0x98, 0x24, 0xe8, 0x8b, 0x50, 0x73, 0xf8, 0xe0, 0x13, 0x29, 0x67, 0x2f, 0x14,
- 0x6d, 0xcc, 0x8d, 0x6f, 0x96, 0x5a, 0x05, 0x4b, 0x92, 0x0f, 0x4e, 0x59, 0xa2, 0x7d, 0x38, 0x11,
- 0x84, 0x09, 0x5b, 0x0f, 0x14, 0xbe, 0x9c, 0x17, 0x34, 0x5b, 0xcf, 0xe3, 0xa2, 0x9e, 0x13, 0xd7,
- 0xb3, 0xfc, 0x70, 0x77, 0x15, 0xe8, 0x86, 0x74, 0x5e, 0x54, 0x59, 0x5d, 0xcf, 0x95, 0xab, 0xab,
- 0xb7, 0xef, 0xc2, 0xfe, 0x1d, 0x0b, 0x6a, 0x92, 0x6c, 0x90, 0x4e, 0xf0, 0xdb, 0x30, 0x1a, 0xb3,
- 0x4f, 0x23, 0x87, 0xe9, 0x42, 0xb9, 0xa6, 0xf3, 0xef, 0x99, 0x2e, 0x7e, 0xfc, 0x7f, 0x8c, 0x25,
- 0x37, 0xe6, 0x7a, 0x54, 0x1d, 0xf8, 0x80, 0xb9, 0x1e, 0x55, 0xbb, 0x7a, 0xb8, 0x1e, 0x7f, 0xcd,
- 0x82, 0x11, 0xee, 0x10, 0x2a, 0xe7, 0x55, 0xd3, 0x9c, 0xc7, 0x29, 0xc7, 0x5b, 0x14, 0x28, 0x7c,
- 0xc9, 0xe8, 0x36, 0xd4, 0xd8, 0x8f, 0xb5, 0x28, 0xdc, 0x13, 0xab, 0xc0, 0x73, 0x65, 0x1c, 0x52,
- 0x5c, 0xeb, 0x71, 0x55, 0x72, 0x4b, 0x32, 0xc0, 0x29, 0x2f, 0xfb, 0xc7, 0x55, 0x3a, 0xe5, 0x53,
- 0x52, 0x63, 0x4d, 0xb3, 0x1e, 0xc5, 0x9a, 0x56, 0x19, 0xfc, 0x9a, 0xf6, 0x0e, 0x4c, 0xb7, 0x34,
- 0x27, 0x7c, 0xba, 0x92, 0x5e, 0x2a, 0xe9, 0x62, 0xd6, 0x3c, 0xf7, 0xdc, 0x01, 0xb2, 0x62, 0xb2,
- 0xc3, 0x59, 0xfe, 0x88, 0xc0, 0x04, 0x3f, 0x3e, 0x14, 0xf5, 0x0d, 0xb1, 0xfa, 0x16, 0x0b, 0x7d,
- 0x2d, 0xbc, 0x84, 0xaa, 0x8c, 0x85, 0x98, 0x34, 0x35, 0x46, 0xd8, 0x60, 0x6b, 0xff, 0xea, 0x30,
- 0x0c, 0xaf, 0xee, 0x93, 0x20, 0x19, 0xe0, 0x14, 0xdf, 0x83, 0x29, 0x2f, 0xd8, 0x0f, 0xfd, 0x7d,
- 0xe2, 0x72, 0xfc, 0x83, 0x2d, 0x67, 0x67, 0x44, 0x25, 0x53, 0xeb, 0x06, 0x33, 0x9c, 0x61, 0x3e,
- 0x88, 0x6d, 0xe4, 0x9b, 0x30, 0xc2, 0x25, 0x42, 0xec, 0x21, 0x0b, 0x1c, 0xa3, 0x6c, 0x40, 0xc5,
- 0xcc, 0x49, 0x37, 0xbb, 0xdc, 0x27, 0x2b, 0x18, 0xa1, 0x5d, 0x98, 0xda, 0xf6, 0xa2, 0x38, 0xa1,
- 0xbb, 0xc1, 0x38, 0x71, 0xf6, 0xda, 0x7d, 0x6f, 0x21, 0xd5, 0x78, 0xac, 0x19, 0x7c, 0x70, 0x86,
- 0x2f, 0x22, 0x30, 0x49, 0x77, 0x30, 0x69, 0x45, 0xa3, 0x7d, 0x56, 0xa4, 0x3c, 0x47, 0xd7, 0x74,
- 0x36, 0xd8, 0xe4, 0x4a, 0xd5, 0x50, 0x8b, 0xed, 0x77, 0xc6, 0xd8, 0x4a, 0xae, 0xd4, 0x10, 0xdf,
- 0xe8, 0x70, 0x1c, 0xd5, 0x66, 0xec, 0x9c, 0xb8, 0x66, 0x6a, 0xb3, 0xf4, 0x34, 0xd8, 0xfe, 0x1e,
- 0x5d, 0x77, 0xe8, 0xf8, 0x0d, 0x5c, 0x65, 0x5f, 0x31, 0x55, 0xf6, 0x53, 0x25, 0xbe, 0x69, 0x0f,
- 0x75, 0xfd, 0x65, 0x18, 0xd7, 0x3e, 0x39, 0x5a, 0x84, 0x5a, 0x4b, 0x1e, 0x69, 0x0a, 0xbd, 0xad,
- 0x8c, 0x06, 0x75, 0xd6, 0x89, 0x53, 0x1a, 0x3a, 0x2a, 0xd4, 0xd8, 0xca, 0x86, 0x3d, 0x50, 0x53,
- 0x0c, 0x33, 0x8c, 0xfd, 0x22, 0xc0, 0xea, 0x3d, 0xd2, 0x5a, 0x6a, 0xb1, 0xd3, 0x76, 0xed, 0x88,
- 0xc4, 0xea, 0x7d, 0x44, 0x42, 0x87, 0x72, 0x6a, 0x6d, 0xc5, 0xb0, 0x5e, 0x17, 0x00, 0xb8, 0x15,
- 0x78, 0xfb, 0xf6, 0x75, 0xe9, 0xd4, 0xe4, 0x9e, 0x27, 0x05, 0xc5, 0x1a, 0x05, 0x7a, 0x1c, 0xaa,
- 0x7e, 0x27, 0x10, 0xc6, 0xd9, 0xe8, 0xd1, 0xe1, 0x7c, 0xf5, 0x5a, 0x27, 0xc0, 0x14, 0xa6, 0xc5,
- 0x17, 0x54, 0x4b, 0xc7, 0x17, 0x14, 0x47, 0xd8, 0x7d, 0xbb, 0x0a, 0x33, 0x6b, 0x3e, 0xb9, 0x67,
- 0xb4, 0xfa, 0x19, 0x18, 0x71, 0x23, 0x6f, 0x9f, 0x44, 0x59, 0xe7, 0x45, 0x9d, 0x41, 0xb1, 0xc0,
- 0x96, 0x0e, 0x79, 0x30, 0xc2, 0x3d, 0xaa, 0x03, 0x0e, 0xf7, 0x28, 0xec, 0x33, 0xda, 0x86, 0xd1,
- 0x90, 0x6f, 0x9e, 0x67, 0x87, 0x99, 0x28, 0xbe, 0x76, 0x7c, 0x63, 0xb2, 0xe3, 0xb3, 0x20, 0xb6,
- 0xde, 0xfc, 0xf8, 0x59, 0x69, 0x31, 0x01, 0xc5, 0x92, 0xf9, 0xdc, 0xa7, 0x60, 0x42, 0xa7, 0xec,
- 0xeb, 0x1c, 0xfa, 0x97, 0x2c, 0x38, 0xb9, 0xe6, 0x87, 0xad, 0x3b, 0x99, 0x98, 0x94, 0x97, 0x61,
- 0x9c, 0x4e, 0xa6, 0xd8, 0x08, 0xd4, 0x32, 0x22, 0xd2, 0x04, 0x0a, 0xeb, 0x74, 0x5a, 0xb1, 0x9b,
- 0x37, 0xd7, 0xeb, 0x79, 0x81, 0x6c, 0x02, 0x85, 0x75, 0x3a, 0xfb, 0x3f, 0x5b, 0xf0, 0xe4, 0xe5,
- 0x95, 0xd5, 0x06, 0x89, 0x62, 0x2f, 0x4e, 0x48, 0x90, 0x74, 0xc5, 0xd2, 0x3d, 0x03, 0x23, 0x6d,
- 0x57, 0x6b, 0x8a, 0x12, 0x81, 0x46, 0x9d, 0xb5, 0x42, 0x60, 0x3f, 0x28, 0x01, 0xa5, 0xbf, 0x66,
- 0xc1, 0xc9, 0xcb, 0x5e, 0x82, 0x49, 0x3b, 0xcc, 0x86, 0xbf, 0x45, 0xa4, 0x1d, 0xc6, 0x5e, 0x12,
- 0x46, 0x07, 0xd9, 0xf0, 0x37, 0xac, 0x30, 0x58, 0xa3, 0xe2, 0x35, 0xef, 0x7b, 0x31, 0x6d, 0x69,
- 0xc5, 0xdc, 0xd4, 0x61, 0x01, 0xc7, 0x8a, 0x82, 0x76, 0xcc, 0xf5, 0x22, 0x66, 0x24, 0x1c, 0x88,
- 0x19, 0xac, 0x3a, 0x56, 0x97, 0x08, 0x9c, 0xd2, 0xd8, 0x7f, 0xdf, 0x82, 0xd3, 0x97, 0xfd, 0x4e,
- 0x9c, 0x90, 0x68, 0x3b, 0x36, 0x1a, 0xfb, 0x22, 0xd4, 0x88, 0x34, 0x68, 0x45, 0x5b, 0xd5, 0x92,
- 0xa1, 0x2c, 0x5d, 0x1e, 0x7b, 0xa7, 0xe8, 0x4a, 0x84, 0x7a, 0xf5, 0x17, 0x98, 0xf4, 0x5b, 0x15,
- 0x98, 0xbc, 0xb2, 0xb9, 0xd9, 0xb8, 0x4c, 0x12, 0xa1, 0x25, 0x8b, 0xdd, 0x2f, 0x0d, 0x6d, 0xef,
- 0x39, 0x7e, 0x69, 0xa1, 0xc7, 0xac, 0xeb, 0x24, 0x9e, 0xbf, 0xc0, 0x43, 0x9d, 0x17, 0xd6, 0x83,
- 0xe4, 0x46, 0xd4, 0x4c, 0x22, 0x2f, 0xd8, 0xc9, 0xdd, 0xab, 0x4a, 0x4d, 0x5e, 0xed, 0xa5, 0xc9,
- 0xd1, 0x8b, 0x30, 0xc2, 0x22, 0xad, 0xa5, 0xd1, 0xf1, 0x61, 0x65, 0x1f, 0x30, 0xe8, 0xfd, 0xc3,
- 0xf9, 0xda, 0x4d, 0xbc, 0xce, 0xff, 0x60, 0x41, 0x8a, 0xbe, 0x04, 0xe3, 0xbb, 0x49, 0xd2, 0xbe,
- 0x42, 0x1c, 0x97, 0x44, 0x52, 0x4b, 0x14, 0x98, 0x67, 0x74, 0x30, 0x78, 0x81, 0x74, 0x62, 0xa5,
- 0xb0, 0x18, 0xeb, 0x1c, 0xed, 0x26, 0x40, 0x8a, 0x7b, 0x48, 0x7b, 0x0e, 0xfb, 0xaf, 0x55, 0x60,
- 0xf4, 0x8a, 0x13, 0xb8, 0x3e, 0x89, 0xd0, 0x1a, 0x0c, 0x91, 0x7b, 0xa4, 0x55, 0xce, 0xb2, 0x4c,
- 0x97, 0x3a, 0xee, 0x3f, 0xa2, 0xff, 0x31, 0x2b, 0x8f, 0x30, 0x8c, 0xd2, 0x76, 0x5f, 0x56, 0xf1,
- 0x91, 0xcf, 0x17, 0x8f, 0x82, 0x12, 0x09, 0xbe, 0x4e, 0x0a, 0x10, 0x96, 0x8c, 0x98, 0xa7, 0xa5,
- 0xd5, 0x6e, 0x52, 0xe5, 0x96, 0x94, 0x0b, 0x81, 0xde, 0x5c, 0x69, 0x70, 0x72, 0xc1, 0x97, 0x7b,
- 0x5a, 0x24, 0x10, 0xa7, 0xec, 0xec, 0x57, 0xe1, 0x14, 0x3b, 0xa2, 0x73, 0x92, 0x5d, 0x63, 0xce,
- 0x14, 0x0a, 0xa7, 0xfd, 0x8f, 0x2a, 0x70, 0x62, 0xbd, 0xb9, 0xd2, 0x34, 0x7d, 0x64, 0xaf, 0xc2,
- 0x04, 0x5f, 0x9e, 0xa9, 0xd0, 0x39, 0xbe, 0x28, 0xaf, 0x9c, 0xcb, 0x9b, 0x1a, 0x0e, 0x1b, 0x94,
- 0xe8, 0x49, 0xa8, 0x7a, 0xef, 0x04, 0xd9, 0x48, 0x9d, 0xf5, 0x37, 0xaf, 0x63, 0x0a, 0xa7, 0x68,
- 0xba, 0xd2, 0x73, 0x15, 0xa7, 0xd0, 0x6a, 0xb5, 0x7f, 0x03, 0xa6, 0xbc, 0xb8, 0x15, 0x7b, 0xeb,
- 0x01, 0x9d, 0xff, 0x4e, 0x4b, 0x8a, 0x6f, 0x6a, 0x94, 0xd3, 0xa6, 0x2a, 0x2c, 0xce, 0x50, 0x6b,
- 0xfa, 0x76, 0xb8, 0xb4, 0xb5, 0x50, 0x1c, 0x28, 0xf9, 0x15, 0xa8, 0xa9, 0xb0, 0x16, 0x19, 0x8a,
- 0x64, 0xe5, 0x87, 0x22, 0x95, 0x50, 0x38, 0xd2, 0x73, 0x59, 0xcd, 0xf5, 0x5c, 0xfe, 0x86, 0x05,
- 0xe9, 0x09, 0x3e, 0xc2, 0x50, 0x6b, 0x87, 0xec, 0x58, 0x20, 0x92, 0x27, 0x6f, 0x4f, 0x17, 0x48,
- 0x22, 0x9f, 0x09, 0x5c, 0x56, 0x1a, 0xb2, 0x2c, 0x4e, 0xd9, 0xa0, 0x6b, 0x30, 0xda, 0x8e, 0x48,
- 0x33, 0x61, 0xd1, 0xb6, 0x7d, 0x70, 0x64, 0x52, 0xdd, 0xe0, 0x25, 0xb1, 0x64, 0x61, 0xff, 0x6b,
- 0x0b, 0xe0, 0x9a, 0xb7, 0xe7, 0x25, 0xd8, 0x09, 0x76, 0xc8, 0x00, 0xb7, 0x77, 0xd7, 0x61, 0x28,
- 0x6e, 0x93, 0x56, 0xb9, 0x03, 0x9d, 0xb4, 0x45, 0xcd, 0x36, 0x69, 0xa5, 0x9f, 0x81, 0xfe, 0xc3,
- 0x8c, 0x8f, 0xfd, 0x9b, 0x00, 0x53, 0x29, 0x19, 0x35, 0xb4, 0xd1, 0x0b, 0x46, 0x78, 0xe9, 0xe3,
- 0x99, 0xf0, 0xd2, 0x1a, 0xa3, 0xd6, 0x22, 0x4a, 0x13, 0xa8, 0xee, 0x39, 0xf7, 0x84, 0x5d, 0xff,
- 0x72, 0xd9, 0x06, 0xd1, 0x9a, 0x16, 0x36, 0x9c, 0x7b, 0xdc, 0x8c, 0x7a, 0x5e, 0x0a, 0xd0, 0x86,
- 0x73, 0xef, 0x3e, 0x3f, 0xb6, 0x61, 0x33, 0x90, 0x6e, 0x24, 0xbe, 0xfe, 0x5f, 0xd3, 0xff, 0x4c,
- 0x29, 0xd2, 0xea, 0x58, 0xad, 0x5e, 0x20, 0x1c, 0x70, 0x7d, 0xd6, 0xea, 0x05, 0xd9, 0x5a, 0xbd,
- 0xa0, 0x44, 0xad, 0x5e, 0x80, 0xde, 0xb5, 0x60, 0x54, 0xf8, 0xad, 0x59, 0x2c, 0xd4, 0xf8, 0xa5,
- 0x4f, 0xf6, 0x55, 0xb5, 0x70, 0x80, 0xf3, 0xea, 0x17, 0xa5, 0xed, 0x28, 0xa0, 0x85, 0x4d, 0x90,
- 0x55, 0xa3, 0xef, 0x58, 0x30, 0x25, 0x7e, 0x63, 0xf2, 0x4e, 0x87, 0xc4, 0x89, 0x58, 0xa5, 0x3e,
- 0xf3, 0x20, 0xad, 0x11, 0x2c, 0x78, 0xa3, 0x3e, 0x21, 0x55, 0x8c, 0x89, 0x2c, 0x6c, 0x5b, 0xa6,
- 0x3d, 0xe8, 0x87, 0x16, 0x9c, 0xda, 0x73, 0xee, 0xf1, 0x1a, 0x39, 0x0c, 0x3b, 0x89, 0x17, 0x8a,
- 0x78, 0xaf, 0xb5, 0x7e, 0xe5, 0xa4, 0x8b, 0x11, 0x6f, 0xee, 0xeb, 0xf2, 0x30, 0x31, 0x8f, 0xa4,
- 0xb0, 0xd1, 0xb9, 0x2d, 0x9c, 0x73, 0x61, 0x4c, 0x0a, 0x66, 0x8e, 0xd5, 0xbe, 0xac, 0x2f, 0xc6,
- 0xc7, 0xcf, 0x40, 0xe9, 0xd9, 0x5a, 0x78, 0xb3, 0xe3, 0x04, 0x89, 0x97, 0x1c, 0x68, 0x36, 0x3e,
- 0xab, 0x45, 0x08, 0xe2, 0x00, 0x6b, 0xd9, 0x85, 0x09, 0x5d, 0xe6, 0x06, 0x58, 0x53, 0x08, 0x27,
- 0x73, 0xe4, 0x69, 0x80, 0x15, 0x76, 0xe0, 0xf1, 0x9e, 0x72, 0x31, 0xb8, 0x6a, 0xed, 0xdf, 0xb2,
- 0x74, 0x85, 0x39, 0x70, 0xbf, 0xc9, 0x86, 0xe9, 0x37, 0x39, 0x5f, 0x76, 0xde, 0xf4, 0x70, 0x9e,
- 0x6c, 0xeb, 0x8d, 0xa7, 0xcb, 0x00, 0xda, 0x84, 0x11, 0x9f, 0x42, 0xe4, 0x01, 0xcd, 0x85, 0x7e,
- 0x66, 0x66, 0x6a, 0x59, 0x30, 0x78, 0x8c, 0x05, 0x2f, 0xfb, 0x07, 0x16, 0x0c, 0x0d, 0x7c, 0x6c,
- 0x1a, 0xe6, 0xd8, 0xf4, 0x32, 0x4e, 0xc5, 0x9d, 0xcb, 0x05, 0xec, 0xdc, 0x5d, 0xbd, 0x97, 0x90,
- 0x20, 0x66, 0x46, 0x64, 0xee, 0xf0, 0xfc, 0x7a, 0x05, 0xc6, 0x69, 0x45, 0xf2, 0x78, 0xfd, 0x35,
- 0x98, 0xf4, 0x9d, 0x2d, 0xe2, 0x4b, 0x0f, 0x6f, 0x76, 0xc3, 0x75, 0x4d, 0x47, 0x62, 0x93, 0x96,
- 0x16, 0xde, 0xd6, 0x1d, 0xe0, 0xc2, 0x18, 0x52, 0x85, 0x0d, 0xef, 0x38, 0x36, 0x69, 0xa9, 0xcd,
- 0x7f, 0xd7, 0x49, 0x5a, 0xbb, 0x62, 0x33, 0xa6, 0x9a, 0x7b, 0x9b, 0x02, 0x31, 0xc7, 0xa1, 0x25,
- 0x98, 0x96, 0xb2, 0x7a, 0x8b, 0xee, 0xd2, 0xc3, 0x40, 0x18, 0x8a, 0xea, 0xa2, 0x1c, 0x36, 0xd1,
- 0x38, 0x4b, 0x8f, 0x3e, 0x05, 0x53, 0x74, 0x70, 0xc2, 0x4e, 0x22, 0x83, 0x07, 0x86, 0x59, 0xf0,
- 0x00, 0x8b, 0xd1, 0xdc, 0x34, 0x30, 0x38, 0x43, 0x69, 0x7f, 0x09, 0x4e, 0x5e, 0x0b, 0x1d, 0x77,
- 0xd9, 0xf1, 0x9d, 0xa0, 0x45, 0xa2, 0xf5, 0x60, 0xa7, 0xf0, 0x9c, 0x55, 0x3f, 0x0b, 0xad, 0x14,
- 0x9d, 0x85, 0xda, 0x11, 0x20, 0xbd, 0x02, 0x11, 0xf6, 0xf2, 0x36, 0x8c, 0x7a, 0xbc, 0x2a, 0x21,
- 0xb2, 0x17, 0x8b, 0xdc, 0x49, 0x5d, 0x6d, 0xd4, 0xc2, 0x38, 0x38, 0x00, 0x4b, 0x96, 0x74, 0x0f,
- 0x91, 0xe7, 0x7f, 0x2a, 0xde, 0xa6, 0xd9, 0x7f, 0xc3, 0x82, 0xe9, 0xeb, 0x99, 0xdb, 0x58, 0xcf,
- 0xc0, 0x48, 0x4c, 0xa2, 0x1c, 0x67, 0x5a, 0x93, 0x41, 0xb1, 0xc0, 0x3e, 0xf4, 0x0d, 0xfa, 0x37,
- 0x2a, 0x50, 0x63, 0xa1, 0x93, 0x6d, 0xa7, 0x35, 0x48, 0x73, 0x74, 0xc3, 0x30, 0x47, 0x0b, 0xb6,
- 0x87, 0xaa, 0x41, 0xbd, 0xac, 0x51, 0x74, 0x53, 0xdd, 0x4e, 0x2a, 0xb5, 0x33, 0x4c, 0x19, 0xf2,
- 0xbb, 0x2c, 0x53, 0xe6, 0x65, 0x26, 0x79, 0x73, 0x89, 0x9d, 0x4e, 0x2a, 0xda, 0x0f, 0xd8, 0xe9,
- 0xa4, 0x6a, 0x57, 0x0f, 0x95, 0xd4, 0xd0, 0x9a, 0xce, 0x14, 0xf6, 0xa7, 0x59, 0x28, 0x9c, 0xe3,
- 0x7b, 0x5f, 0x25, 0xea, 0x8a, 0xdf, 0xbc, 0x08, 0x6e, 0x13, 0xd0, 0xfb, 0x4c, 0xbb, 0x88, 0x7f,
- 0xfc, 0xe6, 0x66, 0x5a, 0xc4, 0xbe, 0x02, 0xd3, 0x99, 0x81, 0x43, 0x2f, 0xc3, 0x70, 0x7b, 0xd7,
- 0x89, 0x49, 0x26, 0xcc, 0x62, 0xb8, 0x41, 0x81, 0xf7, 0x0f, 0xe7, 0xa7, 0x54, 0x01, 0x06, 0xc1,
- 0x9c, 0xda, 0xfe, 0x73, 0x0b, 0x86, 0xae, 0x87, 0xee, 0x20, 0x05, 0xec, 0x8a, 0x21, 0x60, 0xcf,
- 0x14, 0xdf, 0xf7, 0xee, 0x29, 0x5b, 0x8d, 0x8c, 0x6c, 0x9d, 0x2f, 0xc1, 0xeb, 0x78, 0xb1, 0xda,
- 0x83, 0x71, 0x76, 0x9f, 0x5c, 0xc4, 0x97, 0xbc, 0x68, 0xec, 0x9b, 0xe6, 0x33, 0xfb, 0xa6, 0x69,
- 0x8d, 0x54, 0xdb, 0x3d, 0x3d, 0x0b, 0xa3, 0x22, 0x9e, 0x21, 0x1b, 0x02, 0x28, 0x68, 0xb1, 0xc4,
- 0xdb, 0xff, 0xb2, 0x0a, 0xc6, 0xfd, 0x75, 0xf4, 0xfb, 0x16, 0x2c, 0x44, 0xfc, 0xda, 0x81, 0x5b,
- 0xef, 0x44, 0x5e, 0xb0, 0xd3, 0x6c, 0xed, 0x12, 0xb7, 0xe3, 0x7b, 0xc1, 0xce, 0xfa, 0x4e, 0x10,
- 0x2a, 0xf0, 0xea, 0x3d, 0xd2, 0xea, 0x30, 0xa7, 0x6a, 0xe9, 0x6b, 0xf3, 0xea, 0x4c, 0xf3, 0xd2,
- 0xd1, 0xe1, 0xfc, 0x02, 0xee, 0xab, 0x16, 0xdc, 0x67, 0xab, 0xd0, 0x1f, 0x59, 0xb0, 0xc8, 0x6f,
- 0x70, 0x97, 0xef, 0x49, 0xa9, 0xfd, 0x66, 0x43, 0x32, 0x4d, 0xd9, 0x6d, 0x92, 0x68, 0x6f, 0xf9,
- 0x15, 0x31, 0xc8, 0x8b, 0x8d, 0xfe, 0x6a, 0xc5, 0xfd, 0x36, 0xd3, 0xfe, 0xed, 0x2a, 0x4c, 0xd2,
- 0xf1, 0x4c, 0x6f, 0x6f, 0xbe, 0x6c, 0x88, 0xc9, 0x47, 0x32, 0x62, 0x72, 0xc2, 0x20, 0x7e, 0x38,
- 0x17, 0x37, 0xdf, 0x81, 0x13, 0xbe, 0x13, 0x27, 0x57, 0x88, 0x13, 0x25, 0x5b, 0xc4, 0x61, 0xc7,
- 0x88, 0xc5, 0x93, 0x20, 0x73, 0x2e, 0xa9, 0x22, 0x64, 0xae, 0x65, 0x59, 0xe1, 0x6e, 0xee, 0x28,
- 0x01, 0xc4, 0x0e, 0x2c, 0x23, 0x27, 0x88, 0x79, 0x4f, 0x3c, 0xe1, 0x84, 0xed, 0xa7, 0xce, 0x39,
- 0x51, 0x27, 0xba, 0xd6, 0xc5, 0x0b, 0xe7, 0xf0, 0xd7, 0x0e, 0xa3, 0x87, 0xcb, 0x1e, 0x46, 0x8f,
- 0x14, 0xc4, 0xdd, 0xfe, 0xb2, 0x05, 0x27, 0xe9, 0x27, 0x31, 0x63, 0x34, 0x63, 0x14, 0xc2, 0x34,
- 0x6d, 0xbe, 0x4f, 0x12, 0x09, 0x2b, 0x5e, 0x47, 0x58, 0x20, 0x9d, 0xc1, 0x27, 0x35, 0xd4, 0xae,
- 0x9a, 0xcc, 0x70, 0x96, 0xbb, 0xfd, 0x5d, 0x0b, 0x58, 0x10, 0xd8, 0xc0, 0x97, 0xaf, 0xcb, 0xe6,
- 0xf2, 0x65, 0x17, 0xeb, 0x8a, 0x1e, 0x2b, 0xd7, 0x4b, 0x30, 0x43, 0xb1, 0x8d, 0x28, 0xbc, 0x77,
- 0x20, 0x0d, 0xea, 0x62, 0x4f, 0xec, 0xbb, 0x15, 0x3e, 0x61, 0xd4, 0xcd, 0x29, 0xf4, 0x2b, 0x16,
- 0x8c, 0xb5, 0x9c, 0xb6, 0xd3, 0xe2, 0x79, 0x3f, 0x4a, 0x78, 0x5d, 0x8c, 0xf2, 0x0b, 0x2b, 0xa2,
- 0x2c, 0xf7, 0x18, 0x7c, 0x5c, 0x76, 0x5d, 0x82, 0x0b, 0xbd, 0x04, 0xaa, 0xf2, 0x39, 0x0f, 0x26,
- 0x0d, 0x66, 0x03, 0xdc, 0x66, 0xfe, 0x8a, 0xc5, 0x95, 0xbd, 0xda, 0x10, 0xdc, 0x85, 0x13, 0x81,
- 0xf6, 0x9f, 0xaa, 0x31, 0x69, 0xff, 0x2e, 0x94, 0x57, 0xe7, 0x4c, 0xfb, 0x69, 0xc1, 0x6e, 0x19,
- 0x86, 0xb8, 0xbb, 0x0e, 0xfb, 0x1f, 0x5b, 0xf0, 0x98, 0x4e, 0xa8, 0x5d, 0x74, 0x2b, 0xf2, 0x02,
- 0xd7, 0x61, 0x2c, 0x6c, 0x93, 0xc8, 0x49, 0x37, 0x3f, 0xe7, 0xe5, 0xe8, 0xdf, 0x10, 0xf0, 0xfb,
- 0x87, 0xf3, 0xa7, 0x74, 0xee, 0x12, 0x8e, 0x55, 0x49, 0x64, 0xc3, 0x08, 0x1b, 0x97, 0x58, 0x5c,
- 0x51, 0x64, 0x59, 0x30, 0xd8, 0xd9, 0x47, 0x8c, 0x05, 0xc6, 0xfe, 0x9b, 0x16, 0x17, 0x36, 0xbd,
- 0xe9, 0xe8, 0x6b, 0x30, 0xb3, 0x47, 0xf7, 0x49, 0xab, 0xf7, 0xda, 0x74, 0x01, 0x65, 0x67, 0xbe,
- 0x56, 0x99, 0x65, 0xa3, 0x47, 0x77, 0x97, 0x67, 0x45, 0xeb, 0x67, 0x36, 0x32, 0x6c, 0x71, 0x57,
- 0x45, 0xf6, 0x1f, 0x8b, 0xf9, 0xca, 0x6c, 0xb6, 0x67, 0x61, 0xb4, 0x1d, 0xba, 0x2b, 0xeb, 0x75,
- 0x2c, 0xc6, 0x4a, 0x29, 0x9c, 0x06, 0x07, 0x63, 0x89, 0x47, 0x97, 0x00, 0xc8, 0xbd, 0x84, 0x44,
- 0x81, 0xe3, 0xab, 0xb3, 0x5a, 0x65, 0x22, 0xad, 0x2a, 0x0c, 0xd6, 0xa8, 0x68, 0x99, 0x76, 0x14,
- 0xee, 0x7b, 0x2e, 0x8b, 0x3c, 0xaf, 0x9a, 0x65, 0x1a, 0x0a, 0x83, 0x35, 0x2a, 0xba, 0x3b, 0xed,
- 0x04, 0x31, 0x5f, 0xbe, 0x9c, 0x2d, 0x91, 0xbc, 0x61, 0x2c, 0xdd, 0x9d, 0xde, 0xd4, 0x91, 0xd8,
- 0xa4, 0xb5, 0x7f, 0x56, 0x03, 0x48, 0x0d, 0x24, 0xf4, 0x6e, 0xf7, 0x0c, 0xfd, 0x44, 0x59, 0xeb,
- 0xea, 0xe1, 0x4d, 0x4f, 0xf4, 0x2d, 0x0b, 0xc6, 0x1d, 0xdf, 0x0f, 0x5b, 0x4e, 0xc2, 0x7a, 0x54,
- 0x29, 0xab, 0x2b, 0x44, 0x4b, 0x96, 0xd2, 0xb2, 0xbc, 0x31, 0x2f, 0xca, 0xa3, 0x3c, 0x0d, 0x53,
- 0xd8, 0x1e, 0xbd, 0x09, 0xe8, 0xe3, 0xd2, 0xb0, 0xe6, 0x1f, 0x65, 0x2e, 0x6b, 0x58, 0xd7, 0x98,
- 0x86, 0xd4, 0x6c, 0x6a, 0xf4, 0x25, 0x23, 0x4f, 0xc1, 0x50, 0x99, 0xdb, 0xb1, 0x86, 0xc9, 0x50,
- 0x94, 0xa2, 0x00, 0x7d, 0x5e, 0x0f, 0xca, 0x1d, 0x2e, 0x73, 0xf5, 0x54, 0xb3, 0x5c, 0x0b, 0x02,
- 0x72, 0x13, 0x98, 0x76, 0xcd, 0x85, 0x52, 0x04, 0x5a, 0x5d, 0x2c, 0xae, 0x21, 0xb3, 0xc2, 0xa6,
- 0x4b, 0x63, 0x06, 0x81, 0xb3, 0x55, 0xd0, 0xd5, 0x90, 0xaa, 0xad, 0xf5, 0x60, 0x3b, 0x14, 0xe1,
- 0x56, 0x17, 0x4a, 0x7c, 0xf3, 0x83, 0x38, 0x21, 0x7b, 0xb4, 0x4c, 0xba, 0x1a, 0x5e, 0x17, 0x5c,
- 0xb0, 0xe2, 0x87, 0x36, 0x61, 0x84, 0x5d, 0xf0, 0x88, 0x67, 0xc7, 0xca, 0xb8, 0xc7, 0xcc, 0x1b,
- 0x8d, 0xa9, 0x01, 0xc2, 0xfe, 0xc6, 0x58, 0xf0, 0x42, 0x57, 0xe4, 0x0d, 0xe0, 0x78, 0x3d, 0xb8,
- 0x19, 0x13, 0x76, 0x03, 0xb8, 0xb6, 0xfc, 0xd1, 0xf4, 0x4a, 0x2f, 0x87, 0xe7, 0x66, 0x66, 0x32,
- 0x4a, 0x52, 0x3b, 0x44, 0xfc, 0x97, 0x09, 0x9f, 0x66, 0xa1, 0x4c, 0x43, 0xcd, 0xf4, 0x50, 0xe9,
- 0x60, 0xdf, 0x32, 0x99, 0xe1, 0x2c, 0xf7, 0x47, 0xb8, 0x06, 0xce, 0xf9, 0x30, 0x93, 0x9d, 0x92,
- 0x03, 0x5c, 0x71, 0xff, 0x6c, 0x08, 0xa6, 0x4c, 0xc1, 0x40, 0x8b, 0x50, 0xdb, 0x63, 0xe9, 0x98,
- 0xd2, 0x24, 0x30, 0x4a, 0xfe, 0x37, 0x24, 0x02, 0xa7, 0x34, 0x2c, 0x1d, 0x0e, 0x2b, 0xae, 0x05,
- 0xda, 0xa4, 0xe9, 0x70, 0x14, 0x06, 0x6b, 0x54, 0xd4, 0x68, 0xdd, 0x0a, 0xc3, 0x44, 0x29, 0x6e,
- 0x25, 0x33, 0xcb, 0x0c, 0x8a, 0x05, 0x96, 0x2a, 0xec, 0x3b, 0xb4, 0x43, 0xbe, 0xe9, 0xea, 0x53,
- 0x0a, 0xfb, 0xaa, 0x8e, 0xc4, 0x26, 0x2d, 0x5d, 0x80, 0xc2, 0x98, 0x09, 0xa1, 0x30, 0x8d, 0xd3,
- 0xc0, 0xa5, 0x26, 0xbf, 0xf0, 0x24, 0xf1, 0xe8, 0x73, 0xf0, 0x98, 0xba, 0x9f, 0x84, 0xb9, 0xeb,
- 0x54, 0xd6, 0x38, 0x62, 0xec, 0x6c, 0x1f, 0x5b, 0xc9, 0x27, 0xc3, 0xbd, 0xca, 0xa3, 0x37, 0x60,
- 0x4a, 0x98, 0xb5, 0x92, 0xe3, 0xa8, 0x79, 0xae, 0x7d, 0xd5, 0xc0, 0xe2, 0x0c, 0x35, 0xaa, 0xc3,
- 0x0c, 0x85, 0x30, 0x8b, 0x52, 0x72, 0xe0, 0xf7, 0xac, 0xd4, 0xca, 0x7c, 0x35, 0x83, 0xc7, 0x5d,
- 0x25, 0xd0, 0x12, 0x4c, 0x73, 0xdb, 0x82, 0xee, 0xdf, 0xd8, 0x77, 0x10, 0x11, 0x92, 0x6a, 0x12,
- 0xdc, 0x30, 0xd1, 0x38, 0x4b, 0x8f, 0x5e, 0x85, 0x09, 0x27, 0x6a, 0xed, 0x7a, 0x09, 0x69, 0x25,
- 0x9d, 0x88, 0xdf, 0xad, 0xd7, 0x02, 0x03, 0x96, 0x34, 0x1c, 0x36, 0x28, 0xed, 0xaf, 0xc2, 0xc9,
- 0x9c, 0x10, 0x6c, 0x2a, 0x38, 0x4e, 0xdb, 0x93, 0x7d, 0xca, 0x84, 0x20, 0x2d, 0x35, 0xd6, 0x65,
- 0x6f, 0x34, 0x2a, 0x2a, 0x9d, 0xcc, 0x67, 0xac, 0xe5, 0x66, 0x53, 0xd2, 0xb9, 0x26, 0x11, 0x38,
- 0xa5, 0xb1, 0xff, 0x7b, 0x0d, 0x34, 0x27, 0x4b, 0x89, 0xc0, 0x93, 0x57, 0x61, 0x42, 0xa6, 0x1b,
- 0xd4, 0xd2, 0x7c, 0xa9, 0x6e, 0x5e, 0xd6, 0x70, 0xd8, 0xa0, 0xa4, 0x6d, 0x0b, 0xa4, 0xcb, 0x28,
- 0x1b, 0xf0, 0xa4, 0x7c, 0x49, 0x38, 0xa5, 0x41, 0x17, 0x60, 0x2c, 0x26, 0xfe, 0xf6, 0x35, 0x2f,
- 0xb8, 0x23, 0x04, 0x5b, 0x69, 0xe5, 0xa6, 0x80, 0x63, 0x45, 0x81, 0x3e, 0x03, 0xd5, 0x8e, 0xe7,
- 0x0a, 0x51, 0x5e, 0x90, 0x76, 0xe7, 0xcd, 0xf5, 0xfa, 0xfd, 0xc3, 0xf9, 0xf9, 0xfc, 0x1c, 0x8a,
- 0x74, 0x13, 0x1d, 0x2f, 0xd0, 0xc9, 0x47, 0x8b, 0xe6, 0xb9, 0xce, 0x47, 0xfa, 0x74, 0x9d, 0x5f,
- 0x02, 0x10, 0x7d, 0x96, 0x92, 0x5c, 0x4d, 0xbf, 0xd9, 0x65, 0x85, 0xc1, 0x1a, 0x15, 0xdd, 0x8a,
- 0xb7, 0x22, 0xe2, 0xc8, 0x1d, 0x2b, 0x0f, 0x11, 0x1e, 0x7b, 0xd0, 0xad, 0xf8, 0x4a, 0x96, 0x15,
- 0xee, 0xe6, 0x8e, 0xf6, 0xe0, 0x84, 0x4b, 0x27, 0x91, 0x51, 0x65, 0xad, 0xdf, 0xa8, 0x64, 0x5a,
- 0x5d, 0x3d, 0xcb, 0x06, 0x77, 0x73, 0x46, 0x5f, 0x84, 0x39, 0x09, 0xec, 0xbe, 0x7b, 0xc8, 0x26,
- 0x4a, 0x75, 0xf9, 0xec, 0xd1, 0xe1, 0xfc, 0x5c, 0xbd, 0x27, 0x15, 0x3e, 0x86, 0x03, 0x7a, 0x1b,
- 0x46, 0xd8, 0x31, 0x4b, 0x3c, 0x3b, 0xce, 0xd6, 0xb9, 0x97, 0xca, 0x3a, 0x1a, 0x17, 0xd8, 0x61,
- 0x8d, 0x88, 0xdb, 0x4c, 0xcf, 0xad, 0x18, 0x10, 0x0b, 0x9e, 0xa8, 0x0d, 0xe3, 0x4e, 0x10, 0x84,
- 0x89, 0xc3, 0xcd, 0xaf, 0x89, 0x32, 0x16, 0xa4, 0x56, 0xc5, 0x52, 0x5a, 0x96, 0xd7, 0xa3, 0x82,
- 0xc1, 0x34, 0x0c, 0xd6, 0xab, 0x40, 0x1d, 0x98, 0x0e, 0xef, 0x52, 0x55, 0x29, 0x4f, 0x1a, 0xe2,
- 0xd9, 0xc9, 0xa2, 0x04, 0x89, 0xe9, 0xc7, 0xb9, 0x61, 0x14, 0xd5, 0x34, 0x98, 0xc9, 0x12, 0x67,
- 0xeb, 0x40, 0x0b, 0x86, 0x17, 0x79, 0x2a, 0x8d, 0x4d, 0x4e, 0xbd, 0xc8, 0xba, 0xd3, 0x98, 0xdd,
- 0x6e, 0xe5, 0xf1, 0x88, 0x4c, 0x13, 0x4c, 0x67, 0x6e, 0xb7, 0xa6, 0x28, 0xac, 0xd3, 0xcd, 0x7d,
- 0x12, 0xc6, 0xb5, 0x61, 0xef, 0x27, 0x08, 0x76, 0xee, 0x0d, 0x98, 0xc9, 0x0e, 0x67, 0x5f, 0x41,
- 0xb4, 0xff, 0xb3, 0x02, 0xd3, 0x39, 0x87, 0x38, 0x77, 0x3c, 0x16, 0xc8, 0x6d, 0xa8, 0xbc, 0xab,
- 0x5e, 0xe0, 0x62, 0x86, 0x31, 0x15, 0x57, 0xa5, 0x84, 0xe2, 0x92, 0x5a, 0xb4, 0xda, 0x53, 0x8b,
- 0x0a, 0x65, 0x35, 0xf4, 0xe0, 0xca, 0xca, 0x5c, 0x1d, 0x86, 0x4b, 0xad, 0x0e, 0x0f, 0x41, 0xc1,
- 0x19, 0x0b, 0xcc, 0x68, 0x89, 0x05, 0xe6, 0x3b, 0x15, 0x98, 0x49, 0xc3, 0x85, 0x45, 0xe6, 0xd1,
- 0xc1, 0x9d, 0x0d, 0x6c, 0x1a, 0x67, 0x03, 0x45, 0x09, 0x45, 0x33, 0xed, 0xea, 0x79, 0x4e, 0xf0,
- 0x76, 0xe6, 0x9c, 0xe0, 0xa5, 0x3e, 0xf9, 0x1e, 0x7f, 0x66, 0xf0, 0xdd, 0x0a, 0x9c, 0xce, 0x16,
- 0x59, 0xf1, 0x1d, 0x6f, 0x6f, 0x80, 0xe3, 0xf4, 0x39, 0x63, 0x9c, 0x5e, 0xe9, 0xaf, 0x3f, 0xac,
- 0x71, 0x3d, 0x07, 0xcb, 0xc9, 0x0c, 0xd6, 0x27, 0x1f, 0x84, 0xf9, 0xf1, 0x23, 0xf6, 0x33, 0x0b,
- 0x1e, 0xcf, 0x2d, 0x37, 0x70, 0x4f, 0xe8, 0x5b, 0xa6, 0x27, 0xf4, 0xc5, 0x07, 0xe8, 0x5b, 0x0f,
- 0xd7, 0xe8, 0x51, 0xa5, 0x47, 0x9f, 0x98, 0xb7, 0xe8, 0x06, 0x8c, 0x3b, 0xad, 0x16, 0x89, 0xe3,
- 0x8d, 0xd0, 0x55, 0xd9, 0x70, 0x5e, 0x60, 0xab, 0x48, 0x0a, 0xbe, 0x7f, 0x38, 0x3f, 0x97, 0x65,
- 0x91, 0xa2, 0xb1, 0xce, 0xc1, 0xcc, 0x6a, 0x55, 0x19, 0x50, 0x56, 0xab, 0x4b, 0x00, 0xfb, 0x6a,
- 0x97, 0x9a, 0x75, 0x42, 0x69, 0xfb, 0x57, 0x8d, 0x0a, 0x7d, 0x81, 0x59, 0x7d, 0x3c, 0x3a, 0x62,
- 0xa8, 0xc8, 0x51, 0xa0, 0x7d, 0x3d, 0x3d, 0xce, 0x82, 0x5f, 0x5f, 0x54, 0xee, 0x3a, 0xc5, 0xd0,
- 0xfe, 0x41, 0x15, 0x3e, 0x7c, 0x8c, 0xc0, 0xa1, 0x25, 0xf3, 0xd0, 0xf3, 0xf9, 0xac, 0x6f, 0x66,
- 0x2e, 0xb7, 0xb0, 0xe1, 0xac, 0xc9, 0x7c, 0xa9, 0xca, 0xfb, 0xfe, 0x52, 0xdf, 0xd6, 0x3d, 0x69,
- 0x3c, 0xb8, 0xf1, 0xf2, 0x03, 0x4f, 0xa9, 0x9f, 0x4f, 0xcf, 0xf7, 0xd7, 0x2d, 0xf8, 0x48, 0x6e,
- 0xa7, 0x8c, 0xc0, 0x8a, 0x45, 0xa8, 0xb5, 0x28, 0x50, 0xbb, 0x7d, 0x92, 0x5e, 0xfb, 0x92, 0x08,
- 0x9c, 0xd2, 0x18, 0xf1, 0x13, 0x95, 0xc2, 0xf8, 0x89, 0x7f, 0x6f, 0xc1, 0xa9, 0x6c, 0x23, 0x06,
- 0xae, 0x6f, 0x9a, 0xa6, 0xbe, 0x59, 0xe8, 0xef, 0xc3, 0xf7, 0x50, 0x35, 0xdf, 0x99, 0x84, 0x33,
- 0x5d, 0x6b, 0x14, 0x1f, 0xc3, 0x5f, 0xb4, 0xe0, 0xc4, 0x0e, 0xb3, 0xaf, 0xb5, 0x0b, 0x3e, 0xa2,
- 0x57, 0x05, 0xb7, 0xa2, 0x8e, 0xbd, 0x17, 0xc4, 0x77, 0x0b, 0x5d, 0x24, 0xb8, 0xbb, 0x32, 0xf4,
- 0x4d, 0x0b, 0x4e, 0x39, 0x77, 0xe3, 0xae, 0xec, 0xf5, 0x42, 0x88, 0xde, 0x28, 0x70, 0x62, 0x15,
- 0xe4, 0xbd, 0x5f, 0x9e, 0x3d, 0x3a, 0x9c, 0x3f, 0x95, 0x47, 0x85, 0x73, 0x6b, 0x45, 0x6f, 0x8b,
- 0xdc, 0x5f, 0xd4, 0xe0, 0x29, 0x75, 0x55, 0x2d, 0xef, 0xba, 0x01, 0x57, 0x48, 0x12, 0x83, 0x15,
- 0x47, 0xf4, 0x65, 0xa8, 0xed, 0xc8, 0x3b, 0x3d, 0x42, 0xdd, 0x15, 0xac, 0x29, 0xb9, 0x57, 0x80,
- 0x78, 0x50, 0xbb, 0x42, 0xe1, 0x94, 0x29, 0xba, 0x02, 0xd5, 0x60, 0x3b, 0x16, 0xf7, 0x66, 0x8b,
- 0x82, 0x67, 0xcc, 0x50, 0x25, 0x7e, 0xe1, 0xf0, 0xfa, 0x5a, 0x13, 0x53, 0x16, 0x94, 0x53, 0xb4,
- 0xe5, 0x0a, 0xef, 0x6d, 0x01, 0x27, 0xbc, 0x5c, 0xef, 0xe6, 0x84, 0x97, 0xeb, 0x98, 0xb2, 0x60,
- 0x51, 0x7a, 0x71, 0x2b, 0xf6, 0x84, 0x6b, 0xb6, 0xe0, 0x52, 0x75, 0xd7, 0x25, 0x0c, 0x9e, 0x06,
- 0x8e, 0x81, 0x31, 0x67, 0x84, 0x36, 0x61, 0xa4, 0xc5, 0x12, 0x36, 0x8b, 0x9d, 0x73, 0x51, 0x1a,
- 0xdf, 0xae, 0xe4, 0xce, 0xfc, 0x08, 0x89, 0xc3, 0xb1, 0xe0, 0xc5, 0xb8, 0x92, 0xf6, 0xee, 0x76,
- 0x2c, 0x36, 0xc7, 0x45, 0x5c, 0xbb, 0x52, 0x6f, 0x0b, 0xae, 0x0c, 0x8e, 0x05, 0x2f, 0x54, 0x87,
- 0xca, 0x76, 0x4b, 0xe4, 0x5e, 0x2c, 0x70, 0xc9, 0x9a, 0xb7, 0x47, 0x97, 0x47, 0x8e, 0x0e, 0xe7,
- 0x2b, 0x6b, 0x2b, 0xb8, 0xb2, 0xdd, 0x42, 0x6f, 0xc1, 0xe8, 0x36, 0xbf, 0x0f, 0x28, 0xf2, 0x2c,
- 0x5e, 0x2c, 0xba, 0xb4, 0xd8, 0x75, 0x79, 0x90, 0x5f, 0x5c, 0x10, 0x08, 0x2c, 0xd9, 0xa1, 0x2f,
- 0x02, 0x6c, 0xab, 0x1b, 0x8e, 0x22, 0xd1, 0xe2, 0x42, 0x7f, 0x37, 0x22, 0xc5, 0xbe, 0x51, 0x41,
- 0xb1, 0xc6, 0x91, 0xca, 0xbc, 0x23, 0x73, 0xce, 0xb3, 0x24, 0x8b, 0x85, 0x32, 0x9f, 0x9b, 0xa2,
- 0x9e, 0xcb, 0xbc, 0x42, 0xe1, 0x94, 0x29, 0xea, 0xc0, 0xe4, 0x7e, 0xdc, 0xde, 0x25, 0x72, 0xea,
- 0xb3, 0xcc, 0x8b, 0xe3, 0x97, 0x5e, 0x2f, 0x48, 0xa7, 0x29, 0x8a, 0x78, 0x51, 0xd2, 0x71, 0xfc,
- 0x2e, 0x0d, 0xc6, 0x72, 0x19, 0xdd, 0xd2, 0xd9, 0x62, 0xb3, 0x16, 0xfa, 0x49, 0xde, 0xe9, 0x84,
- 0x5b, 0x07, 0x09, 0x11, 0x99, 0x19, 0x0b, 0x3e, 0xc9, 0x9b, 0x9c, 0xb8, 0xfb, 0x93, 0x08, 0x04,
- 0x96, 0xec, 0xd4, 0x90, 0x31, 0x6d, 0x3c, 0x53, 0x7a, 0xc8, 0xba, 0xfa, 0x90, 0x0e, 0x19, 0xd3,
- 0xbe, 0x29, 0x53, 0xa6, 0x75, 0xdb, 0xbb, 0x61, 0x12, 0x06, 0x19, 0xdd, 0x7f, 0xa2, 0x8c, 0xd6,
- 0x6d, 0xe4, 0x94, 0xec, 0xd6, 0xba, 0x79, 0x54, 0x38, 0xb7, 0x56, 0xfb, 0x8f, 0x87, 0xbb, 0x17,
- 0x5b, 0x66, 0x08, 0xff, 0x6a, 0xf7, 0xb9, 0xe2, 0x67, 0xfa, 0xdf, 0xe5, 0x3d, 0xc4, 0x13, 0xc6,
- 0x6f, 0x5a, 0x70, 0xa6, 0x9d, 0xbb, 0x98, 0x8a, 0x05, 0xab, 0xdf, 0xcd, 0x22, 0x1f, 0x30, 0x95,
- 0x76, 0x34, 0x1f, 0x8f, 0x7b, 0xd4, 0x99, 0x35, 0x3f, 0xab, 0xef, 0xdb, 0xfc, 0xbc, 0x0d, 0x63,
- 0xcc, 0x62, 0x4a, 0x73, 0x60, 0xf4, 0x99, 0x36, 0x82, 0x2d, 0x7d, 0x2b, 0x82, 0x05, 0x56, 0xcc,
- 0xe8, 0xc0, 0x3d, 0x99, 0xed, 0x04, 0x26, 0x0c, 0x2d, 0xf2, 0xa5, 0x72, 0xaf, 0xc6, 0x9a, 0x18,
- 0x89, 0x27, 0x1b, 0xc7, 0x11, 0xdf, 0x2f, 0x22, 0xc0, 0xc7, 0x57, 0xf6, 0x28, 0xcd, 0xd9, 0x7f,
- 0x66, 0xe5, 0xd8, 0x5f, 0x7c, 0x03, 0xf2, 0xba, 0xb9, 0x01, 0x79, 0x26, 0xbb, 0x01, 0xe9, 0x72,
- 0x14, 0x18, 0x7b, 0x8f, 0xf2, 0xc9, 0x03, 0xcb, 0x26, 0xe9, 0xb0, 0x7d, 0x38, 0x57, 0x34, 0xb9,
- 0x59, 0x04, 0x8f, 0xab, 0x8e, 0xc3, 0xd2, 0x08, 0x1e, 0x77, 0xbd, 0x8e, 0x19, 0xa6, 0xec, 0x6d,
- 0x6f, 0xfb, 0x7f, 0x5b, 0x50, 0x6d, 0x84, 0xee, 0x00, 0x1d, 0x1f, 0x97, 0x0d, 0xc7, 0xc7, 0xd3,
- 0x85, 0x2f, 0xed, 0xf4, 0x74, 0x73, 0xdc, 0xc8, 0xb8, 0x39, 0x3e, 0x56, 0xcc, 0xea, 0x78, 0xa7,
- 0xc6, 0x0f, 0xab, 0xa0, 0xbf, 0x15, 0x84, 0xfe, 0xe0, 0x41, 0x42, 0x39, 0xab, 0xe5, 0x9e, 0x0f,
- 0x12, 0x75, 0xb0, 0xd0, 0x1f, 0x79, 0xbd, 0xeb, 0xe7, 0x36, 0xa2, 0xf3, 0x36, 0xf1, 0x76, 0x76,
- 0x13, 0xe2, 0x66, 0x3b, 0xf6, 0xe8, 0x22, 0x3a, 0xff, 0x9b, 0x05, 0xd3, 0x99, 0xda, 0xd1, 0x57,
- 0xf2, 0xee, 0x89, 0x3c, 0x90, 0x33, 0xe3, 0x44, 0xe1, 0xb5, 0x92, 0x05, 0x00, 0xe5, 0x7d, 0x96,
- 0x2e, 0x07, 0x66, 0x81, 0x29, 0xf7, 0x74, 0x8c, 0x35, 0x0a, 0xf4, 0x32, 0x8c, 0x27, 0x61, 0x3b,
- 0xf4, 0xc3, 0x9d, 0x83, 0xab, 0x44, 0x66, 0x1f, 0x50, 0x9e, 0xfb, 0xcd, 0x14, 0x85, 0x75, 0x3a,
- 0xfb, 0xc7, 0x55, 0xc8, 0xbe, 0x33, 0xf5, 0xff, 0xa5, 0xf4, 0xe7, 0x47, 0x4a, 0xff, 0xd0, 0x82,
- 0x19, 0x5a, 0x3b, 0x0b, 0xdb, 0x90, 0xd1, 0x97, 0x2a, 0xcf, 0xb7, 0x75, 0x4c, 0x9e, 0xef, 0x67,
- 0xa8, 0xae, 0x73, 0xc3, 0x4e, 0x22, 0xdc, 0x24, 0x9a, 0x0a, 0xa3, 0x50, 0x2c, 0xb0, 0x82, 0x8e,
- 0x44, 0x91, 0xb8, 0x8e, 0xa2, 0xd3, 0x91, 0x28, 0xc2, 0x02, 0x2b, 0xd3, 0x80, 0x0f, 0xe5, 0xa7,
- 0x01, 0xe7, 0xf9, 0x7b, 0x44, 0xb8, 0x80, 0x30, 0x02, 0xb4, 0xfc, 0x3d, 0x32, 0x8e, 0x20, 0xa5,
- 0xb1, 0xbf, 0x5b, 0x85, 0x89, 0x46, 0xe8, 0xa6, 0x01, 0xd5, 0x2f, 0x19, 0x01, 0xd5, 0xe7, 0x32,
- 0x01, 0xd5, 0x33, 0x3a, 0xed, 0xc3, 0x89, 0xa7, 0x16, 0x39, 0x9e, 0x58, 0xa2, 0xfa, 0x07, 0x8a,
- 0xa5, 0x36, 0x72, 0x3c, 0x29, 0x36, 0xd8, 0xe4, 0xfa, 0x97, 0x27, 0x86, 0xfa, 0xcf, 0x2d, 0x98,
- 0x6a, 0x84, 0x2e, 0x15, 0xce, 0xbf, 0x4c, 0x92, 0xa8, 0x67, 0x86, 0x1a, 0x39, 0x26, 0x33, 0xd4,
- 0x6f, 0x58, 0x30, 0xda, 0x08, 0xdd, 0x81, 0xbb, 0x0f, 0xd7, 0x4c, 0xf7, 0xe1, 0x47, 0x0a, 0x75,
- 0x6e, 0x0f, 0x8f, 0xe1, 0x0f, 0xaa, 0x30, 0x49, 0xdb, 0x1b, 0xee, 0xc8, 0xaf, 0x65, 0x8c, 0x8c,
- 0x55, 0x62, 0x64, 0xa8, 0x09, 0x18, 0xfa, 0x7e, 0x78, 0x37, 0xfb, 0xe5, 0xd6, 0x18, 0x14, 0x0b,
- 0x2c, 0xba, 0x00, 0x63, 0xed, 0x88, 0xec, 0x7b, 0x61, 0x27, 0xce, 0x5e, 0x6a, 0x6b, 0x08, 0x38,
- 0x56, 0x14, 0xe8, 0x25, 0x98, 0x88, 0xbd, 0xa0, 0x45, 0x64, 0x30, 0xc1, 0x10, 0x0b, 0x26, 0xe0,
- 0x49, 0xf7, 0x34, 0x38, 0x36, 0xa8, 0xd0, 0x4d, 0xa8, 0xb1, 0xff, 0x6c, 0xf6, 0xf4, 0x9b, 0x95,
- 0x9c, 0x67, 0x9d, 0x92, 0xc5, 0x71, 0xca, 0x09, 0x5d, 0x02, 0x48, 0x64, 0xd0, 0x43, 0x2c, 0xb2,
- 0x67, 0x28, 0x6b, 0x54, 0x85, 0x43, 0xc4, 0x58, 0xa3, 0x42, 0xcf, 0x43, 0x2d, 0x71, 0x3c, 0xff,
- 0x9a, 0x17, 0x90, 0x58, 0x04, 0x8c, 0x88, 0xb4, 0xb1, 0x02, 0x88, 0x53, 0x3c, 0x5d, 0xe7, 0xd9,
- 0x65, 0x5a, 0xfe, 0xda, 0xc1, 0x18, 0xa3, 0x66, 0xeb, 0xfc, 0x35, 0x05, 0xc5, 0x1a, 0x85, 0xfd,
- 0x22, 0x5b, 0xaf, 0xfb, 0x8c, 0xb6, 0xff, 0x69, 0x05, 0x50, 0x83, 0x05, 0x57, 0x18, 0x0f, 0x42,
- 0xec, 0xc2, 0x54, 0x4c, 0xae, 0x79, 0x41, 0xe7, 0x9e, 0x60, 0x55, 0xee, 0x72, 0x43, 0x73, 0x55,
- 0x2f, 0xc3, 0xef, 0x90, 0x9a, 0x30, 0x9c, 0xe1, 0x4b, 0x87, 0x24, 0xea, 0x04, 0x4b, 0xf1, 0xcd,
- 0x98, 0x44, 0xe2, 0x49, 0x07, 0x36, 0x24, 0x58, 0x02, 0x71, 0x8a, 0xa7, 0x02, 0xc0, 0xfe, 0x5c,
- 0x0f, 0x03, 0x1c, 0x86, 0x89, 0x14, 0x19, 0x96, 0xe8, 0x5b, 0x83, 0x63, 0x83, 0x0a, 0xad, 0x01,
- 0x8a, 0x3b, 0xed, 0xb6, 0xcf, 0x4e, 0xb1, 0x1c, 0xff, 0x72, 0x14, 0x76, 0xda, 0x3c, 0xb2, 0x56,
- 0xe4, 0xc8, 0x6e, 0x76, 0x61, 0x71, 0x4e, 0x09, 0x3a, 0xdd, 0xb7, 0x63, 0xf6, 0x5b, 0xdc, 0x91,
- 0xe5, 0x1e, 0xb5, 0x26, 0x03, 0x61, 0x89, 0xb3, 0xbf, 0xc6, 0x96, 0x27, 0x96, 0x6d, 0x3f, 0xe9,
- 0x44, 0x04, 0xdd, 0x81, 0xc9, 0x36, 0x5b, 0x82, 0x92, 0x28, 0xf4, 0x7d, 0x12, 0x15, 0xbf, 0x5b,
- 0xd4, 0x33, 0xbc, 0x83, 0x67, 0xd8, 0xd6, 0x99, 0x61, 0x93, 0xb7, 0xfd, 0x9f, 0x80, 0xe9, 0x1a,
- 0x71, 0x8c, 0x38, 0x2a, 0x82, 0x37, 0x85, 0x15, 0xf6, 0xd1, 0x32, 0x2f, 0xcc, 0xa4, 0x7a, 0x5c,
- 0x84, 0x82, 0x62, 0xc9, 0x05, 0x7d, 0x81, 0x85, 0x26, 0xf3, 0x29, 0x5e, 0xfe, 0xd9, 0x27, 0x4e,
- 0x6f, 0x84, 0x25, 0x0b, 0x16, 0x58, 0x63, 0x87, 0xae, 0xc1, 0xa4, 0x48, 0xcf, 0x2e, 0x1c, 0x02,
- 0x55, 0x63, 0x53, 0x3c, 0x89, 0x75, 0xe4, 0xfd, 0x2c, 0x00, 0x9b, 0x85, 0xd1, 0x0e, 0x3c, 0xa9,
- 0x3d, 0xd5, 0x92, 0x13, 0x88, 0xc4, 0x75, 0xc7, 0x47, 0x8e, 0x0e, 0xe7, 0x9f, 0xdc, 0x3c, 0x8e,
- 0x10, 0x1f, 0xcf, 0x07, 0xdd, 0x80, 0xd3, 0x4e, 0x2b, 0xf1, 0xf6, 0x49, 0x9d, 0x38, 0xae, 0xef,
- 0x05, 0xc4, 0xbc, 0x46, 0xfd, 0xf8, 0xd1, 0xe1, 0xfc, 0xe9, 0xa5, 0x3c, 0x02, 0x9c, 0x5f, 0x0e,
- 0xbd, 0x0e, 0x35, 0x37, 0x88, 0xc5, 0x18, 0x8c, 0x18, 0xaf, 0xd2, 0xd4, 0xea, 0xd7, 0x9b, 0xaa,
- 0xff, 0xe9, 0x1f, 0x9c, 0x16, 0x40, 0xef, 0xf0, 0x67, 0x72, 0xd5, 0x3e, 0x84, 0xbf, 0x86, 0xf4,
- 0x4a, 0xa9, 0x9d, 0xaf, 0x71, 0xed, 0x81, 0xfb, 0xca, 0x54, 0xa8, 0x9f, 0x71, 0x23, 0xc2, 0xa8,
- 0x02, 0x7d, 0x16, 0x50, 0x4c, 0xa2, 0x7d, 0xaf, 0x45, 0x96, 0x5a, 0x2c, 0xef, 0x24, 0x3b, 0x92,
- 0x1b, 0x33, 0xe2, 0xdd, 0x51, 0xb3, 0x8b, 0x02, 0xe7, 0x94, 0x42, 0x57, 0xa8, 0xde, 0xd1, 0xa1,
- 0x22, 0x32, 0x53, 0x1a, 0x75, 0xb3, 0x75, 0xd2, 0x8e, 0x48, 0xcb, 0x49, 0x88, 0x6b, 0x72, 0xc4,
- 0x99, 0x72, 0x74, 0x65, 0x51, 0x69, 0xb4, 0xc1, 0x8c, 0x27, 0xec, 0x4e, 0xa5, 0x4d, 0xf7, 0x48,
- 0xbb, 0x61, 0x9c, 0x5c, 0x27, 0xc9, 0xdd, 0x30, 0xba, 0xc3, 0x7c, 0xec, 0x63, 0x5a, 0x22, 0xaf,
- 0x14, 0x85, 0x75, 0x3a, 0x6a, 0x03, 0xb1, 0xc3, 0x9d, 0xf5, 0x3a, 0xf3, 0x9c, 0x8f, 0xa5, 0x73,
- 0xe7, 0x0a, 0x07, 0x63, 0x89, 0x97, 0xa4, 0xeb, 0x8d, 0x15, 0xe6, 0x05, 0xcf, 0x90, 0xae, 0x37,
- 0x56, 0xb0, 0xc4, 0xa3, 0xb0, 0xfb, 0xed, 0x9f, 0xa9, 0x32, 0x27, 0x12, 0xdd, 0x7a, 0xbc, 0xe4,
- 0xf3, 0x3f, 0xf7, 0x60, 0x46, 0xbd, 0x3f, 0xc4, 0x33, 0x2c, 0xc6, 0xb3, 0xd3, 0x65, 0x1e, 0xe9,
- 0xcd, 0x4d, 0xd4, 0xa8, 0x42, 0x71, 0xd7, 0x33, 0x3c, 0x71, 0x57, 0x2d, 0x46, 0x3a, 0x80, 0x99,
- 0xc2, 0xd4, 0xe8, 0x8b, 0x50, 0x8b, 0x3b, 0x5b, 0x6e, 0xb8, 0xe7, 0x78, 0x01, 0x73, 0x55, 0xeb,
- 0x4f, 0xce, 0x4a, 0x04, 0x4e, 0x69, 0xe6, 0x3e, 0x0d, 0x27, 0xba, 0x64, 0xba, 0xaf, 0x18, 0xb2,
- 0x6f, 0x0c, 0x41, 0x4d, 0x39, 0x73, 0xd0, 0xa2, 0xe9, 0xaf, 0x7b, 0x3c, 0xeb, 0xaf, 0x1b, 0xa3,
- 0xeb, 0xaf, 0xee, 0xa2, 0xfb, 0x62, 0xce, 0x9b, 0x93, 0xcf, 0x15, 0x7e, 0xc4, 0xf2, 0x57, 0x39,
- 0xfa, 0x78, 0x91, 0x33, 0x35, 0xeb, 0x87, 0x8e, 0x35, 0xeb, 0x4b, 0x3e, 0x2c, 0x44, 0x0d, 0xf8,
- 0x76, 0xe8, 0xae, 0x37, 0xb2, 0xaf, 0x67, 0x34, 0x28, 0x10, 0x73, 0x1c, 0x33, 0xbd, 0xa8, 0x52,
- 0x66, 0xa6, 0xd7, 0xe8, 0x03, 0x99, 0x5e, 0xb2, 0x38, 0x4e, 0x39, 0xa1, 0x7d, 0x38, 0xd1, 0x32,
- 0x9f, 0x42, 0x51, 0xd7, 0x33, 0x5e, 0xe8, 0xe3, 0x29, 0x92, 0x8e, 0x96, 0xf6, 0x7d, 0x25, 0xcb,
- 0x0f, 0x77, 0x57, 0x61, 0xff, 0x98, 0x7b, 0x7e, 0xc4, 0x6e, 0x90, 0xc4, 0x1d, 0x7f, 0x90, 0x89,
- 0x9c, 0x6f, 0x18, 0x1b, 0xd4, 0x87, 0xe0, 0x73, 0xfc, 0x5d, 0x8b, 0xf9, 0x1c, 0x37, 0xc9, 0x5e,
- 0xdb, 0x77, 0x92, 0x41, 0x06, 0xe6, 0x7d, 0x01, 0xc6, 0x12, 0x51, 0x4b, 0xb9, 0xec, 0xd3, 0x5a,
- 0xb3, 0x98, 0x0f, 0x56, 0x69, 0x01, 0x09, 0xc5, 0x8a, 0xa1, 0xfd, 0xdb, 0xfc, 0x2b, 0x48, 0xcc,
- 0xc0, 0xb7, 0x55, 0xd7, 0xcd, 0x6d, 0xd5, 0xb3, 0xa5, 0x7b, 0xd2, 0x6b, 0x7b, 0x65, 0xb6, 0x9f,
- 0x99, 0x6a, 0x1f, 0x7c, 0x17, 0xb8, 0xbd, 0x01, 0xe6, 0xdb, 0x2e, 0xe8, 0x75, 0x1e, 0xd6, 0xca,
- 0x75, 0xe1, 0x73, 0x7d, 0x86, 0xb4, 0xda, 0xdf, 0xaf, 0xc0, 0xa9, 0xbc, 0x37, 0xde, 0x91, 0x0b,
- 0x13, 0x6d, 0xcd, 0x7c, 0x2e, 0x97, 0xb1, 0x40, 0x37, 0xb8, 0x53, 0xa3, 0x45, 0x87, 0x62, 0x83,
- 0x2b, 0xda, 0x82, 0x09, 0xb2, 0xef, 0xb5, 0x94, 0x57, 0xa5, 0xd2, 0xa7, 0x72, 0x52, 0x75, 0xac,
- 0x6a, 0x5c, 0xb0, 0xc1, 0x73, 0x00, 0xa9, 0xd1, 0xed, 0x7f, 0x62, 0xc1, 0x63, 0x3d, 0x72, 0x1a,
- 0xd0, 0xea, 0xee, 0x32, 0xb7, 0xa3, 0x78, 0x38, 0x48, 0x55, 0xc7, 0x9d, 0x91, 0x58, 0x60, 0xd1,
- 0x16, 0x00, 0x77, 0x26, 0xb2, 0x47, 0x54, 0x2b, 0x65, 0x4e, 0xfc, 0xbb, 0x6e, 0x10, 0x6b, 0x97,
- 0x4b, 0xd5, 0xb3, 0xa9, 0x1a, 0x57, 0xfb, 0x7b, 0x55, 0x18, 0xe6, 0xef, 0x38, 0x36, 0x60, 0x74,
- 0x97, 0x67, 0x4e, 0xec, 0x2f, 0x71, 0x63, 0x6a, 0x1e, 0x71, 0x00, 0x96, 0x6c, 0xd0, 0x06, 0x9c,
- 0xf4, 0x02, 0x2f, 0xf1, 0x1c, 0xbf, 0x4e, 0x7c, 0xe7, 0x40, 0xda, 0xdb, 0x3c, 0x6b, 0xb6, 0x4c,
- 0xf0, 0x7a, 0x72, 0xbd, 0x9b, 0x04, 0xe7, 0x95, 0x43, 0x6f, 0x74, 0x25, 0x40, 0xe2, 0x19, 0x29,
- 0xd5, 0x9d, 0xa4, 0xe3, 0x93, 0x20, 0xa1, 0xd7, 0x60, 0xb2, 0xdd, 0xb5, 0xb3, 0xd0, 0x1e, 0x00,
- 0x34, 0x77, 0x13, 0x26, 0x2d, 0xaa, 0xc3, 0x4c, 0xdc, 0x61, 0xe7, 0xaf, 0x9b, 0xbb, 0x11, 0x89,
- 0x77, 0x43, 0xdf, 0x15, 0x2f, 0x58, 0x29, 0x2b, 0xaa, 0x99, 0xc1, 0xe3, 0xae, 0x12, 0x94, 0xcb,
- 0xb6, 0xe3, 0xf9, 0x9d, 0x88, 0xa4, 0x5c, 0x46, 0x4c, 0x2e, 0x6b, 0x19, 0x3c, 0xee, 0x2a, 0x61,
- 0xff, 0xa9, 0x05, 0x27, 0x73, 0x82, 0x14, 0x78, 0xe0, 0xdc, 0x8e, 0x17, 0x27, 0x2a, 0x37, 0xb2,
- 0x16, 0x38, 0xc7, 0xe1, 0x58, 0x51, 0x50, 0x29, 0xe4, 0xdb, 0xc5, 0xec, 0xe1, 0x9f, 0x38, 0x86,
- 0x15, 0xd8, 0xfe, 0xd2, 0x19, 0xa9, 0x87, 0xe8, 0x87, 0x7a, 0x3e, 0x44, 0xff, 0x14, 0x0c, 0xef,
- 0xa8, 0xad, 0xb9, 0x66, 0x8f, 0xf0, 0xcd, 0x39, 0xc7, 0xd9, 0xdf, 0xae, 0xc2, 0x74, 0x26, 0x58,
- 0x89, 0x36, 0x24, 0xf3, 0x5e, 0x3e, 0xf3, 0x27, 0xac, 0x90, 0xf6, 0x6e, 0xce, 0x9b, 0xf9, 0xcf,
- 0x98, 0x8f, 0xea, 0xa6, 0x6d, 0x5e, 0xae, 0x1b, 0xef, 0x86, 0x95, 0xcd, 0xd7, 0xfe, 0x14, 0x0c,
- 0xb5, 0x43, 0xf5, 0xfa, 0xa3, 0x12, 0x7a, 0xbc, 0x5c, 0x6f, 0x84, 0xa1, 0x8f, 0x19, 0x12, 0x3d,
- 0x2d, 0x7a, 0x9f, 0xf1, 0x49, 0x62, 0xc7, 0x0d, 0x63, 0x6d, 0x08, 0x9e, 0x85, 0xd1, 0x3b, 0xe4,
- 0x20, 0xf2, 0x82, 0x9d, 0xac, 0x47, 0xf6, 0x2a, 0x07, 0x63, 0x89, 0x37, 0x73, 0xb2, 0x8f, 0x0e,
- 0x38, 0x27, 0xfb, 0x58, 0x61, 0xb4, 0xe5, 0x6f, 0x5a, 0x30, 0xcd, 0x72, 0xca, 0x89, 0xeb, 0x9e,
- 0x5e, 0x18, 0x0c, 0x70, 0x49, 0x7c, 0x0a, 0x86, 0x23, 0x5a, 0x59, 0x36, 0x9d, 0x32, 0x6b, 0x01,
- 0xe6, 0x38, 0xf4, 0x84, 0x78, 0x98, 0x9c, 0x7e, 0xbe, 0x09, 0x9e, 0x9e, 0x36, 0x7d, 0x61, 0x9c,
- 0x45, 0xf1, 0x63, 0xd2, 0xf6, 0x3d, 0xde, 0xd8, 0xd4, 0x01, 0xf3, 0x41, 0x89, 0xe2, 0xcf, 0x6d,
- 0xdc, 0xc3, 0x8a, 0xe2, 0xcf, 0x67, 0x7e, 0xbc, 0xf1, 0xf9, 0x3f, 0x2a, 0x70, 0x36, 0xb7, 0x5c,
- 0x7a, 0x8e, 0xb3, 0x66, 0x9c, 0xe3, 0x5c, 0xca, 0x9c, 0xe3, 0xd8, 0xc7, 0x97, 0x7e, 0x38, 0x27,
- 0x3b, 0xf9, 0x47, 0x2e, 0xd5, 0x47, 0x76, 0xe4, 0x32, 0x54, 0xd6, 0x50, 0x18, 0x2e, 0x30, 0x14,
- 0x7e, 0x66, 0xc1, 0xe3, 0xb9, 0x03, 0xf6, 0x01, 0xbb, 0x34, 0x91, 0xdb, 0xc6, 0x1e, 0x86, 0xf3,
- 0xdf, 0xae, 0xf6, 0xe8, 0x13, 0x33, 0xa1, 0xcf, 0x53, 0x8d, 0xc3, 0x90, 0xb1, 0x30, 0x80, 0x26,
- 0xb8, 0xb6, 0xe1, 0x30, 0xac, 0xb0, 0x28, 0xd6, 0x2e, 0x1d, 0xf0, 0x46, 0xae, 0x3e, 0xe0, 0x64,
- 0x5a, 0x30, 0xbd, 0x65, 0xfa, 0x8d, 0xd5, 0xcc, 0x65, 0x04, 0x74, 0x5b, 0xdb, 0x12, 0x55, 0x1f,
- 0x64, 0x4b, 0x34, 0x91, 0xbf, 0x1d, 0x42, 0x4b, 0x30, 0xbd, 0xe7, 0x05, 0xec, 0x81, 0x32, 0xd3,
- 0x02, 0x51, 0xf7, 0xbc, 0x36, 0x4c, 0x34, 0xce, 0xd2, 0xcf, 0xbd, 0x06, 0x93, 0x0f, 0xee, 0x22,
- 0x79, 0xaf, 0x0a, 0x1f, 0x3e, 0x46, 0x21, 0xf0, 0x95, 0xc0, 0xf8, 0x2e, 0xda, 0x4a, 0xd0, 0xf5,
- 0x6d, 0x1a, 0x70, 0x6a, 0xbb, 0xe3, 0xfb, 0x07, 0x2c, 0x02, 0x82, 0xb8, 0x92, 0x42, 0x58, 0x77,
- 0xea, 0xe9, 0xd0, 0xb5, 0x1c, 0x1a, 0x9c, 0x5b, 0x12, 0x7d, 0x16, 0x50, 0xb8, 0xc5, 0xb2, 0x2c,
- 0xba, 0xe9, 0x9d, 0x5c, 0xf6, 0x09, 0xaa, 0xe9, 0x44, 0xbd, 0xd1, 0x45, 0x81, 0x73, 0x4a, 0x51,
- 0x5b, 0x8f, 0xbd, 0x3a, 0xaa, 0x9a, 0x95, 0xb1, 0xf5, 0xb0, 0x8e, 0xc4, 0x26, 0x2d, 0xba, 0x0c,
- 0x27, 0x9c, 0x7d, 0xc7, 0xe3, 0xf9, 0x54, 0x24, 0x03, 0x6e, 0xec, 0x29, 0x37, 0xc4, 0x52, 0x96,
- 0x00, 0x77, 0x97, 0x41, 0x6d, 0xc3, 0xab, 0xc4, 0xf3, 0x29, 0xbf, 0xfe, 0x00, 0x12, 0x5c, 0xda,
- 0xcf, 0x64, 0xff, 0x89, 0x45, 0x97, 0xbb, 0x9c, 0x37, 0xbd, 0x8c, 0xe7, 0xaf, 0xb5, 0xab, 0x18,
- 0xdd, 0xcf, 0x5f, 0x33, 0x87, 0xab, 0x49, 0xcb, 0x45, 0x23, 0x4e, 0xc3, 0x27, 0x0d, 0xcb, 0x52,
- 0xdc, 0x3f, 0x52, 0x14, 0xe8, 0x36, 0x8c, 0xba, 0xde, 0xbe, 0x17, 0x87, 0x51, 0x89, 0x67, 0x67,
- 0xbb, 0x42, 0xf2, 0x52, 0x5d, 0x59, 0xe7, 0x4c, 0xb0, 0xe4, 0x66, 0xff, 0x9d, 0x0a, 0x4c, 0xca,
- 0xfa, 0xde, 0xec, 0x84, 0x4c, 0x87, 0x0d, 0x6a, 0x11, 0x7f, 0xd3, 0x58, 0xc4, 0x17, 0xcb, 0x5d,
- 0xc2, 0x62, 0x8d, 0xea, 0xb9, 0x78, 0x7f, 0x2e, 0xb3, 0x78, 0x5f, 0xec, 0x87, 0xe9, 0xf1, 0x8b,
- 0xf6, 0xbf, 0xb5, 0xe0, 0x84, 0x41, 0xff, 0x41, 0x49, 0xe9, 0x9b, 0xd7, 0x97, 0x1e, 0xab, 0xc6,
- 0xf7, 0x2a, 0x99, 0x3e, 0xb0, 0xd5, 0xe2, 0x6b, 0x30, 0xb4, 0xeb, 0x44, 0x6e, 0xb9, 0x74, 0x62,
- 0x5d, 0xc5, 0x17, 0xae, 0x38, 0x91, 0xcb, 0x75, 0xfe, 0x05, 0xf5, 0xea, 0x88, 0x13, 0xb9, 0x85,
- 0x91, 0xc4, 0xac, 0x52, 0xf4, 0x2a, 0x8c, 0xc4, 0xad, 0xb0, 0xad, 0xa2, 0xb7, 0xce, 0xf1, 0x17,
- 0x49, 0x28, 0xe4, 0xfe, 0xe1, 0x3c, 0x32, 0xab, 0xa3, 0x60, 0x2c, 0xe8, 0xe7, 0x08, 0xd4, 0x54,
- 0xd5, 0x03, 0x8c, 0x59, 0x7d, 0xaf, 0x0a, 0x27, 0x73, 0xe4, 0x04, 0xfd, 0x82, 0x31, 0x6a, 0xaf,
- 0xf5, 0x2d, 0x68, 0xef, 0x73, 0xdc, 0x7e, 0x81, 0xed, 0x83, 0x5c, 0x21, 0x1b, 0x0f, 0x50, 0xfd,
- 0xcd, 0x98, 0x64, 0xab, 0xa7, 0xa0, 0xe2, 0xea, 0x69, 0xb5, 0x8f, 0x68, 0xf0, 0x69, 0x35, 0xaa,
- 0x9d, 0x03, 0xfc, 0xc6, 0xef, 0x0e, 0xc1, 0xa9, 0xbc, 0x5b, 0x9e, 0xe8, 0x97, 0xad, 0x4c, 0x46,
- 0xf0, 0x37, 0xfa, 0xbf, 0x2a, 0xca, 0xd3, 0x84, 0x8b, 0x1c, 0x08, 0x0b, 0x66, 0x8e, 0xf0, 0xc2,
- 0xd1, 0x16, 0xb5, 0xb3, 0xe8, 0xff, 0x88, 0x67, 0x76, 0x97, 0xfa, 0xe0, 0x33, 0x0f, 0xd0, 0x14,
- 0x91, 0x1c, 0x3e, 0xce, 0x44, 0xff, 0x4b, 0x70, 0x71, 0xf4, 0xbf, 0x6c, 0xc3, 0xdc, 0x0e, 0x8c,
- 0x6b, 0xfd, 0x1a, 0xa0, 0x08, 0x78, 0x74, 0x41, 0xd2, 0x5a, 0x3d, 0x40, 0x31, 0xf8, 0x7b, 0x16,
- 0x64, 0x42, 0x34, 0x94, 0xb3, 0xc5, 0xea, 0xe9, 0x6c, 0x39, 0x07, 0x43, 0x51, 0xe8, 0x93, 0x6c,
- 0xb6, 0x6a, 0x1c, 0xfa, 0x04, 0x33, 0x8c, 0x7a, 0x7a, 0xb0, 0xda, 0xeb, 0xe9, 0x41, 0xba, 0x0b,
- 0xf7, 0xc9, 0x3e, 0x91, 0xae, 0x0f, 0xa5, 0xbc, 0xaf, 0x51, 0x20, 0xe6, 0x38, 0xfb, 0xf7, 0xab,
- 0x30, 0xc2, 0xfd, 0x0b, 0x03, 0x5c, 0x93, 0x1b, 0x62, 0xab, 0x5f, 0xea, 0xd6, 0x25, 0x6f, 0xcd,
- 0x42, 0xdd, 0x49, 0x1c, 0x2e, 0x50, 0xaa, 0x6f, 0xa9, 0x7b, 0x00, 0x2d, 0x18, 0xbd, 0x9f, 0xcb,
- 0xec, 0x64, 0x81, 0xf3, 0xd0, 0xc6, 0x62, 0x17, 0x20, 0x66, 0xcf, 0x5c, 0x51, 0x1e, 0x22, 0xe7,
- 0xdb, 0x4b, 0xa5, 0xda, 0xd1, 0x54, 0xc5, 0x78, 0x6b, 0xd2, 0x64, 0x53, 0x0a, 0x81, 0x35, 0xde,
- 0x73, 0xaf, 0x40, 0x4d, 0x11, 0x17, 0x99, 0xf9, 0x13, 0xba, 0x48, 0xfe, 0x15, 0x98, 0xce, 0xd4,
- 0xd5, 0xd7, 0x2e, 0xe1, 0x47, 0x16, 0x9c, 0xe8, 0x7a, 0x2f, 0x15, 0xbd, 0x6b, 0xc1, 0x29, 0x3f,
- 0xc7, 0xb1, 0x54, 0x1c, 0x22, 0xd3, 0xd3, 0x25, 0xa5, 0xb6, 0x08, 0x79, 0x58, 0x9c, 0x5b, 0x9b,
- 0xcc, 0x62, 0x59, 0xc9, 0xcf, 0x62, 0x69, 0x7f, 0xdf, 0x02, 0xf1, 0xc9, 0x06, 0x6e, 0xfe, 0xac,
- 0x9b, 0xe6, 0xcf, 0x47, 0xcb, 0xc8, 0x40, 0x0f, 0xbb, 0xe7, 0x3f, 0x58, 0x80, 0x38, 0x41, 0xf6,
- 0xad, 0x3b, 0xee, 0xa5, 0xd3, 0xac, 0xf5, 0x54, 0x68, 0x14, 0x06, 0x6b, 0x54, 0x7d, 0x26, 0x34,
- 0x57, 0x6f, 0x44, 0x95, 0x7b, 0x1e, 0xbe, 0x5a, 0xe2, 0x79, 0xf8, 0xdf, 0xad, 0x42, 0x36, 0x8a,
- 0x01, 0x7d, 0x19, 0x26, 0x5a, 0x4e, 0xdb, 0xd9, 0xf2, 0x7c, 0x2f, 0xf1, 0x48, 0x5c, 0xee, 0x9c,
- 0x68, 0x45, 0x2b, 0x21, 0xfc, 0xbc, 0x1a, 0x04, 0x1b, 0x1c, 0xd1, 0x02, 0x40, 0x3b, 0xf2, 0xf6,
- 0x3d, 0x9f, 0xec, 0x30, 0xa3, 0x83, 0x05, 0x32, 0xf2, 0x43, 0x0f, 0x09, 0xc5, 0x1a, 0x45, 0x4e,
- 0xd0, 0x5c, 0xf5, 0x51, 0x04, 0xcd, 0x0d, 0xf5, 0x19, 0x34, 0x37, 0x5c, 0x2a, 0x68, 0x0e, 0xc3,
- 0x19, 0xe9, 0x9e, 0xa5, 0xff, 0xd7, 0x3c, 0x9f, 0xf0, 0x9c, 0x75, 0x22, 0xd4, 0x71, 0xee, 0xe8,
- 0x70, 0xfe, 0x0c, 0xce, 0xa5, 0xc0, 0x3d, 0x4a, 0xda, 0x1d, 0x38, 0xd9, 0x24, 0x91, 0xc7, 0x52,
- 0x0a, 0xb9, 0xe9, 0xf4, 0xfb, 0x22, 0xd4, 0xa2, 0xcc, 0xcc, 0xef, 0xf3, 0xd6, 0x99, 0x96, 0x98,
- 0x42, 0xce, 0xf4, 0x94, 0xa5, 0xfd, 0xd7, 0x2b, 0x30, 0x2a, 0xa2, 0x85, 0x06, 0xb8, 0x8a, 0x5c,
- 0x35, 0x76, 0x76, 0xcf, 0x16, 0xcd, 0x5c, 0xd6, 0x9c, 0x9e, 0x7b, 0xba, 0x66, 0x66, 0x4f, 0xf7,
- 0x7c, 0x39, 0x76, 0xc7, 0xef, 0xe6, 0x7e, 0xa7, 0x02, 0x53, 0x66, 0xd4, 0xd4, 0x00, 0x87, 0xe3,
- 0x2d, 0x18, 0x8d, 0x45, 0x28, 0x51, 0xa9, 0x07, 0xf9, 0xb3, 0x9f, 0x34, 0x7d, 0x6a, 0x5e, 0x04,
- 0x0f, 0x49, 0x76, 0xb9, 0xd1, 0x4a, 0xd5, 0x47, 0x11, 0xad, 0x64, 0xff, 0x3b, 0xa6, 0x52, 0xf5,
- 0x01, 0x1c, 0xf8, 0x82, 0xf0, 0xa6, 0xa9, 0x7a, 0x2f, 0x94, 0x92, 0x03, 0xd1, 0xb8, 0x1e, 0x0b,
- 0xc3, 0xbf, 0xb2, 0x60, 0x5c, 0x10, 0x0e, 0xbc, 0xf9, 0x9f, 0x35, 0x9b, 0xff, 0x74, 0xa9, 0xe6,
- 0xf7, 0x68, 0xf7, 0x3f, 0xa8, 0xa8, 0x76, 0x37, 0xc4, 0xeb, 0x9f, 0x85, 0xe9, 0x0b, 0xc7, 0xda,
- 0x51, 0x98, 0x84, 0xad, 0xd0, 0x17, 0x8b, 0xfb, 0x13, 0x69, 0x74, 0x39, 0x87, 0xdf, 0xd7, 0x7e,
- 0x63, 0x45, 0xcd, 0x02, 0xa7, 0xc3, 0x28, 0x11, 0x8b, 0x53, 0xde, 0xdb, 0xa3, 0x5b, 0xf2, 0x6d,
- 0x67, 0x0a, 0x13, 0x97, 0x32, 0xfa, 0x7d, 0xd3, 0x34, 0x0d, 0x17, 0x57, 0x9c, 0xb0, 0xc6, 0x55,
- 0xc6, 0x30, 0xb2, 0x1a, 0x86, 0x4d, 0xd7, 0xe9, 0x75, 0x01, 0xc7, 0x8a, 0xc2, 0x7e, 0x85, 0x69,
- 0x57, 0x36, 0x3c, 0xfd, 0xc5, 0x80, 0x7f, 0x63, 0x44, 0x0d, 0x2c, 0xf3, 0x8d, 0x5c, 0x87, 0x61,
- 0xda, 0x45, 0xb9, 0xfd, 0x2b, 0xa7, 0xca, 0x68, 0x13, 0xf4, 0x28, 0xb0, 0x28, 0x89, 0x31, 0x67,
- 0x83, 0x48, 0x97, 0xbf, 0xfd, 0x95, 0xd2, 0xda, 0xb1, 0x0f, 0x0f, 0x3b, 0xcb, 0x08, 0xc3, 0x12,
- 0x61, 0xac, 0x37, 0xb2, 0x29, 0x27, 0x57, 0x24, 0x02, 0xa7, 0x34, 0x68, 0x51, 0x58, 0xe9, 0xe6,
- 0xd3, 0xb0, 0xd2, 0x4a, 0x97, 0x43, 0xa2, 0x99, 0xe9, 0x17, 0x61, 0x5c, 0x25, 0xdd, 0x6e, 0xf0,
- 0xdc, 0xc9, 0x35, 0x6e, 0xb9, 0xac, 0xa6, 0x60, 0xac, 0xd3, 0xa0, 0x75, 0x38, 0xe9, 0xaa, 0x90,
- 0xd5, 0x46, 0x67, 0xcb, 0xf7, 0x5a, 0xb4, 0x28, 0xbf, 0x2e, 0xf2, 0xd8, 0xd1, 0xe1, 0xfc, 0xc9,
- 0x7a, 0x37, 0x1a, 0xe7, 0x95, 0x41, 0x9b, 0x30, 0x1d, 0xf3, 0xe4, 0xe2, 0xf2, 0x4a, 0x99, 0xc8,
- 0xc9, 0xf6, 0x9c, 0x74, 0xf4, 0x37, 0x4d, 0xf4, 0x7d, 0x06, 0xe2, 0x1a, 0x41, 0x80, 0x70, 0x96,
- 0x05, 0x7a, 0x03, 0xa6, 0x7c, 0xfd, 0x7d, 0xa4, 0x86, 0x88, 0xdc, 0x55, 0xe1, 0x0f, 0xc6, 0xeb,
- 0x49, 0x0d, 0x9c, 0xa1, 0x46, 0x6f, 0xc1, 0xac, 0x0e, 0x11, 0x17, 0xd6, 0x9d, 0x60, 0x87, 0xc4,
- 0x22, 0xab, 0xf1, 0x13, 0x47, 0x87, 0xf3, 0xb3, 0xd7, 0x7a, 0xd0, 0xe0, 0x9e, 0xa5, 0xd1, 0xab,
- 0x30, 0x21, 0x47, 0x52, 0x8b, 0xe2, 0x4d, 0x03, 0x6f, 0x34, 0x1c, 0x36, 0x28, 0xdf, 0xdf, 0x79,
- 0xc6, 0xd7, 0x68, 0x61, 0x6d, 0x39, 0x45, 0x5f, 0x81, 0x09, 0xbd, 0x8d, 0x42, 0x47, 0x7e, 0xbc,
- 0xfc, 0x9b, 0x53, 0x62, 0x59, 0x56, 0x2d, 0xd7, 0x71, 0xd8, 0xe0, 0x6d, 0xdf, 0x80, 0x91, 0xe6,
- 0x41, 0xdc, 0x4a, 0xfc, 0x87, 0xf5, 0x2a, 0x70, 0x0b, 0xa6, 0x33, 0xcf, 0xe7, 0xaa, 0x77, 0x98,
- 0xad, 0x87, 0xf5, 0x0e, 0xb3, 0xfd, 0x75, 0x0b, 0x86, 0x37, 0x1d, 0xaf, 0xf8, 0x3d, 0x80, 0x32,
- 0x4d, 0x46, 0x2f, 0xc3, 0x08, 0xd9, 0xde, 0x26, 0x2d, 0xf9, 0xae, 0xf3, 0x93, 0xd2, 0x9c, 0x59,
- 0x65, 0x50, 0x3a, 0x35, 0x59, 0x65, 0xfc, 0x2f, 0x16, 0xc4, 0xf6, 0x7f, 0xb4, 0x00, 0x36, 0x43,
- 0x5f, 0x1e, 0xd5, 0x14, 0xb4, 0x64, 0xb9, 0xeb, 0x65, 0x82, 0x67, 0x72, 0x5e, 0x26, 0x40, 0x29,
- 0xc3, 0x9c, 0x77, 0x09, 0x54, 0x6f, 0xaa, 0xa5, 0x7a, 0x33, 0xd4, 0x4f, 0x6f, 0xbe, 0x65, 0x81,
- 0x88, 0x98, 0x29, 0x21, 0x09, 0xae, 0xcc, 0x26, 0x6e, 0xa4, 0xa2, 0x78, 0xae, 0xcc, 0x6d, 0x0f,
- 0x91, 0x80, 0x42, 0xc9, 0xa6, 0x91, 0x76, 0xc2, 0xe0, 0x4a, 0xb7, 0xf0, 0xe3, 0x1c, 0xbd, 0xc1,
- 0x6c, 0xc7, 0xe2, 0x76, 0xf5, 0x95, 0x72, 0x8b, 0x25, 0xdb, 0xa6, 0x8c, 0x55, 0xf2, 0x25, 0x3d,
- 0xd9, 0xb6, 0x44, 0xe0, 0x94, 0x06, 0x3d, 0x0b, 0xa3, 0x71, 0x67, 0x8b, 0x91, 0x67, 0xc2, 0x67,
- 0x9a, 0x1c, 0x8c, 0x25, 0xde, 0xfe, 0x25, 0x04, 0x46, 0xd7, 0x8c, 0x44, 0x4f, 0xd6, 0x43, 0x4f,
- 0xf4, 0xf4, 0x36, 0x8c, 0x91, 0xbd, 0x76, 0x72, 0x50, 0xf7, 0xa2, 0x72, 0xe9, 0xf6, 0x56, 0x05,
- 0x75, 0x37, 0x77, 0x89, 0xc1, 0x8a, 0x63, 0x8f, 0xb4, 0x5d, 0xd5, 0x0f, 0x44, 0xda, 0xae, 0xa1,
- 0xbf, 0x90, 0xb4, 0x5d, 0x6f, 0xc1, 0xe8, 0x0e, 0x7f, 0xd7, 0x5f, 0x5c, 0xf0, 0x2b, 0x38, 0x03,
- 0xbb, 0xcc, 0x89, 0xbb, 0x73, 0xf1, 0x08, 0x04, 0x96, 0xec, 0xd0, 0x26, 0x8c, 0xf0, 0x7d, 0x87,
- 0xc8, 0x84, 0xf5, 0xf1, 0x32, 0x1e, 0x99, 0xee, 0xa4, 0x50, 0x22, 0x46, 0x4a, 0xf0, 0x92, 0x69,
- 0xba, 0x46, 0xdf, 0x7f, 0x9a, 0x2e, 0x95, 0x5c, 0x6b, 0xec, 0x61, 0x25, 0xd7, 0x32, 0x92, 0x94,
- 0xd5, 0x06, 0x91, 0xa4, 0xec, 0x5b, 0x16, 0x9c, 0x6e, 0xe7, 0x25, 0xf8, 0x13, 0x69, 0xb2, 0x3e,
- 0xfd, 0x00, 0x09, 0x0f, 0x8d, 0xaa, 0xd9, 0xa5, 0xab, 0x5c, 0x32, 0x9c, 0x5f, 0xb1, 0xcc, 0x76,
- 0x36, 0xfe, 0xfe, 0xb3, 0x9d, 0x0d, 0x3a, 0x9f, 0x56, 0x9a, 0xfb, 0x6c, 0x72, 0x20, 0xb9, 0xcf,
- 0xa6, 0x1e, 0x62, 0xee, 0x33, 0x2d, 0x6b, 0xd9, 0xf4, 0xc3, 0xcd, 0x5a, 0xb6, 0x0b, 0xe3, 0x6e,
- 0x78, 0x37, 0xb8, 0xeb, 0x44, 0xee, 0x52, 0x63, 0x5d, 0x24, 0xc9, 0x2a, 0xc8, 0xc9, 0x50, 0x4f,
- 0x0b, 0x18, 0x35, 0x70, 0xd7, 0x63, 0x8a, 0xc4, 0x3a, 0x6b, 0x91, 0xbf, 0xed, 0xc4, 0xfb, 0xcc,
- 0xdf, 0x66, 0x64, 0x41, 0x43, 0x83, 0xc8, 0x82, 0xf6, 0x65, 0x76, 0x45, 0x7b, 0xdb, 0xdb, 0xd9,
- 0x70, 0xda, 0xb3, 0x27, 0xcb, 0xd4, 0xb0, 0x22, 0xc9, 0xbb, 0x6b, 0x50, 0x28, 0x9c, 0x32, 0xed,
- 0xce, 0xb3, 0x76, 0xea, 0x51, 0xe7, 0x59, 0x3b, 0x3d, 0xc0, 0x3c, 0x6b, 0x67, 0x1e, 0x69, 0x9e,
- 0xb5, 0xc7, 0xfe, 0x42, 0xf2, 0xac, 0xfd, 0x55, 0x38, 0x7b, 0xfc, 0xe7, 0x48, 0x73, 0xf8, 0x36,
- 0x52, 0x97, 0x41, 0x26, 0x87, 0x2f, 0x33, 0x75, 0x34, 0xaa, 0xd2, 0xe9, 0x9e, 0xbe, 0x6f, 0xc1,
- 0x63, 0x3d, 0xf2, 0xa2, 0x94, 0xbe, 0xbb, 0xd0, 0x86, 0xe9, 0xb6, 0x59, 0xb4, 0xf4, 0xfd, 0x22,
- 0x23, 0x0f, 0x8b, 0x8a, 0x8d, 0xcb, 0x20, 0x70, 0x96, 0xfd, 0xf2, 0x47, 0x7f, 0xf2, 0xde, 0xd9,
- 0x0f, 0xfd, 0xf4, 0xbd, 0xb3, 0x1f, 0xfa, 0xa3, 0xf7, 0xce, 0x7e, 0xe8, 0x17, 0x8f, 0xce, 0x5a,
- 0x3f, 0x39, 0x3a, 0x6b, 0xfd, 0xf4, 0xe8, 0xac, 0xf5, 0xa7, 0x47, 0x67, 0xad, 0x6f, 0xfd, 0xd9,
- 0xd9, 0x0f, 0x7d, 0xbe, 0xb2, 0x7f, 0xf1, 0xff, 0x05, 0x00, 0x00, 0xff, 0xff, 0x55, 0x52, 0xb9,
- 0x48, 0x00, 0xb5, 0x00, 0x00,
+ 0xba, 0xaf, 0x61, 0xcd, 0xde, 0x1d, 0x25, 0x11, 0x92, 0x7a, 0xa7, 0x6b, 0x77, 0x5b, 0xd7, 0xdb,
+ 0x3d, 0xec, 0xee, 0xd9, 0xbb, 0xa5, 0x62, 0xc0, 0x91, 0x19, 0x1b, 0x81, 0x05, 0x47, 0x41, 0x20,
+ 0x24, 0x40, 0x12, 0x44, 0x09, 0x90, 0xc0, 0x89, 0x61, 0x2b, 0x8a, 0x94, 0x40, 0x8a, 0x65, 0x03,
+ 0x41, 0x6c, 0x47, 0x41, 0xe2, 0x40, 0xfa, 0x13, 0x1b, 0x36, 0xb0, 0x31, 0xd7, 0xf9, 0x97, 0xfc,
+ 0x08, 0x90, 0x5f, 0x59, 0x18, 0x49, 0x50, 0x9f, 0x5d, 0xd5, 0xd3, 0xb3, 0xdd, 0x73, 0xbc, 0x39,
+ 0x53, 0x46, 0xfe, 0xcd, 0xbc, 0xf7, 0xea, 0xd5, 0x47, 0xbf, 0x7a, 0xf5, 0xea, 0xd5, 0xab, 0x57,
+ 0x70, 0xe1, 0xee, 0xab, 0xf1, 0x82, 0x17, 0x2e, 0xde, 0xed, 0x6c, 0x92, 0x28, 0x20, 0x09, 0x89,
+ 0x17, 0xdb, 0x77, 0xb7, 0x17, 0x9d, 0xb6, 0xb7, 0xb8, 0x77, 0x71, 0x71, 0x9b, 0x04, 0x24, 0x72,
+ 0x12, 0xe2, 0x2e, 0xb4, 0xa3, 0x30, 0x09, 0xd1, 0x13, 0x9c, 0x7a, 0x21, 0xa5, 0x5e, 0x68, 0xdf,
+ 0xdd, 0x5e, 0x70, 0xda, 0xde, 0xc2, 0xde, 0xc5, 0xb9, 0x17, 0xb6, 0xbd, 0x64, 0xa7, 0xb3, 0xb9,
+ 0xd0, 0x0a, 0x77, 0x17, 0xb7, 0xc3, 0xed, 0x70, 0x91, 0x15, 0xda, 0xec, 0x6c, 0xb1, 0x7f, 0xec,
+ 0x0f, 0xfb, 0xc5, 0x99, 0xcd, 0x5d, 0xea, 0x5d, 0x75, 0x44, 0xe2, 0xb0, 0x13, 0xb5, 0x48, 0xb6,
+ 0x01, 0xc7, 0x94, 0x89, 0x17, 0x77, 0x49, 0xe2, 0xe4, 0x34, 0x7a, 0xee, 0x85, 0xfc, 0x32, 0x51,
+ 0x27, 0x48, 0xbc, 0xdd, 0xee, 0x2a, 0x5e, 0x3a, 0x9e, 0x3c, 0x6e, 0xed, 0x90, 0x5d, 0xa7, 0xab,
+ 0xd4, 0xc5, 0xfc, 0x52, 0x9d, 0xc4, 0xf3, 0x17, 0xbd, 0x20, 0x89, 0x93, 0x28, 0x5b, 0xc4, 0xfe,
+ 0x43, 0x0b, 0xce, 0x2d, 0xdd, 0x69, 0xae, 0xfa, 0x4e, 0x9c, 0x78, 0xad, 0x65, 0x3f, 0x6c, 0xdd,
+ 0x6d, 0x26, 0x61, 0x44, 0x6e, 0x87, 0x7e, 0x67, 0x97, 0x34, 0xd9, 0x00, 0xa0, 0x0b, 0x30, 0xb6,
+ 0xc7, 0xfe, 0xaf, 0xd7, 0x67, 0xad, 0x73, 0xd6, 0xf9, 0xda, 0xf2, 0xcc, 0x8f, 0x0f, 0xe6, 0x3f,
+ 0x72, 0x78, 0x30, 0x3f, 0x76, 0x5b, 0xc0, 0xb1, 0xa2, 0x40, 0xcf, 0xc0, 0xc8, 0x56, 0xbc, 0xb1,
+ 0xdf, 0x26, 0xb3, 0x15, 0x46, 0x3b, 0x25, 0x68, 0x47, 0xd6, 0x9a, 0x14, 0x8a, 0x05, 0x16, 0x2d,
+ 0x42, 0xad, 0xed, 0x44, 0x89, 0x97, 0x78, 0x61, 0x30, 0x5b, 0x3d, 0x67, 0x9d, 0x1f, 0x5e, 0x3e,
+ 0x21, 0x48, 0x6b, 0x0d, 0x89, 0xc0, 0x29, 0x0d, 0x6d, 0x46, 0x44, 0x1c, 0xf7, 0x66, 0xe0, 0xef,
+ 0xcf, 0x0e, 0x9d, 0xb3, 0xce, 0x8f, 0xa5, 0xcd, 0xc0, 0x02, 0x8e, 0x15, 0x85, 0xfd, 0x83, 0x0a,
+ 0x8c, 0x2d, 0x6d, 0x6d, 0x79, 0x81, 0x97, 0xec, 0xa3, 0xaf, 0xc0, 0x44, 0x10, 0xba, 0x44, 0xfe,
+ 0x67, 0xbd, 0x18, 0xbf, 0xf4, 0xdc, 0xc2, 0x71, 0xa2, 0xb4, 0x70, 0x43, 0x2b, 0xb1, 0x3c, 0x73,
+ 0x78, 0x30, 0x3f, 0xa1, 0x43, 0xb0, 0xc1, 0x11, 0xbd, 0x0d, 0xe3, 0xed, 0xd0, 0x55, 0x15, 0x54,
+ 0x58, 0x05, 0xcf, 0x1e, 0x5f, 0x41, 0x23, 0x2d, 0xb0, 0x3c, 0x7d, 0x78, 0x30, 0x3f, 0xae, 0x01,
+ 0xb0, 0xce, 0x0e, 0xf9, 0x30, 0x4d, 0xff, 0x06, 0x89, 0xa7, 0x6a, 0xa8, 0xb2, 0x1a, 0x5e, 0x28,
+ 0xae, 0x41, 0x2b, 0xb4, 0x7c, 0xf2, 0xf0, 0x60, 0x7e, 0x3a, 0x03, 0xc4, 0x59, 0xd6, 0xf6, 0xbb,
+ 0x30, 0xb5, 0x94, 0x24, 0x4e, 0x6b, 0x87, 0xb8, 0xfc, 0xfb, 0xa2, 0x97, 0x60, 0x28, 0x70, 0x76,
+ 0x89, 0xf8, 0xfa, 0xe7, 0xc4, 0xb0, 0x0f, 0xdd, 0x70, 0x76, 0xc9, 0xd1, 0xc1, 0xfc, 0xcc, 0xad,
+ 0xc0, 0x7b, 0xa7, 0x23, 0x64, 0x86, 0xc2, 0x30, 0xa3, 0x46, 0x97, 0x00, 0x5c, 0xb2, 0xe7, 0xb5,
+ 0x48, 0xc3, 0x49, 0x76, 0x84, 0x34, 0x20, 0x51, 0x16, 0xea, 0x0a, 0x83, 0x35, 0x2a, 0xfb, 0xeb,
+ 0x16, 0xd4, 0x96, 0xf6, 0x42, 0xcf, 0x6d, 0x84, 0x6e, 0x8c, 0x3a, 0x30, 0xdd, 0x8e, 0xc8, 0x16,
+ 0x89, 0x14, 0x68, 0xd6, 0x3a, 0x57, 0x3d, 0x3f, 0x7e, 0xe9, 0x52, 0x41, 0xbf, 0xcd, 0x42, 0xab,
+ 0x41, 0x12, 0xed, 0x2f, 0x3f, 0x26, 0xaa, 0x9e, 0xce, 0x60, 0x71, 0xb6, 0x0e, 0xfb, 0x6f, 0x55,
+ 0xe0, 0xf4, 0xd2, 0xbb, 0x9d, 0x88, 0xd4, 0xbd, 0xf8, 0x6e, 0x76, 0x2a, 0xb8, 0x5e, 0x7c, 0xf7,
+ 0x46, 0x3a, 0x18, 0x4a, 0x06, 0xeb, 0x02, 0x8e, 0x15, 0x05, 0x7a, 0x01, 0x46, 0xe9, 0xef, 0x5b,
+ 0x78, 0x5d, 0xf4, 0xfe, 0xa4, 0x20, 0x1e, 0xaf, 0x3b, 0x89, 0x53, 0xe7, 0x28, 0x2c, 0x69, 0xd0,
+ 0x75, 0x18, 0x6f, 0x39, 0xad, 0x1d, 0x2f, 0xd8, 0xbe, 0x1e, 0xba, 0x84, 0x7d, 0xe1, 0xda, 0xf2,
+ 0xf3, 0x94, 0x7c, 0x25, 0x05, 0x1f, 0x1d, 0xcc, 0xcf, 0xf2, 0xb6, 0x09, 0x16, 0x1a, 0x0e, 0xeb,
+ 0xe5, 0x91, 0xad, 0x26, 0xe2, 0x10, 0xe3, 0x04, 0x39, 0x93, 0xf0, 0xbc, 0x36, 0xa7, 0x86, 0xd9,
+ 0x9c, 0x9a, 0xe8, 0x31, 0x9f, 0xfe, 0xb9, 0x25, 0xc6, 0x64, 0xcd, 0xf3, 0x4d, 0xf5, 0x70, 0x09,
+ 0x20, 0x26, 0xad, 0x88, 0x24, 0xda, 0xa8, 0xa8, 0xcf, 0xdc, 0x54, 0x18, 0xac, 0x51, 0xd1, 0xc9,
+ 0x1f, 0xef, 0x38, 0x11, 0x93, 0x16, 0x31, 0x36, 0x6a, 0xf2, 0x37, 0x25, 0x02, 0xa7, 0x34, 0xc6,
+ 0xe4, 0xaf, 0x16, 0x4e, 0xfe, 0x7f, 0x63, 0xc1, 0xe8, 0xb2, 0x17, 0xb8, 0x5e, 0xb0, 0x8d, 0xde,
+ 0x82, 0x31, 0xaa, 0x95, 0x5d, 0x27, 0x71, 0xc4, 0xbc, 0x3f, 0x7f, 0xbc, 0xf0, 0xdc, 0xdc, 0xfc,
+ 0x2a, 0x69, 0x25, 0xd7, 0x49, 0xe2, 0xa4, 0xdd, 0x48, 0x61, 0x58, 0x71, 0x43, 0xb7, 0x60, 0x24,
+ 0x71, 0xa2, 0x6d, 0x92, 0x88, 0xe9, 0xfe, 0x42, 0x19, 0xbe, 0x98, 0x8a, 0x1a, 0x09, 0x5a, 0x24,
+ 0x55, 0x8c, 0x1b, 0x8c, 0x09, 0x16, 0xcc, 0xec, 0x16, 0x4c, 0xac, 0x38, 0x6d, 0x67, 0xd3, 0xf3,
+ 0xbd, 0xc4, 0x23, 0x31, 0xfa, 0x38, 0x54, 0x1d, 0xd7, 0x65, 0x82, 0x5f, 0x5b, 0x3e, 0x7d, 0x78,
+ 0x30, 0x5f, 0x5d, 0x72, 0xdd, 0xa3, 0x83, 0x79, 0x50, 0x54, 0xfb, 0x98, 0x52, 0xa0, 0xe7, 0x60,
+ 0xc8, 0x8d, 0xc2, 0xf6, 0x6c, 0x85, 0x51, 0x9e, 0xa1, 0x33, 0xb4, 0x1e, 0x85, 0xed, 0x0c, 0x29,
+ 0xa3, 0xb1, 0x7f, 0xaf, 0x02, 0x68, 0x85, 0xb4, 0x77, 0xd6, 0x9a, 0xc6, 0xb7, 0x3c, 0x0f, 0x63,
+ 0xbb, 0x61, 0xe0, 0x25, 0x61, 0x14, 0x8b, 0x0a, 0x99, 0x3c, 0x5c, 0x17, 0x30, 0xac, 0xb0, 0xe8,
+ 0x1c, 0x0c, 0xb5, 0xd3, 0x69, 0x3d, 0x21, 0x55, 0x02, 0x9b, 0xd0, 0x0c, 0x43, 0x29, 0x3a, 0x31,
+ 0x89, 0x84, 0x1c, 0x2b, 0x8a, 0x5b, 0x31, 0x89, 0x30, 0xc3, 0xa4, 0x92, 0x43, 0x65, 0x4a, 0x48,
+ 0x69, 0x46, 0x72, 0x28, 0x06, 0x6b, 0x54, 0xe8, 0xcb, 0x50, 0xe3, 0xff, 0x30, 0xd9, 0x62, 0x22,
+ 0x5b, 0xa8, 0x0c, 0xae, 0x85, 0x2d, 0xc7, 0xcf, 0x0e, 0xfe, 0x24, 0x93, 0x34, 0xc9, 0x08, 0xa7,
+ 0x3c, 0x0d, 0x49, 0x1b, 0x29, 0x94, 0xb4, 0xbf, 0x6b, 0x01, 0x5a, 0xf1, 0x02, 0x97, 0x44, 0x8f,
+ 0x60, 0xc9, 0xec, 0x6f, 0x12, 0xfc, 0x09, 0x6d, 0x5a, 0xb8, 0xdb, 0x0e, 0x03, 0x12, 0x24, 0x2b,
+ 0x61, 0xe0, 0xf2, 0x65, 0xf4, 0xd3, 0x30, 0x94, 0xd0, 0xaa, 0x78, 0xb3, 0x9e, 0x91, 0x9f, 0x85,
+ 0x56, 0x70, 0x74, 0x30, 0x7f, 0xa6, 0xbb, 0x04, 0x6b, 0x02, 0x2b, 0x83, 0x3e, 0x05, 0x23, 0x71,
+ 0xe2, 0x24, 0x9d, 0x58, 0x34, 0xf4, 0xa3, 0xb2, 0xa1, 0x4d, 0x06, 0x3d, 0x3a, 0x98, 0x9f, 0x56,
+ 0xc5, 0x38, 0x08, 0x8b, 0x02, 0xe8, 0x59, 0x18, 0xdd, 0x25, 0x71, 0xec, 0x6c, 0x4b, 0xc5, 0x36,
+ 0x2d, 0xca, 0x8e, 0x5e, 0xe7, 0x60, 0x2c, 0xf1, 0xe8, 0x29, 0x18, 0x26, 0x51, 0x14, 0x46, 0x42,
+ 0x22, 0x26, 0x05, 0xe1, 0xf0, 0x2a, 0x05, 0x62, 0x8e, 0xb3, 0x7f, 0x6a, 0xc1, 0xb4, 0x6a, 0x2b,
+ 0xaf, 0x6b, 0x80, 0x53, 0xdd, 0x05, 0x68, 0xc9, 0x8e, 0xc5, 0x6c, 0x82, 0x8d, 0x5f, 0xfa, 0xc4,
+ 0xf1, 0xbc, 0xbb, 0x07, 0x32, 0xad, 0x43, 0x81, 0x62, 0xac, 0xf1, 0xb5, 0x7f, 0xcf, 0x82, 0x93,
+ 0x99, 0x3e, 0x5d, 0xf3, 0xe2, 0x04, 0x7d, 0xa1, 0xab, 0x5f, 0x17, 0x7a, 0xd7, 0x1d, 0x2f, 0x50,
+ 0x5a, 0x26, 0xf8, 0x5e, 0xcc, 0xfb, 0xa6, 0xa4, 0x44, 0x42, 0xb4, 0x9e, 0x61, 0x18, 0xf6, 0x12,
+ 0xb2, 0x2b, 0x3b, 0xf5, 0x42, 0xc9, 0x4e, 0xf1, 0xd6, 0xa5, 0xdf, 0x66, 0x9d, 0xf2, 0xc0, 0x9c,
+ 0x95, 0xfd, 0xbf, 0x2c, 0xa8, 0xad, 0x84, 0xc1, 0x96, 0xb7, 0x7d, 0xdd, 0x69, 0x0f, 0xf0, 0xab,
+ 0x34, 0x61, 0x88, 0x71, 0xe5, 0x4d, 0xbf, 0x58, 0xd4, 0x74, 0xd1, 0xa0, 0x05, 0xba, 0x72, 0x72,
+ 0x93, 0x40, 0x29, 0x25, 0x0a, 0xc2, 0x8c, 0xd9, 0xdc, 0x2b, 0x50, 0x53, 0x04, 0x68, 0x06, 0xaa,
+ 0x77, 0x09, 0xb7, 0x17, 0x6b, 0x98, 0xfe, 0x44, 0xa7, 0x60, 0x78, 0xcf, 0xf1, 0x3b, 0x62, 0xaa,
+ 0x62, 0xfe, 0xe7, 0xd3, 0x95, 0x57, 0x2d, 0xfb, 0x47, 0x16, 0x9c, 0x52, 0x95, 0x5c, 0x25, 0xfb,
+ 0x4d, 0xe2, 0x93, 0x56, 0x12, 0x46, 0xe8, 0x3d, 0x0b, 0x4e, 0xf9, 0x39, 0x4a, 0x48, 0x8c, 0xc6,
+ 0x83, 0xa8, 0xaf, 0x27, 0x44, 0xc3, 0x4f, 0xe5, 0x61, 0x71, 0x6e, 0x6d, 0xe8, 0x49, 0xde, 0x17,
+ 0x3e, 0x73, 0xc7, 0x05, 0x83, 0xea, 0x55, 0xb2, 0xcf, 0x3a, 0x66, 0xff, 0xd0, 0x82, 0x49, 0xd5,
+ 0xfc, 0x81, 0x8b, 0xdd, 0x35, 0x53, 0xec, 0x3e, 0x5e, 0xf2, 0xdb, 0xf5, 0x10, 0xb8, 0x7f, 0x58,
+ 0x81, 0xd3, 0x8a, 0xc6, 0x50, 0xc4, 0x1f, 0x92, 0xb1, 0xef, 0xaf, 0xbb, 0x57, 0xc9, 0xfe, 0x46,
+ 0x48, 0x57, 0xd2, 0xfc, 0xee, 0xa2, 0x8b, 0x30, 0xee, 0x92, 0x2d, 0xa7, 0xe3, 0x27, 0xca, 0x50,
+ 0x1c, 0xe6, 0x3b, 0x88, 0x7a, 0x0a, 0xc6, 0x3a, 0x8d, 0xfd, 0x07, 0x35, 0x36, 0x25, 0x13, 0xc7,
+ 0x0b, 0x48, 0x44, 0x97, 0x66, 0xcd, 0x9e, 0x9f, 0xd0, 0xed, 0x79, 0x61, 0xbb, 0x3f, 0x05, 0xc3,
+ 0xde, 0x2e, 0x55, 0xd6, 0x15, 0x53, 0x07, 0xaf, 0x53, 0x20, 0xe6, 0x38, 0xf4, 0x34, 0x8c, 0xb6,
+ 0xc2, 0xdd, 0x5d, 0x27, 0x70, 0x67, 0xab, 0xcc, 0x58, 0x18, 0xa7, 0xfa, 0x7c, 0x85, 0x83, 0xb0,
+ 0xc4, 0xa1, 0x27, 0x60, 0xc8, 0x89, 0xb6, 0xe3, 0xd9, 0x21, 0x46, 0x33, 0x46, 0x6b, 0x5a, 0x8a,
+ 0xb6, 0x63, 0xcc, 0xa0, 0xd4, 0x08, 0xb8, 0x17, 0x46, 0x77, 0xbd, 0x60, 0xbb, 0xee, 0x45, 0x6c,
+ 0x45, 0xd7, 0x8c, 0x80, 0x3b, 0x0a, 0x83, 0x35, 0x2a, 0xd4, 0x80, 0xe1, 0x76, 0x18, 0x25, 0xf1,
+ 0xec, 0x08, 0x1b, 0xce, 0xe7, 0x0b, 0xa5, 0x87, 0xf7, 0xbb, 0x11, 0x46, 0x49, 0xda, 0x15, 0xfa,
+ 0x2f, 0xc6, 0x9c, 0x11, 0x5a, 0x81, 0x2a, 0x09, 0xf6, 0x66, 0x47, 0x19, 0xbf, 0x8f, 0x1d, 0xcf,
+ 0x6f, 0x35, 0xd8, 0xbb, 0xed, 0x44, 0xe9, 0x14, 0x5a, 0x0d, 0xf6, 0x30, 0x2d, 0x8d, 0x5a, 0x50,
+ 0x93, 0x5e, 0x83, 0x78, 0x76, 0xac, 0x8c, 0x80, 0x61, 0x41, 0x8e, 0xc9, 0x3b, 0x1d, 0x2f, 0x22,
+ 0xbb, 0x24, 0x48, 0xe2, 0xd4, 0x12, 0x96, 0xd8, 0x18, 0xa7, 0x7c, 0x51, 0x0b, 0x26, 0xb8, 0xe1,
+ 0x70, 0x3d, 0xec, 0x04, 0x49, 0x3c, 0x5b, 0x63, 0x4d, 0x2e, 0xd8, 0x6a, 0xde, 0x4e, 0x4b, 0x2c,
+ 0x9f, 0x12, 0xec, 0x27, 0x34, 0x60, 0x8c, 0x0d, 0xa6, 0xe8, 0x6d, 0x98, 0xf4, 0xbd, 0x3d, 0x12,
+ 0x90, 0x38, 0x6e, 0x44, 0xe1, 0x26, 0x99, 0x05, 0xd6, 0x9b, 0xa7, 0x8a, 0xb6, 0x5d, 0xe1, 0x26,
+ 0x59, 0x3e, 0x71, 0x78, 0x30, 0x3f, 0x79, 0x4d, 0x2f, 0x8d, 0x4d, 0x66, 0xe8, 0xcb, 0x30, 0x45,
+ 0xad, 0x14, 0x2f, 0x65, 0x3f, 0x5e, 0x9e, 0x3d, 0x3a, 0x3c, 0x98, 0x9f, 0xc2, 0x46, 0x71, 0x9c,
+ 0x61, 0x87, 0x36, 0xa0, 0xe6, 0x7b, 0x5b, 0xa4, 0xb5, 0xdf, 0xf2, 0xc9, 0xec, 0x04, 0xe3, 0x5d,
+ 0x30, 0xe5, 0xae, 0x49, 0x72, 0x6e, 0x19, 0xaa, 0xbf, 0x38, 0x65, 0x84, 0x6e, 0xc3, 0x99, 0x84,
+ 0x44, 0xbb, 0x5e, 0xe0, 0xd0, 0xe5, 0x5a, 0x98, 0x2d, 0x6c, 0x6f, 0x3b, 0xc9, 0xa4, 0xf6, 0xac,
+ 0x18, 0xd8, 0x33, 0x1b, 0xb9, 0x54, 0xb8, 0x47, 0x69, 0x74, 0x13, 0xa6, 0xd9, 0x7c, 0x6a, 0x74,
+ 0x7c, 0xbf, 0x11, 0xfa, 0x5e, 0x6b, 0x7f, 0x76, 0x8a, 0x31, 0x7c, 0x5a, 0xee, 0x58, 0xd7, 0x4d,
+ 0x34, 0xb5, 0xe8, 0xd3, 0x7f, 0x38, 0x5b, 0x1a, 0xf9, 0x30, 0x1d, 0x93, 0x56, 0x27, 0xf2, 0x92,
+ 0x7d, 0x2a, 0xfb, 0xe4, 0x7e, 0x32, 0x3b, 0x5d, 0x66, 0x87, 0xd2, 0x34, 0x0b, 0x71, 0x77, 0x41,
+ 0x06, 0x88, 0xb3, 0xac, 0xa9, 0xaa, 0x88, 0x13, 0xd7, 0x0b, 0x66, 0x67, 0x98, 0x49, 0xaa, 0xe6,
+ 0x57, 0x93, 0x02, 0x31, 0xc7, 0xb1, 0x0d, 0x1f, 0xfd, 0x71, 0x93, 0xea, 0xde, 0x13, 0x8c, 0x30,
+ 0xdd, 0xf0, 0x49, 0x04, 0x4e, 0x69, 0xe8, 0x6a, 0x95, 0x24, 0xfb, 0xb3, 0x88, 0x91, 0xaa, 0xa9,
+ 0xb6, 0xb1, 0xf1, 0x79, 0x4c, 0xe1, 0xf6, 0x26, 0x4c, 0xa9, 0x69, 0xcd, 0x46, 0x07, 0xcd, 0xc3,
+ 0x30, 0xd5, 0x5c, 0x72, 0xdf, 0x52, 0xa3, 0x4d, 0xa0, 0x0a, 0x2d, 0xc6, 0x1c, 0xce, 0x9a, 0xe0,
+ 0xbd, 0x4b, 0x96, 0xf7, 0x13, 0xc2, 0xed, 0xd7, 0xaa, 0xd6, 0x04, 0x89, 0xc0, 0x29, 0x8d, 0xfd,
+ 0x7f, 0xf8, 0x8a, 0x98, 0xea, 0x8e, 0x12, 0x7a, 0xf3, 0x02, 0x8c, 0xed, 0x84, 0x71, 0x42, 0xa9,
+ 0x59, 0x1d, 0xc3, 0xe9, 0x2a, 0x78, 0x45, 0xc0, 0xb1, 0xa2, 0x40, 0xaf, 0xc1, 0x64, 0x4b, 0xaf,
+ 0x40, 0xa8, 0xf2, 0xd3, 0xa2, 0x88, 0x59, 0x3b, 0x36, 0x69, 0xd1, 0xab, 0x30, 0xc6, 0x9c, 0x78,
+ 0xad, 0xd0, 0x17, 0x96, 0xb2, 0x5c, 0x99, 0xc6, 0x1a, 0x02, 0x7e, 0xa4, 0xfd, 0xc6, 0x8a, 0x9a,
+ 0xee, 0x37, 0x68, 0x13, 0xd6, 0x1b, 0x42, 0xdd, 0xaa, 0xfd, 0xc6, 0x15, 0x06, 0xc5, 0x02, 0x6b,
+ 0xff, 0x8b, 0x8a, 0x36, 0xca, 0xd4, 0xe2, 0x23, 0xe8, 0x0b, 0x30, 0x7a, 0xcf, 0xf1, 0x12, 0x2f,
+ 0xd8, 0x16, 0x2b, 0xe8, 0x8b, 0x25, 0x75, 0x2f, 0x2b, 0x7e, 0x87, 0x17, 0xe5, 0xeb, 0x84, 0xf8,
+ 0x83, 0x25, 0x43, 0xca, 0x3b, 0xea, 0x04, 0x01, 0xe5, 0x5d, 0xe9, 0x9f, 0x37, 0xe6, 0x45, 0x39,
+ 0x6f, 0xf1, 0x07, 0x4b, 0x86, 0x68, 0x0b, 0x40, 0xce, 0x3e, 0xe2, 0x0a, 0xe7, 0xd9, 0x27, 0xfb,
+ 0x61, 0xbf, 0xa1, 0x4a, 0x2f, 0x4f, 0xd1, 0x95, 0x29, 0xfd, 0x8f, 0x35, 0xce, 0x76, 0xc4, 0x0c,
+ 0x91, 0xee, 0x66, 0xa1, 0xcf, 0xd3, 0x09, 0xe0, 0x44, 0x09, 0x71, 0x97, 0x92, 0x62, 0x33, 0x38,
+ 0xb5, 0xa6, 0x36, 0xbc, 0x5d, 0xa2, 0x4f, 0x15, 0xc1, 0x02, 0xa7, 0xdc, 0xec, 0xef, 0x55, 0x61,
+ 0xb6, 0x57, 0x63, 0xa9, 0x40, 0x92, 0xfb, 0x5e, 0xb2, 0x42, 0x0d, 0x05, 0xcb, 0x14, 0xc8, 0x55,
+ 0x01, 0xc7, 0x8a, 0x82, 0x4a, 0x46, 0xec, 0x6d, 0x07, 0x8e, 0x2f, 0x84, 0x57, 0x49, 0x46, 0x93,
+ 0x41, 0xb1, 0xc0, 0x52, 0xba, 0x88, 0x38, 0xb1, 0xf0, 0xdc, 0x6a, 0x12, 0x84, 0x19, 0x14, 0x0b,
+ 0xac, 0xbe, 0xeb, 0x1b, 0x2a, 0xd8, 0xf5, 0x19, 0x03, 0x34, 0xfc, 0x30, 0x07, 0x08, 0xbd, 0x0d,
+ 0xb0, 0xe5, 0x05, 0x5e, 0xbc, 0xc3, 0x78, 0x8f, 0xf4, 0xc9, 0x5b, 0x19, 0x23, 0x6b, 0x8a, 0x07,
+ 0xd6, 0xf8, 0xa1, 0x97, 0x61, 0x5c, 0x4d, 0xcc, 0xf5, 0xfa, 0xec, 0xa8, 0xe9, 0xe9, 0x4b, 0xb5,
+ 0x54, 0x1d, 0xeb, 0x74, 0xf6, 0x57, 0xb3, 0x92, 0x22, 0xe6, 0x83, 0x36, 0xb6, 0x56, 0xd9, 0xb1,
+ 0xad, 0x1c, 0x3f, 0xb6, 0xf6, 0x7f, 0xa9, 0xd2, 0xcd, 0xb2, 0x56, 0x59, 0x27, 0x2e, 0xa1, 0xcb,
+ 0xde, 0xa4, 0x8a, 0xdd, 0x49, 0x88, 0x98, 0x8d, 0x17, 0xfa, 0x99, 0x2e, 0xfa, 0x32, 0x40, 0x67,
+ 0x01, 0xe7, 0x84, 0x76, 0xa0, 0xe6, 0x3b, 0x31, 0xdb, 0x3d, 0x12, 0x31, 0x0b, 0xfb, 0x63, 0x9b,
+ 0x1a, 0xdf, 0x4e, 0x9c, 0x68, 0xeb, 0x2c, 0xaf, 0x25, 0x65, 0x4e, 0x57, 0x25, 0x6a, 0x14, 0xc8,
+ 0xa3, 0x02, 0xd5, 0x1c, 0x6a, 0x39, 0xec, 0x63, 0x8e, 0x43, 0xaf, 0xc2, 0x44, 0x44, 0x98, 0x9c,
+ 0xac, 0x50, 0xbb, 0x87, 0x89, 0xdd, 0x70, 0x6a, 0x20, 0x61, 0x0d, 0x87, 0x0d, 0xca, 0xd4, 0x3e,
+ 0x1e, 0x39, 0xc6, 0x3e, 0x7e, 0x16, 0x46, 0xd9, 0x0f, 0x25, 0x15, 0xea, 0x0b, 0xad, 0x73, 0x30,
+ 0x96, 0xf8, 0xac, 0x10, 0x8d, 0x95, 0x14, 0xa2, 0xe7, 0x60, 0xaa, 0xee, 0x90, 0xdd, 0x30, 0x58,
+ 0x0d, 0xdc, 0x76, 0xe8, 0x05, 0x09, 0x9a, 0x85, 0x21, 0xb6, 0x92, 0xf0, 0xb9, 0x3e, 0x44, 0x39,
+ 0xe0, 0x21, 0x6a, 0xe3, 0xda, 0xff, 0xd7, 0x82, 0xc9, 0x3a, 0xf1, 0x49, 0x42, 0x6e, 0xb6, 0x99,
+ 0xbf, 0x01, 0xad, 0x01, 0xda, 0x8e, 0x9c, 0x16, 0x69, 0x90, 0xc8, 0x0b, 0xdd, 0x26, 0x69, 0x85,
+ 0x01, 0xf3, 0xb0, 0xd3, 0xa5, 0xf1, 0xcc, 0xe1, 0xc1, 0x3c, 0xba, 0xdc, 0x85, 0xc5, 0x39, 0x25,
+ 0x90, 0x0b, 0x93, 0xed, 0x88, 0x18, 0x0e, 0x12, 0xab, 0xd8, 0x2c, 0x6f, 0xe8, 0x45, 0xb8, 0xd5,
+ 0x68, 0x80, 0xb0, 0xc9, 0x14, 0x7d, 0x16, 0x66, 0xc2, 0xa8, 0xbd, 0xe3, 0x04, 0x75, 0xd2, 0x26,
+ 0x81, 0x4b, 0x4d, 0x65, 0xe1, 0x05, 0x3b, 0x75, 0x78, 0x30, 0x3f, 0x73, 0x33, 0x83, 0xc3, 0x5d,
+ 0xd4, 0xf6, 0xaf, 0x57, 0xe0, 0x74, 0x3d, 0xbc, 0x17, 0xdc, 0x73, 0x22, 0x77, 0xa9, 0xb1, 0xce,
+ 0xed, 0x5f, 0xe6, 0x55, 0x94, 0xde, 0x4c, 0xab, 0xa7, 0x37, 0xf3, 0x8b, 0x30, 0xb6, 0xe5, 0x11,
+ 0xdf, 0xc5, 0x64, 0x4b, 0x74, 0xef, 0x62, 0x19, 0x2f, 0xc6, 0x1a, 0x2d, 0x23, 0x3d, 0x01, 0xdc,
+ 0x99, 0xba, 0x26, 0xd8, 0x60, 0xc5, 0x10, 0x75, 0x60, 0x46, 0x1a, 0xf8, 0x12, 0x2b, 0x66, 0xc7,
+ 0x8b, 0xe5, 0xf6, 0x0f, 0x66, 0x35, 0x6c, 0x3c, 0x70, 0x86, 0x21, 0xee, 0xaa, 0x82, 0x6e, 0xcc,
+ 0x76, 0xe9, 0xba, 0x30, 0xc4, 0x64, 0x85, 0x6d, 0xcc, 0xd8, 0xce, 0x91, 0x41, 0xed, 0x7f, 0x6a,
+ 0xc1, 0x63, 0x5d, 0xa3, 0x25, 0xb6, 0xd5, 0x6f, 0xc9, 0xfd, 0x2c, 0x3f, 0x8e, 0x29, 0x68, 0x65,
+ 0xee, 0x98, 0x97, 0xdb, 0xdb, 0x56, 0x4a, 0xec, 0x6d, 0x6f, 0xc2, 0xa9, 0xd5, 0xdd, 0x76, 0xb2,
+ 0x5f, 0xf7, 0x4c, 0x27, 0xec, 0x2b, 0x30, 0xb2, 0x4b, 0x5c, 0xaf, 0xb3, 0x2b, 0x3e, 0xeb, 0xbc,
+ 0x54, 0xa4, 0xd7, 0x19, 0xf4, 0xe8, 0x60, 0x7e, 0xb2, 0x99, 0x84, 0x91, 0xb3, 0x4d, 0x38, 0x00,
+ 0x0b, 0x72, 0xfb, 0x7d, 0x0b, 0xa6, 0xe5, 0x84, 0x5a, 0x72, 0xdd, 0x88, 0xc4, 0x31, 0x9a, 0x83,
+ 0x8a, 0xd7, 0x16, 0x8c, 0x40, 0x30, 0xaa, 0xac, 0x37, 0x70, 0xc5, 0x6b, 0xa3, 0x2f, 0x40, 0x8d,
+ 0xfb, 0xee, 0x53, 0xe1, 0xe8, 0xf3, 0x2c, 0x80, 0x6d, 0x3a, 0x36, 0x24, 0x0f, 0x9c, 0xb2, 0x93,
+ 0x06, 0x25, 0x53, 0xd5, 0x55, 0xd3, 0x93, 0x7c, 0x45, 0xc0, 0xb1, 0xa2, 0x40, 0xe7, 0x61, 0x2c,
+ 0x08, 0x5d, 0x7e, 0xac, 0xc2, 0x17, 0x5c, 0x26, 0x72, 0x37, 0x04, 0x0c, 0x2b, 0xac, 0xfd, 0x0d,
+ 0x0b, 0x26, 0x64, 0x1f, 0x4b, 0xda, 0xb6, 0x74, 0x92, 0xa4, 0x76, 0x6d, 0x3a, 0x49, 0xa8, 0x6d,
+ 0xca, 0x30, 0x86, 0x49, 0x5a, 0xed, 0xc7, 0x24, 0xb5, 0x7f, 0x58, 0x81, 0x29, 0xd9, 0x9c, 0x66,
+ 0x67, 0x33, 0x26, 0x09, 0xfa, 0x12, 0xd4, 0x1c, 0x3e, 0xf8, 0x44, 0xca, 0xd9, 0x0b, 0x45, 0x1b,
+ 0x73, 0xe3, 0x9b, 0xa5, 0x56, 0xc1, 0x92, 0xe4, 0x83, 0x53, 0x96, 0x68, 0x0f, 0x4e, 0x04, 0x61,
+ 0xc2, 0xd6, 0x03, 0x85, 0x2f, 0xe7, 0x05, 0xcd, 0xd6, 0xf3, 0xb8, 0xa8, 0xe7, 0xc4, 0x8d, 0x2c,
+ 0x3f, 0xdc, 0x5d, 0x05, 0xba, 0x29, 0x9d, 0x17, 0x55, 0x56, 0xd7, 0x73, 0xe5, 0xea, 0xea, 0xed,
+ 0xbb, 0xb0, 0x7f, 0xc7, 0x82, 0x9a, 0x24, 0x1b, 0xa4, 0x13, 0xfc, 0x0e, 0x8c, 0xc6, 0xec, 0xd3,
+ 0xc8, 0x61, 0xba, 0x50, 0xae, 0xe9, 0xfc, 0x7b, 0xa6, 0x8b, 0x1f, 0xff, 0x1f, 0x63, 0xc9, 0x8d,
+ 0xb9, 0x1e, 0x55, 0x07, 0x3e, 0x64, 0xae, 0x47, 0xd5, 0xae, 0x1e, 0xae, 0xc7, 0x5f, 0xb3, 0x60,
+ 0x84, 0x3b, 0x84, 0xca, 0x79, 0xd5, 0x34, 0xe7, 0x71, 0xca, 0xf1, 0x36, 0x05, 0x0a, 0x5f, 0x32,
+ 0xba, 0x03, 0x35, 0xf6, 0x63, 0x2d, 0x0a, 0x77, 0xc5, 0x2a, 0xf0, 0x5c, 0x19, 0x87, 0x14, 0xd7,
+ 0x7a, 0x5c, 0x95, 0xdc, 0x96, 0x0c, 0x70, 0xca, 0xcb, 0xfe, 0x51, 0x95, 0x4e, 0xf9, 0x94, 0xd4,
+ 0x58, 0xd3, 0xac, 0x47, 0xb1, 0xa6, 0x55, 0x06, 0xbf, 0xa6, 0xbd, 0x03, 0xd3, 0x2d, 0xcd, 0x09,
+ 0x9f, 0xae, 0xa4, 0x97, 0x4a, 0xba, 0x98, 0x35, 0xcf, 0x3d, 0x77, 0x80, 0xac, 0x98, 0xec, 0x70,
+ 0x96, 0x3f, 0x22, 0x30, 0xc1, 0x8f, 0x0f, 0x45, 0x7d, 0x43, 0xac, 0xbe, 0xc5, 0x42, 0x5f, 0x0b,
+ 0x2f, 0xa1, 0x2a, 0x63, 0x21, 0x26, 0x4d, 0x8d, 0x11, 0x36, 0xd8, 0xda, 0xbf, 0x3a, 0x0c, 0xc3,
+ 0xab, 0x7b, 0x24, 0x48, 0x06, 0x38, 0xc5, 0x77, 0x61, 0xca, 0x0b, 0xf6, 0x42, 0x7f, 0x8f, 0xb8,
+ 0x1c, 0xff, 0x60, 0xcb, 0xd9, 0x19, 0x51, 0xc9, 0xd4, 0xba, 0xc1, 0x0c, 0x67, 0x98, 0x0f, 0x62,
+ 0x1b, 0xf9, 0x26, 0x8c, 0x70, 0x89, 0x10, 0x7b, 0xc8, 0x02, 0xc7, 0x28, 0x1b, 0x50, 0x31, 0x73,
+ 0xd2, 0xcd, 0x2e, 0xf7, 0xc9, 0x0a, 0x46, 0x68, 0x07, 0xa6, 0xb6, 0xbc, 0x28, 0x4e, 0xe8, 0x6e,
+ 0x30, 0x4e, 0x9c, 0xdd, 0x76, 0xdf, 0x5b, 0x48, 0x35, 0x1e, 0x6b, 0x06, 0x1f, 0x9c, 0xe1, 0x8b,
+ 0x08, 0x4c, 0xd2, 0x1d, 0x4c, 0x5a, 0xd1, 0x68, 0x9f, 0x15, 0x29, 0xcf, 0xd1, 0x35, 0x9d, 0x0d,
+ 0x36, 0xb9, 0x52, 0x35, 0xd4, 0x62, 0xfb, 0x9d, 0x31, 0xb6, 0x92, 0x2b, 0x35, 0xc4, 0x37, 0x3a,
+ 0x1c, 0x47, 0xb5, 0x19, 0x3b, 0x27, 0xae, 0x99, 0xda, 0x2c, 0x3d, 0x0d, 0xb6, 0xbf, 0x4b, 0xd7,
+ 0x1d, 0x3a, 0x7e, 0x03, 0x57, 0xd9, 0x57, 0x4c, 0x95, 0xfd, 0x54, 0x89, 0x6f, 0xda, 0x43, 0x5d,
+ 0x7f, 0x05, 0xc6, 0xb5, 0x4f, 0x8e, 0x16, 0xa1, 0xd6, 0x92, 0x47, 0x9a, 0x42, 0x6f, 0x2b, 0xa3,
+ 0x41, 0x9d, 0x75, 0xe2, 0x94, 0x86, 0x8e, 0x0a, 0x35, 0xb6, 0xb2, 0x61, 0x0f, 0xd4, 0x14, 0xc3,
+ 0x0c, 0x63, 0xbf, 0x08, 0xb0, 0x7a, 0x9f, 0xb4, 0x96, 0x5a, 0xec, 0xb4, 0x5d, 0x3b, 0x22, 0xb1,
+ 0x7a, 0x1f, 0x91, 0xd0, 0xa1, 0x9c, 0x5a, 0x5b, 0x31, 0xac, 0xd7, 0x05, 0x00, 0x6e, 0x05, 0xde,
+ 0xb9, 0x73, 0x43, 0x3a, 0x35, 0xb9, 0xe7, 0x49, 0x41, 0xb1, 0x46, 0x81, 0x1e, 0x87, 0xaa, 0xdf,
+ 0x09, 0x84, 0x71, 0x36, 0x7a, 0x78, 0x30, 0x5f, 0xbd, 0xd6, 0x09, 0x30, 0x85, 0x69, 0xf1, 0x05,
+ 0xd5, 0xd2, 0xf1, 0x05, 0xc5, 0x11, 0x76, 0xdf, 0xaa, 0xc2, 0xcc, 0x9a, 0x4f, 0xee, 0x1b, 0xad,
+ 0x7e, 0x06, 0x46, 0xdc, 0xc8, 0xdb, 0x23, 0x51, 0xd6, 0x79, 0x51, 0x67, 0x50, 0x2c, 0xb0, 0xa5,
+ 0x43, 0x1e, 0x8c, 0x70, 0x8f, 0xea, 0x80, 0xc3, 0x3d, 0x0a, 0xfb, 0x8c, 0xb6, 0x60, 0x34, 0xe4,
+ 0x9b, 0xe7, 0xd9, 0x61, 0x26, 0x8a, 0xaf, 0x1d, 0xdf, 0x98, 0xec, 0xf8, 0x2c, 0x88, 0xad, 0x37,
+ 0x3f, 0x7e, 0x56, 0x5a, 0x4c, 0x40, 0xb1, 0x64, 0x3e, 0xf7, 0x69, 0x98, 0xd0, 0x29, 0xfb, 0x3a,
+ 0x87, 0xfe, 0x45, 0x0b, 0x4e, 0xae, 0xf9, 0x61, 0xeb, 0x6e, 0x26, 0x26, 0xe5, 0x65, 0x18, 0xa7,
+ 0x93, 0x29, 0x36, 0x02, 0xb5, 0x8c, 0x88, 0x34, 0x81, 0xc2, 0x3a, 0x9d, 0x56, 0xec, 0xd6, 0xad,
+ 0xf5, 0x7a, 0x5e, 0x20, 0x9b, 0x40, 0x61, 0x9d, 0xce, 0xfe, 0xcf, 0x16, 0x3c, 0x79, 0x79, 0x65,
+ 0xb5, 0x41, 0xa2, 0xd8, 0x8b, 0x13, 0x12, 0x24, 0x5d, 0xb1, 0x74, 0xcf, 0xc0, 0x48, 0xdb, 0xd5,
+ 0x9a, 0xa2, 0x44, 0xa0, 0x51, 0x67, 0xad, 0x10, 0xd8, 0x0f, 0x4b, 0x40, 0xe9, 0xaf, 0x59, 0x70,
+ 0xf2, 0xb2, 0x97, 0x60, 0xd2, 0x0e, 0xb3, 0xe1, 0x6f, 0x11, 0x69, 0x87, 0xb1, 0x97, 0x84, 0xd1,
+ 0x7e, 0x36, 0xfc, 0x0d, 0x2b, 0x0c, 0xd6, 0xa8, 0x78, 0xcd, 0x7b, 0x5e, 0x4c, 0x5b, 0x5a, 0x31,
+ 0x37, 0x75, 0x58, 0xc0, 0xb1, 0xa2, 0xa0, 0x1d, 0x73, 0xbd, 0x88, 0x19, 0x09, 0xfb, 0x62, 0x06,
+ 0xab, 0x8e, 0xd5, 0x25, 0x02, 0xa7, 0x34, 0xf6, 0xdf, 0xb7, 0xe0, 0xf4, 0x65, 0xbf, 0x13, 0x27,
+ 0x24, 0xda, 0x8a, 0x8d, 0xc6, 0xbe, 0x08, 0x35, 0x22, 0x0d, 0x5a, 0xd1, 0x56, 0xb5, 0x64, 0x28,
+ 0x4b, 0x97, 0xc7, 0xde, 0x29, 0xba, 0x12, 0xa1, 0x5e, 0xfd, 0x05, 0x26, 0xfd, 0x56, 0x05, 0x26,
+ 0xaf, 0x6c, 0x6c, 0x34, 0x2e, 0x93, 0x44, 0x68, 0xc9, 0x62, 0xf7, 0x4b, 0x43, 0xdb, 0x7b, 0x8e,
+ 0x5f, 0x5a, 0xe8, 0x31, 0xeb, 0x3a, 0x89, 0xe7, 0x2f, 0xf0, 0x50, 0xe7, 0x85, 0xf5, 0x20, 0xb9,
+ 0x19, 0x35, 0x93, 0xc8, 0x0b, 0xb6, 0x73, 0xf7, 0xaa, 0x52, 0x93, 0x57, 0x7b, 0x69, 0x72, 0xf4,
+ 0x22, 0x8c, 0xb0, 0x48, 0x6b, 0x69, 0x74, 0xfc, 0x9c, 0xb2, 0x0f, 0x18, 0xf4, 0xe8, 0x60, 0xbe,
+ 0x76, 0x0b, 0xaf, 0xf3, 0x3f, 0x58, 0x90, 0xa2, 0x2f, 0xc3, 0xf8, 0x4e, 0x92, 0xb4, 0xaf, 0x10,
+ 0xc7, 0x25, 0x91, 0xd4, 0x12, 0x05, 0xe6, 0x19, 0x1d, 0x0c, 0x5e, 0x20, 0x9d, 0x58, 0x29, 0x2c,
+ 0xc6, 0x3a, 0x47, 0xbb, 0x09, 0x90, 0xe2, 0x1e, 0xd2, 0x9e, 0xc3, 0xfe, 0x6b, 0x15, 0x18, 0xbd,
+ 0xe2, 0x04, 0xae, 0x4f, 0x22, 0xb4, 0x06, 0x43, 0xe4, 0x3e, 0x69, 0x95, 0xb3, 0x2c, 0xd3, 0xa5,
+ 0x8e, 0xfb, 0x8f, 0xe8, 0x7f, 0xcc, 0xca, 0x23, 0x0c, 0xa3, 0xb4, 0xdd, 0x97, 0x55, 0x7c, 0xe4,
+ 0xf3, 0xc5, 0xa3, 0xa0, 0x44, 0x82, 0xaf, 0x93, 0x02, 0x84, 0x25, 0x23, 0xe6, 0x69, 0x69, 0xb5,
+ 0x9b, 0x54, 0xb9, 0x25, 0xe5, 0x42, 0xa0, 0x37, 0x56, 0x1a, 0x9c, 0x5c, 0xf0, 0xe5, 0x9e, 0x16,
+ 0x09, 0xc4, 0x29, 0x3b, 0xfb, 0x55, 0x38, 0xc5, 0x8e, 0xe8, 0x9c, 0x64, 0xc7, 0x98, 0x33, 0x85,
+ 0xc2, 0x69, 0xff, 0xa3, 0x0a, 0x9c, 0x58, 0x6f, 0xae, 0x34, 0x4d, 0x1f, 0xd9, 0xab, 0x30, 0xc1,
+ 0x97, 0x67, 0x2a, 0x74, 0x8e, 0x2f, 0xca, 0x2b, 0xe7, 0xf2, 0x86, 0x86, 0xc3, 0x06, 0x25, 0x7a,
+ 0x12, 0xaa, 0xde, 0x3b, 0x41, 0x36, 0x52, 0x67, 0xfd, 0xcd, 0x1b, 0x98, 0xc2, 0x29, 0x9a, 0xae,
+ 0xf4, 0x5c, 0xc5, 0x29, 0xb4, 0x5a, 0xed, 0xdf, 0x80, 0x29, 0x2f, 0x6e, 0xc5, 0xde, 0x7a, 0x40,
+ 0xe7, 0xbf, 0xd3, 0x92, 0xe2, 0x9b, 0x1a, 0xe5, 0xb4, 0xa9, 0x0a, 0x8b, 0x33, 0xd4, 0x9a, 0xbe,
+ 0x1d, 0x2e, 0x6d, 0x2d, 0x14, 0x07, 0x4a, 0x7e, 0x15, 0x6a, 0x2a, 0xac, 0x45, 0x86, 0x22, 0x59,
+ 0xf9, 0xa1, 0x48, 0x25, 0x14, 0x8e, 0xf4, 0x5c, 0x56, 0x73, 0x3d, 0x97, 0xbf, 0x61, 0x41, 0x7a,
+ 0x82, 0x8f, 0x30, 0xd4, 0xda, 0x21, 0x3b, 0x16, 0x88, 0xe4, 0xc9, 0xdb, 0xd3, 0x05, 0x92, 0xc8,
+ 0x67, 0x02, 0x97, 0x95, 0x86, 0x2c, 0x8b, 0x53, 0x36, 0xe8, 0x1a, 0x8c, 0xb6, 0x23, 0xd2, 0x4c,
+ 0x58, 0xb4, 0x6d, 0x1f, 0x1c, 0x99, 0x54, 0x37, 0x78, 0x49, 0x2c, 0x59, 0xd8, 0xff, 0xda, 0x02,
+ 0xb8, 0xe6, 0xed, 0x7a, 0x09, 0x76, 0x82, 0x6d, 0x32, 0xc0, 0xed, 0xdd, 0x0d, 0x18, 0x8a, 0xdb,
+ 0xa4, 0x55, 0xee, 0x40, 0x27, 0x6d, 0x51, 0xb3, 0x4d, 0x5a, 0xe9, 0x67, 0xa0, 0xff, 0x30, 0xe3,
+ 0x63, 0xff, 0x26, 0xc0, 0x54, 0x4a, 0x46, 0x0d, 0x6d, 0xf4, 0x82, 0x11, 0x5e, 0xfa, 0x78, 0x26,
+ 0xbc, 0xb4, 0xc6, 0xa8, 0xb5, 0x88, 0xd2, 0x04, 0xaa, 0xbb, 0xce, 0x7d, 0x61, 0xd7, 0xbf, 0x5c,
+ 0xb6, 0x41, 0xb4, 0xa6, 0x85, 0xeb, 0xce, 0x7d, 0x6e, 0x46, 0x3d, 0x2f, 0x05, 0xe8, 0xba, 0x73,
+ 0xff, 0x88, 0x1f, 0xdb, 0xb0, 0x19, 0x48, 0x37, 0x12, 0x5f, 0xff, 0xaf, 0xe9, 0x7f, 0xa6, 0x14,
+ 0x69, 0x75, 0xac, 0x56, 0x2f, 0x10, 0x0e, 0xb8, 0x3e, 0x6b, 0xf5, 0x82, 0x6c, 0xad, 0x5e, 0x50,
+ 0xa2, 0x56, 0x2f, 0x40, 0xef, 0x59, 0x30, 0x2a, 0xfc, 0xd6, 0x2c, 0x16, 0x6a, 0xfc, 0xd2, 0xa7,
+ 0xfa, 0xaa, 0x5a, 0x38, 0xc0, 0x79, 0xf5, 0x8b, 0xd2, 0x76, 0x14, 0xd0, 0xc2, 0x26, 0xc8, 0xaa,
+ 0xd1, 0xb7, 0x2d, 0x98, 0x12, 0xbf, 0x31, 0x79, 0xa7, 0x43, 0xe2, 0x44, 0xac, 0x52, 0x9f, 0x7d,
+ 0x90, 0xd6, 0x08, 0x16, 0xbc, 0x51, 0x9f, 0x94, 0x2a, 0xc6, 0x44, 0x16, 0xb6, 0x2d, 0xd3, 0x1e,
+ 0xf4, 0x03, 0x0b, 0x4e, 0xed, 0x3a, 0xf7, 0x79, 0x8d, 0x1c, 0x86, 0x9d, 0xc4, 0x0b, 0x45, 0xbc,
+ 0xd7, 0x5a, 0xbf, 0x72, 0xd2, 0xc5, 0x88, 0x37, 0xf7, 0x75, 0x79, 0x98, 0x98, 0x47, 0x52, 0xd8,
+ 0xe8, 0xdc, 0x16, 0xce, 0xb9, 0x30, 0x26, 0x05, 0x33, 0xc7, 0x6a, 0x5f, 0xd6, 0x17, 0xe3, 0xe3,
+ 0x67, 0xa0, 0xf4, 0x6c, 0x2d, 0xbc, 0xd9, 0x71, 0x82, 0xc4, 0x4b, 0xf6, 0x35, 0x1b, 0x9f, 0xd5,
+ 0x22, 0x04, 0x71, 0x80, 0xb5, 0xec, 0xc0, 0x84, 0x2e, 0x73, 0x03, 0xac, 0x29, 0x84, 0x93, 0x39,
+ 0xf2, 0x34, 0xc0, 0x0a, 0x3b, 0xf0, 0x78, 0x4f, 0xb9, 0x18, 0x5c, 0xb5, 0xf6, 0x6f, 0x59, 0xba,
+ 0xc2, 0x1c, 0xb8, 0xdf, 0xe4, 0xba, 0xe9, 0x37, 0x39, 0x5f, 0x76, 0xde, 0xf4, 0x70, 0x9e, 0x6c,
+ 0xe9, 0x8d, 0xa7, 0xcb, 0x00, 0xda, 0x80, 0x11, 0x9f, 0x42, 0xe4, 0x01, 0xcd, 0x85, 0x7e, 0x66,
+ 0x66, 0x6a, 0x59, 0x30, 0x78, 0x8c, 0x05, 0x2f, 0xfb, 0xfb, 0x16, 0x0c, 0x0d, 0x7c, 0x6c, 0x1a,
+ 0xe6, 0xd8, 0xf4, 0x32, 0x4e, 0xc5, 0x9d, 0xcb, 0x05, 0xec, 0xdc, 0x5b, 0xbd, 0x9f, 0x90, 0x20,
+ 0x66, 0x46, 0x64, 0xee, 0xf0, 0xfc, 0x7a, 0x05, 0xc6, 0x69, 0x45, 0xf2, 0x78, 0xfd, 0x35, 0x98,
+ 0xf4, 0x9d, 0x4d, 0xe2, 0x4b, 0x0f, 0x6f, 0x76, 0xc3, 0x75, 0x4d, 0x47, 0x62, 0x93, 0x96, 0x16,
+ 0xde, 0xd2, 0x1d, 0xe0, 0xc2, 0x18, 0x52, 0x85, 0x0d, 0xef, 0x38, 0x36, 0x69, 0xa9, 0xcd, 0x7f,
+ 0xcf, 0x49, 0x5a, 0x3b, 0x62, 0x33, 0xa6, 0x9a, 0x7b, 0x87, 0x02, 0x31, 0xc7, 0xa1, 0x25, 0x98,
+ 0x96, 0xb2, 0x7a, 0x9b, 0xee, 0xd2, 0xc3, 0x40, 0x18, 0x8a, 0xea, 0xa2, 0x1c, 0x36, 0xd1, 0x38,
+ 0x4b, 0x8f, 0x3e, 0x0d, 0x53, 0x74, 0x70, 0xc2, 0x4e, 0x22, 0x83, 0x07, 0x86, 0x59, 0xf0, 0x00,
+ 0x8b, 0xd1, 0xdc, 0x30, 0x30, 0x38, 0x43, 0x69, 0x7f, 0x19, 0x4e, 0x5e, 0x0b, 0x1d, 0x77, 0xd9,
+ 0xf1, 0x9d, 0xa0, 0x45, 0xa2, 0xf5, 0x60, 0xbb, 0xf0, 0x9c, 0x55, 0x3f, 0x0b, 0xad, 0x14, 0x9d,
+ 0x85, 0xda, 0x11, 0x20, 0xbd, 0x02, 0x11, 0xf6, 0xf2, 0x36, 0x8c, 0x7a, 0xbc, 0x2a, 0x21, 0xb2,
+ 0x17, 0x8b, 0xdc, 0x49, 0x5d, 0x6d, 0xd4, 0xc2, 0x38, 0x38, 0x00, 0x4b, 0x96, 0x74, 0x0f, 0x91,
+ 0xe7, 0x7f, 0x2a, 0xde, 0xa6, 0xd9, 0x7f, 0xc3, 0x82, 0xe9, 0x1b, 0x99, 0xdb, 0x58, 0xcf, 0xc0,
+ 0x48, 0x4c, 0xa2, 0x1c, 0x67, 0x5a, 0x93, 0x41, 0xb1, 0xc0, 0x3e, 0xf4, 0x0d, 0xfa, 0xaf, 0x54,
+ 0xa0, 0xc6, 0x42, 0x27, 0xdb, 0x4e, 0x6b, 0x90, 0xe6, 0xe8, 0x75, 0xc3, 0x1c, 0x2d, 0xd8, 0x1e,
+ 0xaa, 0x06, 0xf5, 0xb2, 0x46, 0xd1, 0x2d, 0x75, 0x3b, 0xa9, 0xd4, 0xce, 0x30, 0x65, 0xc8, 0xef,
+ 0xb2, 0x4c, 0x99, 0x97, 0x99, 0xe4, 0xcd, 0x25, 0x76, 0x3a, 0xa9, 0x68, 0x3f, 0x64, 0xa7, 0x93,
+ 0xaa, 0x5d, 0x3d, 0x54, 0x52, 0x43, 0x6b, 0x3a, 0x53, 0xd8, 0x9f, 0x61, 0xa1, 0x70, 0x8e, 0xef,
+ 0xbd, 0x4b, 0xd4, 0x15, 0xbf, 0x79, 0x11, 0xdc, 0x26, 0xa0, 0x47, 0x4c, 0xbb, 0x88, 0x7f, 0xfc,
+ 0xe6, 0x66, 0x5a, 0xc4, 0xbe, 0x02, 0xd3, 0x99, 0x81, 0x43, 0x2f, 0xc3, 0x70, 0x7b, 0xc7, 0x89,
+ 0x49, 0x26, 0xcc, 0x62, 0xb8, 0x41, 0x81, 0x47, 0x07, 0xf3, 0x53, 0xaa, 0x00, 0x83, 0x60, 0x4e,
+ 0x6d, 0xff, 0xb9, 0x05, 0x43, 0x37, 0x42, 0x77, 0x90, 0x02, 0x76, 0xc5, 0x10, 0xb0, 0x67, 0x8a,
+ 0xef, 0x7b, 0xf7, 0x94, 0xad, 0x46, 0x46, 0xb6, 0xce, 0x97, 0xe0, 0x75, 0xbc, 0x58, 0xed, 0xc2,
+ 0x38, 0xbb, 0x4f, 0x2e, 0xe2, 0x4b, 0x5e, 0x34, 0xf6, 0x4d, 0xf3, 0x99, 0x7d, 0xd3, 0xb4, 0x46,
+ 0xaa, 0xed, 0x9e, 0x9e, 0x85, 0x51, 0x11, 0xcf, 0x90, 0x0d, 0x01, 0x14, 0xb4, 0x58, 0xe2, 0xed,
+ 0x7f, 0x59, 0x05, 0xe3, 0xfe, 0x3a, 0xfa, 0x7d, 0x0b, 0x16, 0x22, 0x7e, 0xed, 0xc0, 0xad, 0x77,
+ 0x22, 0x2f, 0xd8, 0x6e, 0xb6, 0x76, 0x88, 0xdb, 0xf1, 0xbd, 0x60, 0x7b, 0x7d, 0x3b, 0x08, 0x15,
+ 0x78, 0xf5, 0x3e, 0x69, 0x75, 0x98, 0x53, 0xb5, 0xf4, 0xb5, 0x79, 0x75, 0xa6, 0x79, 0xe9, 0xf0,
+ 0x60, 0x7e, 0x01, 0xf7, 0x55, 0x0b, 0xee, 0xb3, 0x55, 0xe8, 0x8f, 0x2c, 0x58, 0xe4, 0x37, 0xb8,
+ 0xcb, 0xf7, 0xa4, 0xd4, 0x7e, 0xb3, 0x21, 0x99, 0xa6, 0xec, 0x36, 0x48, 0xb4, 0xbb, 0xfc, 0x8a,
+ 0x18, 0xe4, 0xc5, 0x46, 0x7f, 0xb5, 0xe2, 0x7e, 0x9b, 0x69, 0xff, 0x76, 0x15, 0x26, 0xe9, 0x78,
+ 0xa6, 0xb7, 0x37, 0x5f, 0x36, 0xc4, 0xe4, 0xa3, 0x19, 0x31, 0x39, 0x61, 0x10, 0x3f, 0x9c, 0x8b,
+ 0x9b, 0xef, 0xc0, 0x09, 0xdf, 0x89, 0x93, 0x2b, 0xc4, 0x89, 0x92, 0x4d, 0xe2, 0xb0, 0x63, 0xc4,
+ 0xe2, 0x49, 0x90, 0x39, 0x97, 0x54, 0x11, 0x32, 0xd7, 0xb2, 0xac, 0x70, 0x37, 0x77, 0x94, 0x00,
+ 0x62, 0x07, 0x96, 0x91, 0x13, 0xc4, 0xbc, 0x27, 0x9e, 0x70, 0xc2, 0xf6, 0x53, 0xe7, 0x9c, 0xa8,
+ 0x13, 0x5d, 0xeb, 0xe2, 0x85, 0x73, 0xf8, 0x6b, 0x87, 0xd1, 0xc3, 0x65, 0x0f, 0xa3, 0x47, 0x0a,
+ 0xe2, 0x6e, 0x7f, 0xc9, 0x82, 0x93, 0xf4, 0x93, 0x98, 0x31, 0x9a, 0x31, 0x0a, 0x61, 0x9a, 0x36,
+ 0xdf, 0x27, 0x89, 0x84, 0x15, 0xaf, 0x23, 0x2c, 0x90, 0xce, 0xe0, 0x93, 0x1a, 0x6a, 0x57, 0x4d,
+ 0x66, 0x38, 0xcb, 0xdd, 0xfe, 0x8e, 0x05, 0x2c, 0x08, 0x6c, 0xe0, 0xcb, 0xd7, 0x65, 0x73, 0xf9,
+ 0xb2, 0x8b, 0x75, 0x45, 0x8f, 0x95, 0xeb, 0x25, 0x98, 0xa1, 0xd8, 0x46, 0x14, 0xde, 0xdf, 0x97,
+ 0x06, 0x75, 0xb1, 0x27, 0xf6, 0xbd, 0x0a, 0x9f, 0x30, 0xea, 0xe6, 0x14, 0xfa, 0x65, 0x0b, 0xc6,
+ 0x5a, 0x4e, 0xdb, 0x69, 0xf1, 0xbc, 0x1f, 0x25, 0xbc, 0x2e, 0x46, 0xf9, 0x85, 0x15, 0x51, 0x96,
+ 0x7b, 0x0c, 0x3e, 0x21, 0xbb, 0x2e, 0xc1, 0x85, 0x5e, 0x02, 0x55, 0xf9, 0x9c, 0x07, 0x93, 0x06,
+ 0xb3, 0x01, 0x6e, 0x33, 0x7f, 0xd9, 0xe2, 0xca, 0x5e, 0x6d, 0x08, 0xee, 0xc1, 0x89, 0x40, 0xfb,
+ 0x4f, 0xd5, 0x98, 0xb4, 0x7f, 0x17, 0xca, 0xab, 0x73, 0xa6, 0xfd, 0xb4, 0x60, 0xb7, 0x0c, 0x43,
+ 0xdc, 0x5d, 0x87, 0xfd, 0x8f, 0x2d, 0x78, 0x4c, 0x27, 0xd4, 0x2e, 0xba, 0x15, 0x79, 0x81, 0xeb,
+ 0x30, 0x16, 0xb6, 0x49, 0xe4, 0xa4, 0x9b, 0x9f, 0xf3, 0x72, 0xf4, 0x6f, 0x0a, 0xf8, 0xd1, 0xc1,
+ 0xfc, 0x29, 0x9d, 0xbb, 0x84, 0x63, 0x55, 0x12, 0xd9, 0x30, 0xc2, 0xc6, 0x25, 0x16, 0x57, 0x14,
+ 0x59, 0x16, 0x0c, 0x76, 0xf6, 0x11, 0x63, 0x81, 0xb1, 0xff, 0xa6, 0xc5, 0x85, 0x4d, 0x6f, 0x3a,
+ 0xfa, 0x1a, 0xcc, 0xec, 0xd2, 0x7d, 0xd2, 0xea, 0xfd, 0x36, 0x5d, 0x40, 0xd9, 0x99, 0xaf, 0x55,
+ 0x66, 0xd9, 0xe8, 0xd1, 0xdd, 0xe5, 0x59, 0xd1, 0xfa, 0x99, 0xeb, 0x19, 0xb6, 0xb8, 0xab, 0x22,
+ 0xfb, 0x8f, 0xc5, 0x7c, 0x65, 0x36, 0xdb, 0xb3, 0x30, 0xda, 0x0e, 0xdd, 0x95, 0xf5, 0x3a, 0x16,
+ 0x63, 0xa5, 0x14, 0x4e, 0x83, 0x83, 0xb1, 0xc4, 0xa3, 0x4b, 0x00, 0xe4, 0x7e, 0x42, 0xa2, 0xc0,
+ 0xf1, 0xd5, 0x59, 0xad, 0x32, 0x91, 0x56, 0x15, 0x06, 0x6b, 0x54, 0xb4, 0x4c, 0x3b, 0x0a, 0xf7,
+ 0x3c, 0x97, 0x45, 0x9e, 0x57, 0xcd, 0x32, 0x0d, 0x85, 0xc1, 0x1a, 0x15, 0xdd, 0x9d, 0x76, 0x82,
+ 0x98, 0x2f, 0x5f, 0xce, 0xa6, 0x48, 0xde, 0x30, 0x96, 0xee, 0x4e, 0x6f, 0xe9, 0x48, 0x6c, 0xd2,
+ 0xda, 0x3f, 0xad, 0x01, 0xa4, 0x06, 0x12, 0x7a, 0xaf, 0x7b, 0x86, 0x7e, 0xb2, 0xac, 0x75, 0xf5,
+ 0xf0, 0xa6, 0x27, 0xfa, 0xa6, 0x05, 0xe3, 0x8e, 0xef, 0x87, 0x2d, 0x27, 0x61, 0x3d, 0xaa, 0x94,
+ 0xd5, 0x15, 0xa2, 0x25, 0x4b, 0x69, 0x59, 0xde, 0x98, 0x17, 0xe5, 0x51, 0x9e, 0x86, 0x29, 0x6c,
+ 0x8f, 0xde, 0x04, 0xf4, 0x09, 0x69, 0x58, 0xf3, 0x8f, 0x32, 0x97, 0x35, 0xac, 0x6b, 0x4c, 0x43,
+ 0x6a, 0x36, 0x35, 0xfa, 0xb2, 0x91, 0xa7, 0x60, 0xa8, 0xcc, 0xed, 0x58, 0xc3, 0x64, 0x28, 0x4a,
+ 0x51, 0x80, 0xbe, 0xa0, 0x07, 0xe5, 0x0e, 0x97, 0xb9, 0x7a, 0xaa, 0x59, 0xae, 0x05, 0x01, 0xb9,
+ 0x09, 0x4c, 0xbb, 0xe6, 0x42, 0x29, 0x02, 0xad, 0x2e, 0x16, 0xd7, 0x90, 0x59, 0x61, 0xd3, 0xa5,
+ 0x31, 0x83, 0xc0, 0xd9, 0x2a, 0xe8, 0x6a, 0x48, 0xd5, 0xd6, 0x7a, 0xb0, 0x15, 0x8a, 0x70, 0xab,
+ 0x0b, 0x25, 0xbe, 0xf9, 0x7e, 0x9c, 0x90, 0x5d, 0x5a, 0x26, 0x5d, 0x0d, 0x6f, 0x08, 0x2e, 0x58,
+ 0xf1, 0x43, 0x1b, 0x30, 0xc2, 0x2e, 0x78, 0xc4, 0xb3, 0x63, 0x65, 0xdc, 0x63, 0xe6, 0x8d, 0xc6,
+ 0xd4, 0x00, 0x61, 0x7f, 0x63, 0x2c, 0x78, 0xa1, 0x2b, 0xf2, 0x06, 0x70, 0xbc, 0x1e, 0xdc, 0x8a,
+ 0x09, 0xbb, 0x01, 0x5c, 0x5b, 0xfe, 0x58, 0x7a, 0xa5, 0x97, 0xc3, 0x73, 0x33, 0x33, 0x19, 0x25,
+ 0xa9, 0x1d, 0x22, 0xfe, 0xcb, 0x84, 0x4f, 0xb3, 0x50, 0xa6, 0xa1, 0x66, 0x7a, 0xa8, 0x74, 0xb0,
+ 0x6f, 0x9b, 0xcc, 0x70, 0x96, 0xfb, 0x23, 0x5c, 0x03, 0xe7, 0x7c, 0x98, 0xc9, 0x4e, 0xc9, 0x01,
+ 0xae, 0xb8, 0x7f, 0x36, 0x04, 0x53, 0xa6, 0x60, 0xa0, 0x45, 0xa8, 0xed, 0xb2, 0x74, 0x4c, 0x69,
+ 0x12, 0x18, 0x25, 0xff, 0xd7, 0x25, 0x02, 0xa7, 0x34, 0x2c, 0x1d, 0x0e, 0x2b, 0xae, 0x05, 0xda,
+ 0xa4, 0xe9, 0x70, 0x14, 0x06, 0x6b, 0x54, 0xd4, 0x68, 0xdd, 0x0c, 0xc3, 0x44, 0x29, 0x6e, 0x25,
+ 0x33, 0xcb, 0x0c, 0x8a, 0x05, 0x96, 0x2a, 0xec, 0xbb, 0xb4, 0x43, 0xbe, 0xe9, 0xea, 0x53, 0x0a,
+ 0xfb, 0xaa, 0x8e, 0xc4, 0x26, 0x2d, 0x5d, 0x80, 0xc2, 0x98, 0x09, 0xa1, 0x30, 0x8d, 0xd3, 0xc0,
+ 0xa5, 0x26, 0xbf, 0xf0, 0x24, 0xf1, 0xe8, 0xf3, 0xf0, 0x98, 0xba, 0x9f, 0x84, 0xb9, 0xeb, 0x54,
+ 0xd6, 0x38, 0x62, 0xec, 0x6c, 0x1f, 0x5b, 0xc9, 0x27, 0xc3, 0xbd, 0xca, 0xa3, 0x37, 0x60, 0x4a,
+ 0x98, 0xb5, 0x92, 0xe3, 0xa8, 0x79, 0xae, 0x7d, 0xd5, 0xc0, 0xe2, 0x0c, 0x35, 0xaa, 0xc3, 0x0c,
+ 0x85, 0x30, 0x8b, 0x52, 0x72, 0xe0, 0xf7, 0xac, 0xd4, 0xca, 0x7c, 0x35, 0x83, 0xc7, 0x5d, 0x25,
+ 0xd0, 0x12, 0x4c, 0x73, 0xdb, 0x82, 0xee, 0xdf, 0xd8, 0x77, 0x10, 0x11, 0x92, 0x6a, 0x12, 0xdc,
+ 0x34, 0xd1, 0x38, 0x4b, 0x8f, 0x5e, 0x85, 0x09, 0x27, 0x6a, 0xed, 0x78, 0x09, 0x69, 0x25, 0x9d,
+ 0x88, 0xdf, 0xad, 0xd7, 0x02, 0x03, 0x96, 0x34, 0x1c, 0x36, 0x28, 0xed, 0x77, 0xe1, 0x64, 0x4e,
+ 0x08, 0x36, 0x15, 0x1c, 0xa7, 0xed, 0xc9, 0x3e, 0x65, 0x42, 0x90, 0x96, 0x1a, 0xeb, 0xb2, 0x37,
+ 0x1a, 0x15, 0x95, 0x4e, 0xe6, 0x33, 0xd6, 0x72, 0xb3, 0x29, 0xe9, 0x5c, 0x93, 0x08, 0x9c, 0xd2,
+ 0xd8, 0xff, 0xbd, 0x06, 0x9a, 0x93, 0xa5, 0x44, 0xe0, 0xc9, 0xab, 0x30, 0x21, 0xd3, 0x0d, 0x6a,
+ 0x69, 0xbe, 0x54, 0x37, 0x2f, 0x6b, 0x38, 0x6c, 0x50, 0xd2, 0xb6, 0x05, 0xd2, 0x65, 0x94, 0x0d,
+ 0x78, 0x52, 0xbe, 0x24, 0x9c, 0xd2, 0xa0, 0x0b, 0x30, 0x16, 0x13, 0x7f, 0xeb, 0x9a, 0x17, 0xdc,
+ 0x15, 0x82, 0xad, 0xb4, 0x72, 0x53, 0xc0, 0xb1, 0xa2, 0x40, 0x9f, 0x85, 0x6a, 0xc7, 0x73, 0x85,
+ 0x28, 0x2f, 0x48, 0xbb, 0xf3, 0xd6, 0x7a, 0xfd, 0xe8, 0x60, 0x7e, 0x3e, 0x3f, 0x87, 0x22, 0xdd,
+ 0x44, 0xc7, 0x0b, 0x74, 0xf2, 0xd1, 0xa2, 0x79, 0xae, 0xf3, 0x91, 0x3e, 0x5d, 0xe7, 0x97, 0x00,
+ 0x44, 0x9f, 0xa5, 0x24, 0x57, 0xd3, 0x6f, 0x76, 0x59, 0x61, 0xb0, 0x46, 0x45, 0xb7, 0xe2, 0xad,
+ 0x88, 0x38, 0x72, 0xc7, 0xca, 0x43, 0x84, 0xc7, 0x1e, 0x74, 0x2b, 0xbe, 0x92, 0x65, 0x85, 0xbb,
+ 0xb9, 0xa3, 0x5d, 0x38, 0xe1, 0xd2, 0x49, 0x64, 0x54, 0x59, 0xeb, 0x37, 0x2a, 0x99, 0x56, 0x57,
+ 0xcf, 0xb2, 0xc1, 0xdd, 0x9c, 0xd1, 0x97, 0x60, 0x4e, 0x02, 0xbb, 0xef, 0x1e, 0xb2, 0x89, 0x52,
+ 0x5d, 0x3e, 0x7b, 0x78, 0x30, 0x3f, 0x57, 0xef, 0x49, 0x85, 0x8f, 0xe1, 0x80, 0xde, 0x86, 0x11,
+ 0x76, 0xcc, 0x12, 0xcf, 0x8e, 0xb3, 0x75, 0xee, 0xa5, 0xb2, 0x8e, 0xc6, 0x05, 0x76, 0x58, 0x23,
+ 0xe2, 0x36, 0xd3, 0x73, 0x2b, 0x06, 0xc4, 0x82, 0x27, 0x6a, 0xc3, 0xb8, 0x13, 0x04, 0x61, 0xe2,
+ 0x70, 0xf3, 0x6b, 0xa2, 0x8c, 0x05, 0xa9, 0x55, 0xb1, 0x94, 0x96, 0xe5, 0xf5, 0xa8, 0x60, 0x30,
+ 0x0d, 0x83, 0xf5, 0x2a, 0x50, 0x07, 0xa6, 0xc3, 0x7b, 0x54, 0x55, 0xca, 0x93, 0x86, 0x78, 0x76,
+ 0xb2, 0x28, 0x41, 0x62, 0xfa, 0x71, 0x6e, 0x1a, 0x45, 0x35, 0x0d, 0x66, 0xb2, 0xc4, 0xd9, 0x3a,
+ 0xd0, 0x82, 0xe1, 0x45, 0x9e, 0x4a, 0x63, 0x93, 0x53, 0x2f, 0xb2, 0xee, 0x34, 0x66, 0xb7, 0x5b,
+ 0x79, 0x3c, 0x22, 0xd3, 0x04, 0xd3, 0x99, 0xdb, 0xad, 0x29, 0x0a, 0xeb, 0x74, 0x73, 0x9f, 0x82,
+ 0x71, 0x6d, 0xd8, 0xfb, 0x09, 0x82, 0x9d, 0x7b, 0x03, 0x66, 0xb2, 0xc3, 0xd9, 0x57, 0x10, 0xed,
+ 0xff, 0xac, 0xc0, 0x74, 0xce, 0x21, 0xce, 0x5d, 0x8f, 0x05, 0x72, 0x1b, 0x2a, 0xef, 0xaa, 0x17,
+ 0xb8, 0x98, 0x61, 0x4c, 0xc5, 0x55, 0x29, 0xa1, 0xb8, 0xa4, 0x16, 0xad, 0xf6, 0xd4, 0xa2, 0x42,
+ 0x59, 0x0d, 0x3d, 0xb8, 0xb2, 0x32, 0x57, 0x87, 0xe1, 0x52, 0xab, 0xc3, 0x43, 0x50, 0x70, 0xc6,
+ 0x02, 0x33, 0x5a, 0x62, 0x81, 0xf9, 0x76, 0x05, 0x66, 0xd2, 0x70, 0x61, 0x91, 0x79, 0x74, 0x70,
+ 0x67, 0x03, 0x1b, 0xc6, 0xd9, 0x40, 0x51, 0x42, 0xd1, 0x4c, 0xbb, 0x7a, 0x9e, 0x13, 0xbc, 0x9d,
+ 0x39, 0x27, 0x78, 0xa9, 0x4f, 0xbe, 0xc7, 0x9f, 0x19, 0x7c, 0xa7, 0x02, 0xa7, 0xb3, 0x45, 0x56,
+ 0x7c, 0xc7, 0xdb, 0x1d, 0xe0, 0x38, 0x7d, 0xde, 0x18, 0xa7, 0x57, 0xfa, 0xeb, 0x0f, 0x6b, 0x5c,
+ 0xcf, 0xc1, 0x72, 0x32, 0x83, 0xf5, 0xa9, 0x07, 0x61, 0x7e, 0xfc, 0x88, 0xfd, 0xd4, 0x82, 0xc7,
+ 0x73, 0xcb, 0x0d, 0xdc, 0x13, 0xfa, 0x96, 0xe9, 0x09, 0x7d, 0xf1, 0x01, 0xfa, 0xd6, 0xc3, 0x35,
+ 0x7a, 0x58, 0xe9, 0xd1, 0x27, 0xe6, 0x2d, 0xba, 0x09, 0xe3, 0x4e, 0xab, 0x45, 0xe2, 0xf8, 0x7a,
+ 0xe8, 0xaa, 0x6c, 0x38, 0x2f, 0xb0, 0x55, 0x24, 0x05, 0x1f, 0x1d, 0xcc, 0xcf, 0x65, 0x59, 0xa4,
+ 0x68, 0xac, 0x73, 0x30, 0xb3, 0x5a, 0x55, 0x06, 0x94, 0xd5, 0xea, 0x12, 0xc0, 0x9e, 0xda, 0xa5,
+ 0x66, 0x9d, 0x50, 0xda, 0xfe, 0x55, 0xa3, 0x42, 0x5f, 0x64, 0x56, 0x1f, 0x8f, 0x8e, 0x18, 0x2a,
+ 0x72, 0x14, 0x68, 0x5f, 0x4f, 0x8f, 0xb3, 0xe0, 0xd7, 0x17, 0x95, 0xbb, 0x4e, 0x31, 0xb4, 0xbf,
+ 0x5f, 0x85, 0x9f, 0x3b, 0x46, 0xe0, 0xd0, 0x92, 0x79, 0xe8, 0xf9, 0x7c, 0xd6, 0x37, 0x33, 0x97,
+ 0x5b, 0xd8, 0x70, 0xd6, 0x64, 0xbe, 0x54, 0xe5, 0x03, 0x7f, 0xa9, 0x6f, 0xe9, 0x9e, 0x34, 0x1e,
+ 0xdc, 0x78, 0xf9, 0x81, 0xa7, 0xd4, 0xcf, 0xa6, 0xe7, 0xfb, 0xeb, 0x16, 0x7c, 0x34, 0xb7, 0x53,
+ 0x46, 0x60, 0xc5, 0x22, 0xd4, 0x5a, 0x14, 0xa8, 0xdd, 0x3e, 0x49, 0xaf, 0x7d, 0x49, 0x04, 0x4e,
+ 0x69, 0x8c, 0xf8, 0x89, 0x4a, 0x61, 0xfc, 0xc4, 0xbf, 0xb7, 0xe0, 0x54, 0xb6, 0x11, 0x03, 0xd7,
+ 0x37, 0x4d, 0x53, 0xdf, 0x2c, 0xf4, 0xf7, 0xe1, 0x7b, 0xa8, 0x9a, 0x6f, 0x4f, 0xc2, 0x99, 0xae,
+ 0x35, 0x8a, 0x8f, 0xe1, 0x2f, 0x58, 0x70, 0x62, 0x9b, 0xd9, 0xd7, 0xda, 0x05, 0x1f, 0xd1, 0xab,
+ 0x82, 0x5b, 0x51, 0xc7, 0xde, 0x0b, 0xe2, 0xbb, 0x85, 0x2e, 0x12, 0xdc, 0x5d, 0x19, 0xfa, 0x86,
+ 0x05, 0xa7, 0x9c, 0x7b, 0x71, 0x57, 0xf6, 0x7a, 0x21, 0x44, 0x6f, 0x14, 0x38, 0xb1, 0x0a, 0xf2,
+ 0xde, 0x2f, 0xcf, 0x1e, 0x1e, 0xcc, 0x9f, 0xca, 0xa3, 0xc2, 0xb9, 0xb5, 0xa2, 0xb7, 0x45, 0xee,
+ 0x2f, 0x6a, 0xf0, 0x94, 0xba, 0xaa, 0x96, 0x77, 0xdd, 0x80, 0x2b, 0x24, 0x89, 0xc1, 0x8a, 0x23,
+ 0xfa, 0x0a, 0xd4, 0xb6, 0xe5, 0x9d, 0x1e, 0xa1, 0xee, 0x0a, 0xd6, 0x94, 0xdc, 0x2b, 0x40, 0x3c,
+ 0xa8, 0x5d, 0xa1, 0x70, 0xca, 0x14, 0x5d, 0x81, 0x6a, 0xb0, 0x15, 0x8b, 0x7b, 0xb3, 0x45, 0xc1,
+ 0x33, 0x66, 0xa8, 0x12, 0xbf, 0x70, 0x78, 0x63, 0xad, 0x89, 0x29, 0x0b, 0xca, 0x29, 0xda, 0x74,
+ 0x85, 0xf7, 0xb6, 0x80, 0x13, 0x5e, 0xae, 0x77, 0x73, 0xc2, 0xcb, 0x75, 0x4c, 0x59, 0xb0, 0x28,
+ 0xbd, 0xb8, 0x15, 0x7b, 0xc2, 0x35, 0x5b, 0x70, 0xa9, 0xba, 0xeb, 0x12, 0x06, 0x4f, 0x03, 0xc7,
+ 0xc0, 0x98, 0x33, 0x42, 0x1b, 0x30, 0xd2, 0x62, 0x09, 0x9b, 0xc5, 0xce, 0xb9, 0x28, 0x8d, 0x6f,
+ 0x57, 0x72, 0x67, 0x7e, 0x84, 0xc4, 0xe1, 0x58, 0xf0, 0x62, 0x5c, 0x49, 0x7b, 0x67, 0x2b, 0x16,
+ 0x9b, 0xe3, 0x22, 0xae, 0x5d, 0xa9, 0xb7, 0x05, 0x57, 0x06, 0xc7, 0x82, 0x17, 0xaa, 0x43, 0x65,
+ 0xab, 0x25, 0x72, 0x2f, 0x16, 0xb8, 0x64, 0xcd, 0xdb, 0xa3, 0xcb, 0x23, 0x87, 0x07, 0xf3, 0x95,
+ 0xb5, 0x15, 0x5c, 0xd9, 0x6a, 0xa1, 0xb7, 0x60, 0x74, 0x8b, 0xdf, 0x07, 0x14, 0x79, 0x16, 0x2f,
+ 0x16, 0x5d, 0x5a, 0xec, 0xba, 0x3c, 0xc8, 0x2f, 0x2e, 0x08, 0x04, 0x96, 0xec, 0xd0, 0x97, 0x00,
+ 0xb6, 0xd4, 0x0d, 0x47, 0x91, 0x68, 0x71, 0xa1, 0xbf, 0x1b, 0x91, 0x62, 0xdf, 0xa8, 0xa0, 0x58,
+ 0xe3, 0x48, 0x65, 0xde, 0x91, 0x39, 0xe7, 0x59, 0x92, 0xc5, 0x42, 0x99, 0xcf, 0x4d, 0x51, 0xcf,
+ 0x65, 0x5e, 0xa1, 0x70, 0xca, 0x14, 0x75, 0x60, 0x72, 0x2f, 0x6e, 0xef, 0x10, 0x39, 0xf5, 0x59,
+ 0xe6, 0xc5, 0xf1, 0x4b, 0xaf, 0x17, 0xa4, 0xd3, 0x14, 0x45, 0xbc, 0x28, 0xe9, 0x38, 0x7e, 0x97,
+ 0x06, 0x63, 0xb9, 0x8c, 0x6e, 0xeb, 0x6c, 0xb1, 0x59, 0x0b, 0xfd, 0x24, 0xef, 0x74, 0xc2, 0xcd,
+ 0xfd, 0x84, 0x88, 0xcc, 0x8c, 0x05, 0x9f, 0xe4, 0x4d, 0x4e, 0xdc, 0xfd, 0x49, 0x04, 0x02, 0x4b,
+ 0x76, 0x6a, 0xc8, 0x98, 0x36, 0x9e, 0x29, 0x3d, 0x64, 0x5d, 0x7d, 0x48, 0x87, 0x8c, 0x69, 0xdf,
+ 0x94, 0x29, 0xd3, 0xba, 0xed, 0x9d, 0x30, 0x09, 0x83, 0x8c, 0xee, 0x3f, 0x51, 0x46, 0xeb, 0x36,
+ 0x72, 0x4a, 0x76, 0x6b, 0xdd, 0x3c, 0x2a, 0x9c, 0x5b, 0xab, 0xfd, 0xc7, 0xc3, 0xdd, 0x8b, 0x2d,
+ 0x33, 0x84, 0x7f, 0xb5, 0xfb, 0x5c, 0xf1, 0xb3, 0xfd, 0xef, 0xf2, 0x1e, 0xe2, 0x09, 0xe3, 0x37,
+ 0x2c, 0x38, 0xd3, 0xce, 0x5d, 0x4c, 0xc5, 0x82, 0xd5, 0xef, 0x66, 0x91, 0x0f, 0x98, 0x4a, 0x3b,
+ 0x9a, 0x8f, 0xc7, 0x3d, 0xea, 0xcc, 0x9a, 0x9f, 0xd5, 0x0f, 0x6c, 0x7e, 0xde, 0x81, 0x31, 0x66,
+ 0x31, 0xa5, 0x39, 0x30, 0xfa, 0x4c, 0x1b, 0xc1, 0x96, 0xbe, 0x15, 0xc1, 0x02, 0x2b, 0x66, 0x74,
+ 0xe0, 0x9e, 0xcc, 0x76, 0x02, 0x13, 0x86, 0x16, 0xf9, 0x52, 0xb9, 0x57, 0x63, 0x4d, 0x8c, 0xc4,
+ 0x93, 0x8d, 0xe3, 0x88, 0x8f, 0x8a, 0x08, 0xf0, 0xf1, 0x95, 0x3d, 0x4a, 0x73, 0xf6, 0x9f, 0x59,
+ 0x39, 0xf6, 0x17, 0xdf, 0x80, 0xbc, 0x6e, 0x6e, 0x40, 0x9e, 0xc9, 0x6e, 0x40, 0xba, 0x1c, 0x05,
+ 0xc6, 0xde, 0xa3, 0x7c, 0xf2, 0xc0, 0xb2, 0x49, 0x3a, 0x6c, 0x1f, 0xce, 0x15, 0x4d, 0x6e, 0x16,
+ 0xc1, 0xe3, 0xaa, 0xe3, 0xb0, 0x34, 0x82, 0xc7, 0x5d, 0xaf, 0x63, 0x86, 0x29, 0x7b, 0xdb, 0xdb,
+ 0xfe, 0xdf, 0x16, 0x54, 0x1b, 0xa1, 0x3b, 0x40, 0xc7, 0xc7, 0x65, 0xc3, 0xf1, 0xf1, 0x74, 0xe1,
+ 0x4b, 0x3b, 0x3d, 0xdd, 0x1c, 0x37, 0x33, 0x6e, 0x8e, 0x8f, 0x17, 0xb3, 0x3a, 0xde, 0xa9, 0xf1,
+ 0x83, 0x2a, 0xe8, 0x6f, 0x05, 0xa1, 0x3f, 0x78, 0x90, 0x50, 0xce, 0x6a, 0xb9, 0xe7, 0x83, 0x44,
+ 0x1d, 0x2c, 0xf4, 0x47, 0x5e, 0xef, 0xfa, 0x99, 0x8d, 0xe8, 0xbc, 0x43, 0xbc, 0xed, 0x9d, 0x84,
+ 0xb8, 0xd9, 0x8e, 0x3d, 0xba, 0x88, 0xce, 0xff, 0x66, 0xc1, 0x74, 0xa6, 0x76, 0xf4, 0xd5, 0xbc,
+ 0x7b, 0x22, 0x0f, 0xe4, 0xcc, 0x38, 0x51, 0x78, 0xad, 0x64, 0x01, 0x40, 0x79, 0x9f, 0xa5, 0xcb,
+ 0x81, 0x59, 0x60, 0xca, 0x3d, 0x1d, 0x63, 0x8d, 0x02, 0xbd, 0x0c, 0xe3, 0x49, 0xd8, 0x0e, 0xfd,
+ 0x70, 0x7b, 0xff, 0x2a, 0x91, 0xd9, 0x07, 0x94, 0xe7, 0x7e, 0x23, 0x45, 0x61, 0x9d, 0xce, 0xfe,
+ 0x51, 0x15, 0xb2, 0xef, 0x4c, 0xfd, 0x7f, 0x29, 0xfd, 0xd9, 0x91, 0xd2, 0x3f, 0xb4, 0x60, 0x86,
+ 0xd6, 0xce, 0xc2, 0x36, 0x64, 0xf4, 0xa5, 0xca, 0xf3, 0x6d, 0x1d, 0x93, 0xe7, 0xfb, 0x19, 0xaa,
+ 0xeb, 0xdc, 0xb0, 0x93, 0x08, 0x37, 0x89, 0xa6, 0xc2, 0x28, 0x14, 0x0b, 0xac, 0xa0, 0x23, 0x51,
+ 0x24, 0xae, 0xa3, 0xe8, 0x74, 0x24, 0x8a, 0xb0, 0xc0, 0xca, 0x34, 0xe0, 0x43, 0xf9, 0x69, 0xc0,
+ 0x79, 0xfe, 0x1e, 0x11, 0x2e, 0x20, 0x8c, 0x00, 0x2d, 0x7f, 0x8f, 0x8c, 0x23, 0x48, 0x69, 0xec,
+ 0xef, 0x54, 0x61, 0xa2, 0x11, 0xba, 0x69, 0x40, 0xf5, 0x4b, 0x46, 0x40, 0xf5, 0xb9, 0x4c, 0x40,
+ 0xf5, 0x8c, 0x4e, 0xfb, 0x70, 0xe2, 0xa9, 0x45, 0x8e, 0x27, 0x96, 0xa8, 0xfe, 0x81, 0x62, 0xa9,
+ 0x8d, 0x1c, 0x4f, 0x8a, 0x0d, 0x36, 0xb9, 0xfe, 0xe5, 0x89, 0xa1, 0xfe, 0x73, 0x0b, 0xa6, 0x1a,
+ 0xa1, 0x4b, 0x85, 0xf3, 0x2f, 0x93, 0x24, 0xea, 0x99, 0xa1, 0x46, 0x8e, 0xc9, 0x0c, 0xf5, 0x1b,
+ 0x16, 0x8c, 0x36, 0x42, 0x77, 0xe0, 0xee, 0xc3, 0x35, 0xd3, 0x7d, 0xf8, 0xd1, 0x42, 0x9d, 0xdb,
+ 0xc3, 0x63, 0xf8, 0xfd, 0x2a, 0x4c, 0xd2, 0xf6, 0x86, 0xdb, 0xf2, 0x6b, 0x19, 0x23, 0x63, 0x95,
+ 0x18, 0x19, 0x6a, 0x02, 0x86, 0xbe, 0x1f, 0xde, 0xcb, 0x7e, 0xb9, 0x35, 0x06, 0xc5, 0x02, 0x8b,
+ 0x2e, 0xc0, 0x58, 0x3b, 0x22, 0x7b, 0x5e, 0xd8, 0x89, 0xb3, 0x97, 0xda, 0x1a, 0x02, 0x8e, 0x15,
+ 0x05, 0x7a, 0x09, 0x26, 0x62, 0x2f, 0x68, 0x11, 0x19, 0x4c, 0x30, 0xc4, 0x82, 0x09, 0x78, 0xd2,
+ 0x3d, 0x0d, 0x8e, 0x0d, 0x2a, 0x74, 0x0b, 0x6a, 0xec, 0x3f, 0x9b, 0x3d, 0xfd, 0x66, 0x25, 0xe7,
+ 0x59, 0xa7, 0x64, 0x71, 0x9c, 0x72, 0x42, 0x97, 0x00, 0x12, 0x19, 0xf4, 0x10, 0x8b, 0xec, 0x19,
+ 0xca, 0x1a, 0x55, 0xe1, 0x10, 0x31, 0xd6, 0xa8, 0xd0, 0xf3, 0x50, 0x4b, 0x1c, 0xcf, 0xbf, 0xe6,
+ 0x05, 0x24, 0x16, 0x01, 0x23, 0x22, 0x6d, 0xac, 0x00, 0xe2, 0x14, 0x4f, 0xd7, 0x79, 0x76, 0x99,
+ 0x96, 0xbf, 0x76, 0x30, 0xc6, 0xa8, 0xd9, 0x3a, 0x7f, 0x4d, 0x41, 0xb1, 0x46, 0x61, 0xbf, 0xc8,
+ 0xd6, 0xeb, 0x3e, 0xa3, 0xed, 0x7f, 0x52, 0x01, 0xd4, 0x60, 0xc1, 0x15, 0xc6, 0x83, 0x10, 0x3b,
+ 0x30, 0x15, 0x93, 0x6b, 0x5e, 0xd0, 0xb9, 0x2f, 0x58, 0x95, 0xbb, 0xdc, 0xd0, 0x5c, 0xd5, 0xcb,
+ 0xf0, 0x3b, 0xa4, 0x26, 0x0c, 0x67, 0xf8, 0xd2, 0x21, 0x89, 0x3a, 0xc1, 0x52, 0x7c, 0x2b, 0x26,
+ 0x91, 0x78, 0xd2, 0x81, 0x0d, 0x09, 0x96, 0x40, 0x9c, 0xe2, 0xa9, 0x00, 0xb0, 0x3f, 0x37, 0xc2,
+ 0x00, 0x87, 0x61, 0x22, 0x45, 0x86, 0x25, 0xfa, 0xd6, 0xe0, 0xd8, 0xa0, 0x42, 0x6b, 0x80, 0xe2,
+ 0x4e, 0xbb, 0xed, 0xb3, 0x53, 0x2c, 0xc7, 0xbf, 0x1c, 0x85, 0x9d, 0x36, 0x8f, 0xac, 0x15, 0x39,
+ 0xb2, 0x9b, 0x5d, 0x58, 0x9c, 0x53, 0x82, 0x4e, 0xf7, 0xad, 0x98, 0xfd, 0x16, 0x77, 0x64, 0xb9,
+ 0x47, 0xad, 0xc9, 0x40, 0x58, 0xe2, 0xec, 0xaf, 0xb1, 0xe5, 0x89, 0x65, 0xdb, 0x4f, 0x3a, 0x11,
+ 0x41, 0x77, 0x61, 0xb2, 0xcd, 0x96, 0xa0, 0x24, 0x0a, 0x7d, 0x9f, 0x44, 0xc5, 0xef, 0x16, 0xf5,
+ 0x0c, 0xef, 0xe0, 0x19, 0xb6, 0x75, 0x66, 0xd8, 0xe4, 0x6d, 0xff, 0x27, 0x60, 0xba, 0x46, 0x1c,
+ 0x23, 0x8e, 0x8a, 0xe0, 0x4d, 0x61, 0x85, 0x7d, 0xac, 0xcc, 0x0b, 0x33, 0xa9, 0x1e, 0x17, 0xa1,
+ 0xa0, 0x58, 0x72, 0x41, 0x5f, 0x64, 0xa1, 0xc9, 0x7c, 0x8a, 0x97, 0x7f, 0xf6, 0x89, 0xd3, 0x1b,
+ 0x61, 0xc9, 0x82, 0x05, 0xd6, 0xd8, 0xa1, 0x6b, 0x30, 0x29, 0xd2, 0xb3, 0x0b, 0x87, 0x40, 0xd5,
+ 0xd8, 0x14, 0x4f, 0x62, 0x1d, 0x79, 0x94, 0x05, 0x60, 0xb3, 0x30, 0xda, 0x86, 0x27, 0xb5, 0xa7,
+ 0x5a, 0x72, 0x02, 0x91, 0xb8, 0xee, 0xf8, 0xe8, 0xe1, 0xc1, 0xfc, 0x93, 0x1b, 0xc7, 0x11, 0xe2,
+ 0xe3, 0xf9, 0xa0, 0x9b, 0x70, 0xda, 0x69, 0x25, 0xde, 0x1e, 0xa9, 0x13, 0xc7, 0xf5, 0xbd, 0x80,
+ 0x98, 0xd7, 0xa8, 0x1f, 0x3f, 0x3c, 0x98, 0x3f, 0xbd, 0x94, 0x47, 0x80, 0xf3, 0xcb, 0xa1, 0xd7,
+ 0xa1, 0xe6, 0x06, 0xb1, 0x18, 0x83, 0x11, 0xe3, 0x55, 0x9a, 0x5a, 0xfd, 0x46, 0x53, 0xf5, 0x3f,
+ 0xfd, 0x83, 0xd3, 0x02, 0xe8, 0x1d, 0xfe, 0x4c, 0xae, 0xda, 0x87, 0xf0, 0xd7, 0x90, 0x5e, 0x29,
+ 0xb5, 0xf3, 0x35, 0xae, 0x3d, 0x70, 0x5f, 0x99, 0x0a, 0xf5, 0x33, 0x6e, 0x44, 0x18, 0x55, 0xa0,
+ 0xcf, 0x01, 0x8a, 0x49, 0xb4, 0xe7, 0xb5, 0xc8, 0x52, 0x8b, 0xe5, 0x9d, 0x64, 0x47, 0x72, 0x63,
+ 0x46, 0xbc, 0x3b, 0x6a, 0x76, 0x51, 0xe0, 0x9c, 0x52, 0xe8, 0x0a, 0xd5, 0x3b, 0x3a, 0x54, 0x44,
+ 0x66, 0x4a, 0xa3, 0x6e, 0xb6, 0x4e, 0xda, 0x11, 0x69, 0x39, 0x09, 0x71, 0x4d, 0x8e, 0x38, 0x53,
+ 0x8e, 0xae, 0x2c, 0x2a, 0x8d, 0x36, 0x98, 0xf1, 0x84, 0xdd, 0xa9, 0xb4, 0xe9, 0x1e, 0x69, 0x27,
+ 0x8c, 0x93, 0x1b, 0x24, 0xb9, 0x17, 0x46, 0x77, 0x99, 0x8f, 0x7d, 0x4c, 0x4b, 0xe4, 0x95, 0xa2,
+ 0xb0, 0x4e, 0x47, 0x6d, 0x20, 0x76, 0xb8, 0xb3, 0x5e, 0x67, 0x9e, 0xf3, 0xb1, 0x74, 0xee, 0x5c,
+ 0xe1, 0x60, 0x2c, 0xf1, 0x92, 0x74, 0xbd, 0xb1, 0xc2, 0xbc, 0xe0, 0x19, 0xd2, 0xf5, 0xc6, 0x0a,
+ 0x96, 0x78, 0x14, 0x76, 0xbf, 0xfd, 0x33, 0x55, 0xe6, 0x44, 0xa2, 0x5b, 0x8f, 0x97, 0x7c, 0xfe,
+ 0xe7, 0x3e, 0xcc, 0xa8, 0xf7, 0x87, 0x78, 0x86, 0xc5, 0x78, 0x76, 0xba, 0xcc, 0x23, 0xbd, 0xb9,
+ 0x89, 0x1a, 0x55, 0x28, 0xee, 0x7a, 0x86, 0x27, 0xee, 0xaa, 0xc5, 0x48, 0x07, 0x30, 0x53, 0x98,
+ 0x1a, 0x7d, 0x11, 0x6a, 0x71, 0x67, 0xd3, 0x0d, 0x77, 0x1d, 0x2f, 0x60, 0xae, 0x6a, 0xfd, 0xc9,
+ 0x59, 0x89, 0xc0, 0x29, 0xcd, 0xdc, 0x67, 0xe0, 0x44, 0x97, 0x4c, 0xf7, 0x15, 0x43, 0xf6, 0xe3,
+ 0x21, 0xa8, 0x29, 0x67, 0x0e, 0x5a, 0x34, 0xfd, 0x75, 0x8f, 0x67, 0xfd, 0x75, 0x63, 0x74, 0xfd,
+ 0xd5, 0x5d, 0x74, 0x5f, 0xca, 0x79, 0x73, 0xf2, 0xb9, 0xc2, 0x8f, 0x58, 0xfe, 0x2a, 0x47, 0x1f,
+ 0x2f, 0x72, 0xa6, 0x66, 0xfd, 0xd0, 0xb1, 0x66, 0x7d, 0xc9, 0x87, 0x85, 0xa8, 0x01, 0xdf, 0x0e,
+ 0xdd, 0xf5, 0x46, 0xf6, 0xf5, 0x8c, 0x06, 0x05, 0x62, 0x8e, 0x63, 0xa6, 0x17, 0x55, 0xca, 0xcc,
+ 0xf4, 0x1a, 0x7d, 0x20, 0xd3, 0x4b, 0x16, 0xc7, 0x29, 0x27, 0xb4, 0x07, 0x27, 0x5a, 0xe6, 0x53,
+ 0x28, 0xea, 0x7a, 0xc6, 0x0b, 0x7d, 0x3c, 0x45, 0xd2, 0xd1, 0xd2, 0xbe, 0xaf, 0x64, 0xf9, 0xe1,
+ 0xee, 0x2a, 0xd0, 0x6b, 0x30, 0xf6, 0x4e, 0x18, 0xaf, 0xf8, 0x4e, 0x1c, 0x0b, 0xbd, 0x24, 0x43,
+ 0xe1, 0xc7, 0xde, 0xbc, 0xd9, 0x64, 0xf0, 0x23, 0xfe, 0x06, 0xb8, 0xfc, 0x8b, 0x55, 0x01, 0xfb,
+ 0x47, 0xdc, 0x6d, 0x24, 0xb6, 0x92, 0x24, 0xee, 0xf8, 0x83, 0xcc, 0x02, 0x7d, 0xd3, 0xd8, 0xdd,
+ 0x3e, 0x04, 0x87, 0xe5, 0xef, 0x5a, 0xcc, 0x61, 0xb9, 0x41, 0x76, 0xdb, 0xbe, 0x93, 0x0c, 0x32,
+ 0xaa, 0xef, 0x8b, 0x30, 0x96, 0x88, 0x5a, 0xca, 0xa5, 0xae, 0xd6, 0x9a, 0xc5, 0x1c, 0xb8, 0x4a,
+ 0x85, 0x48, 0x28, 0x56, 0x0c, 0xed, 0xdf, 0xe6, 0x5f, 0x41, 0x62, 0x06, 0xbe, 0x27, 0xbb, 0x61,
+ 0xee, 0xc9, 0x9e, 0x2d, 0xdd, 0x93, 0x5e, 0x7b, 0x33, 0xb3, 0xfd, 0xcc, 0xce, 0xfb, 0xf0, 0xfb,
+ 0xcf, 0xed, 0xeb, 0x60, 0x3e, 0x0c, 0x83, 0x5e, 0xe7, 0x31, 0xb1, 0x5c, 0x91, 0x3e, 0xd7, 0x67,
+ 0x3c, 0xac, 0xfd, 0xbd, 0x0a, 0x9c, 0xca, 0x7b, 0x20, 0x1e, 0xb9, 0x30, 0xd1, 0xd6, 0x6c, 0xef,
+ 0x72, 0xe9, 0x0e, 0x74, 0x6b, 0x3d, 0xb5, 0x78, 0x74, 0x28, 0x36, 0xb8, 0xa2, 0x4d, 0x98, 0x20,
+ 0x7b, 0x5e, 0x4b, 0xb9, 0x64, 0x2a, 0x7d, 0x6a, 0x36, 0x55, 0xc7, 0xaa, 0xc6, 0x05, 0x1b, 0x3c,
+ 0x07, 0x90, 0x57, 0xdd, 0xfe, 0x27, 0x16, 0x3c, 0xd6, 0x23, 0x21, 0x02, 0xad, 0xee, 0x1e, 0xf3,
+ 0x59, 0x8a, 0x57, 0x87, 0x54, 0x75, 0xdc, 0x93, 0x89, 0x05, 0x16, 0x6d, 0x02, 0x70, 0x4f, 0x24,
+ 0x7b, 0x81, 0xb5, 0x52, 0x26, 0x5c, 0xa0, 0xeb, 0xfa, 0xb1, 0x76, 0x33, 0x55, 0xbd, 0xb9, 0xaa,
+ 0x71, 0xb5, 0xbf, 0x5b, 0x85, 0x61, 0xfe, 0x08, 0x64, 0x03, 0x46, 0x77, 0x78, 0xda, 0xc5, 0xfe,
+ 0xb2, 0x3e, 0xa6, 0xb6, 0x15, 0x07, 0x60, 0xc9, 0x06, 0x5d, 0x87, 0x93, 0x5e, 0xe0, 0x25, 0x9e,
+ 0xe3, 0xd7, 0x89, 0xef, 0xec, 0x4b, 0x63, 0x9d, 0xa7, 0xdc, 0x96, 0xd9, 0x61, 0x4f, 0xae, 0x77,
+ 0x93, 0xe0, 0xbc, 0x72, 0xe8, 0x8d, 0xae, 0xec, 0x49, 0x3c, 0x9d, 0xa5, 0xba, 0xd0, 0x74, 0x7c,
+ 0x06, 0x25, 0xf4, 0x1a, 0x4c, 0xb6, 0xbb, 0xb6, 0x25, 0xda, 0xeb, 0x81, 0xe6, 0x56, 0xc4, 0xa4,
+ 0x45, 0x75, 0x98, 0x89, 0x3b, 0xec, 0xf0, 0x76, 0x63, 0x27, 0x22, 0xf1, 0x4e, 0xe8, 0xbb, 0xe2,
+ 0xf9, 0x2b, 0x65, 0x82, 0x35, 0x33, 0x78, 0xdc, 0x55, 0x82, 0x72, 0xd9, 0x72, 0x3c, 0xbf, 0x13,
+ 0x91, 0x94, 0xcb, 0x88, 0xc9, 0x65, 0x2d, 0x83, 0xc7, 0x5d, 0x25, 0xec, 0x3f, 0xb5, 0xe0, 0x64,
+ 0x4e, 0x84, 0x03, 0x8f, 0xba, 0xdb, 0xf6, 0xe2, 0x44, 0x25, 0x56, 0xd6, 0xa2, 0xee, 0x38, 0x1c,
+ 0x2b, 0x0a, 0x2a, 0x85, 0x7c, 0xaf, 0x99, 0x3d, 0x39, 0x14, 0x67, 0xb8, 0x02, 0xdb, 0x5f, 0x2e,
+ 0x24, 0xf5, 0x8a, 0xfd, 0x50, 0xcf, 0x57, 0xec, 0x9f, 0x82, 0xe1, 0x6d, 0xb5, 0xaf, 0xd7, 0x8c,
+ 0x19, 0xbe, 0xb3, 0xe7, 0x38, 0xfb, 0x5b, 0x55, 0x98, 0xce, 0x44, 0x3a, 0xd1, 0x86, 0x64, 0x1e,
+ 0xdb, 0x67, 0xce, 0x88, 0x15, 0xd2, 0xde, 0xc9, 0x79, 0x70, 0xff, 0x19, 0xf3, 0x45, 0xde, 0xb4,
+ 0xcd, 0xcb, 0x75, 0xe3, 0xd1, 0xb1, 0xb2, 0xc9, 0xde, 0x9f, 0x82, 0xa1, 0x76, 0xa8, 0x9e, 0x8e,
+ 0x54, 0x42, 0x8f, 0x97, 0xeb, 0x8d, 0x30, 0xf4, 0x31, 0x43, 0xa2, 0xa7, 0x45, 0xef, 0x33, 0x0e,
+ 0x4d, 0xec, 0xb8, 0x61, 0xac, 0x0d, 0xc1, 0xb3, 0x30, 0x7a, 0x97, 0xec, 0x47, 0x5e, 0xb0, 0x9d,
+ 0x75, 0xe7, 0x5e, 0xe5, 0x60, 0x2c, 0xf1, 0x66, 0x42, 0xf7, 0xd1, 0x01, 0x27, 0x74, 0x1f, 0x2b,
+ 0x0c, 0xd5, 0xfc, 0x4d, 0x0b, 0xa6, 0x59, 0x42, 0x3a, 0x71, 0x57, 0xd4, 0x0b, 0x83, 0x01, 0x2e,
+ 0x89, 0x4f, 0xc1, 0x70, 0x44, 0x2b, 0xcb, 0xe6, 0x62, 0x66, 0x2d, 0xc0, 0x1c, 0x87, 0x9e, 0x10,
+ 0xaf, 0x9a, 0xd3, 0xcf, 0x37, 0xc1, 0x73, 0xdb, 0xa6, 0xcf, 0x93, 0xb3, 0x2b, 0x00, 0x98, 0xb4,
+ 0x7d, 0x8f, 0x37, 0x36, 0xf5, 0xde, 0x7c, 0x58, 0xae, 0x00, 0xe4, 0x36, 0xee, 0x61, 0x5d, 0x01,
+ 0xc8, 0x67, 0x7e, 0xbc, 0xf1, 0xf9, 0x3f, 0x2a, 0x70, 0x36, 0xb7, 0x5c, 0x7a, 0x08, 0xb4, 0x66,
+ 0x1c, 0x02, 0x5d, 0xca, 0x1c, 0x02, 0xd9, 0xc7, 0x97, 0x7e, 0x38, 0xc7, 0x42, 0xf9, 0xe7, 0x35,
+ 0xd5, 0x47, 0x76, 0x5e, 0x33, 0x54, 0xd6, 0x50, 0x18, 0x2e, 0x30, 0x14, 0x7e, 0x6a, 0xc1, 0xe3,
+ 0xb9, 0x03, 0xf6, 0x21, 0xbb, 0x71, 0x91, 0xdb, 0xc6, 0x1e, 0x86, 0xf3, 0xdf, 0xae, 0xf6, 0xe8,
+ 0x13, 0x33, 0xa1, 0xcf, 0x53, 0x8d, 0xc3, 0x90, 0xb1, 0x30, 0x80, 0x26, 0xb8, 0xb6, 0xe1, 0x30,
+ 0xac, 0xb0, 0x28, 0xd6, 0x6e, 0x2c, 0xf0, 0x46, 0xae, 0x3e, 0xe0, 0x64, 0x5a, 0x30, 0x5d, 0x6d,
+ 0xfa, 0x75, 0xd7, 0xcc, 0x4d, 0x06, 0x74, 0x47, 0xdb, 0x12, 0x55, 0x1f, 0x64, 0x4b, 0x34, 0x91,
+ 0xbf, 0x1d, 0x42, 0x4b, 0x30, 0xbd, 0xeb, 0x05, 0xec, 0x75, 0x33, 0xd3, 0x02, 0x51, 0x97, 0xc4,
+ 0xae, 0x9b, 0x68, 0x9c, 0xa5, 0x9f, 0x7b, 0x0d, 0x26, 0x1f, 0xdc, 0xbf, 0xf2, 0x7e, 0x15, 0x7e,
+ 0xee, 0x18, 0x85, 0xc0, 0x57, 0x02, 0xe3, 0xbb, 0x68, 0x2b, 0x41, 0xd7, 0xb7, 0x69, 0xc0, 0xa9,
+ 0xad, 0x8e, 0xef, 0xef, 0xb3, 0xf0, 0x09, 0xe2, 0x4a, 0x0a, 0x61, 0xdd, 0xa9, 0x77, 0x47, 0xd7,
+ 0x72, 0x68, 0x70, 0x6e, 0x49, 0xf4, 0x39, 0x40, 0xe1, 0x26, 0x4b, 0xd1, 0xe8, 0xa6, 0x17, 0x7a,
+ 0xd9, 0x27, 0xa8, 0xa6, 0x13, 0xf5, 0x66, 0x17, 0x05, 0xce, 0x29, 0x45, 0x6d, 0x3d, 0xf6, 0x64,
+ 0xa9, 0x6a, 0x56, 0xc6, 0xd6, 0xc3, 0x3a, 0x12, 0x9b, 0xb4, 0xe8, 0x32, 0x9c, 0x70, 0xf6, 0x1c,
+ 0x8f, 0x27, 0x63, 0x91, 0x0c, 0xb8, 0xb1, 0xa7, 0x7c, 0x18, 0x4b, 0x59, 0x02, 0xdc, 0x5d, 0x06,
+ 0xb5, 0x0d, 0x97, 0x14, 0x4f, 0xc6, 0xfc, 0xfa, 0x03, 0x48, 0x70, 0x69, 0x27, 0x95, 0xfd, 0x27,
+ 0x16, 0x5d, 0xee, 0x72, 0x1e, 0x04, 0x33, 0xde, 0xce, 0xd6, 0xee, 0x71, 0x74, 0xbf, 0x9d, 0xcd,
+ 0xbc, 0xb5, 0x26, 0x2d, 0x17, 0x8d, 0x38, 0x8d, 0xbd, 0x34, 0x2c, 0x4b, 0x71, 0x79, 0x49, 0x51,
+ 0xa0, 0x3b, 0x30, 0xea, 0x7a, 0x7b, 0x5e, 0x1c, 0x46, 0x25, 0xde, 0xac, 0xed, 0x8a, 0xe7, 0x4b,
+ 0x75, 0x65, 0x9d, 0x33, 0xc1, 0x92, 0x9b, 0xfd, 0x77, 0x2a, 0x30, 0x29, 0xeb, 0x7b, 0xb3, 0x13,
+ 0x32, 0x1d, 0x36, 0xa8, 0x45, 0xfc, 0x4d, 0x63, 0x11, 0x5f, 0x2c, 0x77, 0x83, 0x8b, 0x35, 0xaa,
+ 0xe7, 0xe2, 0xfd, 0xf9, 0xcc, 0xe2, 0x7d, 0xb1, 0x1f, 0xa6, 0xc7, 0x2f, 0xda, 0xff, 0xd6, 0x82,
+ 0x13, 0x06, 0xfd, 0x87, 0x25, 0x1f, 0x70, 0x5e, 0x5f, 0x7a, 0xac, 0x1a, 0xdf, 0xad, 0x64, 0xfa,
+ 0xc0, 0x56, 0x8b, 0xaf, 0xc1, 0xd0, 0x8e, 0x13, 0xb9, 0xe5, 0x72, 0x91, 0x75, 0x15, 0x5f, 0xb8,
+ 0xe2, 0x44, 0x2e, 0xd7, 0xf9, 0x17, 0xd4, 0x93, 0x25, 0x4e, 0xe4, 0x16, 0x86, 0x21, 0xb3, 0x4a,
+ 0xd1, 0xab, 0x30, 0x12, 0xb7, 0xc2, 0xb6, 0x0a, 0xfd, 0x3a, 0xc7, 0x9f, 0x33, 0xa1, 0x90, 0xa3,
+ 0x83, 0x79, 0x64, 0x56, 0x47, 0xc1, 0x58, 0xd0, 0xcf, 0x11, 0xa8, 0xa9, 0xaa, 0x07, 0x18, 0xf0,
+ 0xfa, 0x7e, 0x15, 0x4e, 0xe6, 0xc8, 0x09, 0xfa, 0x79, 0x63, 0xd4, 0x5e, 0xeb, 0x5b, 0xd0, 0x3e,
+ 0xe0, 0xb8, 0xfd, 0x3c, 0xdb, 0x07, 0xb9, 0x42, 0x36, 0x1e, 0xa0, 0xfa, 0x5b, 0x31, 0xc9, 0x56,
+ 0x4f, 0x41, 0xc5, 0xd5, 0xd3, 0x6a, 0x1f, 0xd1, 0xe0, 0xd3, 0x6a, 0x54, 0x3b, 0x07, 0xf8, 0x8d,
+ 0xdf, 0x1b, 0x82, 0x53, 0x79, 0x57, 0x44, 0xd1, 0x2f, 0x59, 0x99, 0x74, 0xe2, 0x6f, 0xf4, 0x7f,
+ 0xcf, 0x94, 0xe7, 0x18, 0x17, 0x09, 0x14, 0x16, 0xcc, 0x04, 0xe3, 0x85, 0xa3, 0x2d, 0x6a, 0x67,
+ 0x57, 0x07, 0x22, 0x9e, 0x16, 0x5e, 0xea, 0x83, 0xcf, 0x3e, 0x40, 0x53, 0x44, 0x66, 0xf9, 0x38,
+ 0x73, 0x75, 0x40, 0x82, 0x8b, 0xaf, 0x0e, 0xc8, 0x36, 0xcc, 0x6d, 0xc3, 0xb8, 0xd6, 0xaf, 0x01,
+ 0x8a, 0x80, 0x47, 0x17, 0x24, 0xad, 0xd5, 0x03, 0x14, 0x83, 0xbf, 0x67, 0x41, 0x26, 0xbe, 0x43,
+ 0x39, 0x5b, 0xac, 0x9e, 0xce, 0x96, 0x73, 0x30, 0x14, 0x85, 0x3e, 0xc9, 0xa6, 0xba, 0xc6, 0xa1,
+ 0x4f, 0x30, 0xc3, 0xa8, 0x77, 0x0b, 0xab, 0xbd, 0xde, 0x2d, 0xa4, 0xbb, 0x70, 0x9f, 0xec, 0x11,
+ 0xe9, 0xfa, 0x50, 0xca, 0xfb, 0x1a, 0x05, 0x62, 0x8e, 0xb3, 0x7f, 0xbf, 0x0a, 0x23, 0xdc, 0xbf,
+ 0x30, 0xc0, 0x35, 0xb9, 0x21, 0xb6, 0xfa, 0xa5, 0xae, 0x6c, 0xf2, 0xd6, 0x2c, 0xd4, 0x9d, 0xc4,
+ 0xe1, 0x02, 0xa5, 0xfa, 0x96, 0xba, 0x07, 0xd0, 0x82, 0xd1, 0xfb, 0xb9, 0xcc, 0x4e, 0x16, 0x38,
+ 0x0f, 0x6d, 0x2c, 0x76, 0x00, 0x62, 0xf6, 0x46, 0x16, 0xe5, 0x21, 0x12, 0xc6, 0xbd, 0x54, 0xaa,
+ 0x1d, 0x4d, 0x55, 0x8c, 0xb7, 0x26, 0xcd, 0x54, 0xa5, 0x10, 0x58, 0xe3, 0x3d, 0xf7, 0x0a, 0xd4,
+ 0x14, 0x71, 0x91, 0x99, 0x3f, 0xa1, 0x8b, 0xe4, 0x5f, 0x81, 0xe9, 0x4c, 0x5d, 0x7d, 0xed, 0x12,
+ 0x7e, 0x68, 0xc1, 0x89, 0xae, 0xc7, 0x56, 0xd1, 0x7b, 0x16, 0x9c, 0xf2, 0x73, 0x1c, 0x4b, 0xc5,
+ 0xf1, 0x35, 0x3d, 0x5d, 0x52, 0x6a, 0x8b, 0x90, 0x87, 0xc5, 0xb9, 0xb5, 0xc9, 0x14, 0x98, 0x95,
+ 0xfc, 0x14, 0x98, 0xf6, 0xf7, 0x2c, 0x10, 0x9f, 0x6c, 0xe0, 0xe6, 0xcf, 0xba, 0x69, 0xfe, 0x7c,
+ 0xac, 0x8c, 0x0c, 0xf4, 0xb0, 0x7b, 0xfe, 0x83, 0x05, 0x88, 0x13, 0x64, 0x1f, 0xca, 0xe3, 0x5e,
+ 0x3a, 0xcd, 0x5a, 0x4f, 0x85, 0x46, 0x61, 0xb0, 0x46, 0xd5, 0x67, 0x36, 0x74, 0xf5, 0xc0, 0x54,
+ 0xb9, 0xb7, 0xe5, 0xab, 0x25, 0xde, 0x96, 0xff, 0xdd, 0x2a, 0x64, 0x43, 0x20, 0xd0, 0x57, 0x60,
+ 0xa2, 0xe5, 0xb4, 0x9d, 0x4d, 0xcf, 0xf7, 0x12, 0x8f, 0xc4, 0xe5, 0xce, 0x89, 0x56, 0xb4, 0x12,
+ 0xc2, 0xcf, 0xab, 0x41, 0xb0, 0xc1, 0x11, 0x2d, 0x00, 0xb4, 0x23, 0x6f, 0xcf, 0xf3, 0xc9, 0x36,
+ 0x33, 0x3a, 0x58, 0x14, 0x24, 0x3f, 0xf4, 0x90, 0x50, 0xac, 0x51, 0xe4, 0x44, 0xdc, 0x55, 0x1f,
+ 0x45, 0xc4, 0xdd, 0x50, 0x9f, 0x11, 0x77, 0xc3, 0xa5, 0x22, 0xee, 0x30, 0x9c, 0x91, 0xee, 0x59,
+ 0xfa, 0x7f, 0xcd, 0xf3, 0x09, 0x4f, 0x78, 0x27, 0xe2, 0x24, 0xe7, 0x0e, 0x0f, 0xe6, 0xcf, 0xe0,
+ 0x5c, 0x0a, 0xdc, 0xa3, 0xa4, 0xdd, 0x81, 0x93, 0x4d, 0x12, 0x79, 0x2c, 0x1f, 0x91, 0x9b, 0x4e,
+ 0xbf, 0x2f, 0x41, 0x2d, 0xca, 0xcc, 0xfc, 0x3e, 0xaf, 0xac, 0x69, 0x59, 0x2d, 0xe4, 0x4c, 0x4f,
+ 0x59, 0xda, 0x7f, 0xbd, 0x02, 0xa3, 0x22, 0xd4, 0x68, 0x80, 0xab, 0xc8, 0x55, 0x63, 0x67, 0xf7,
+ 0x6c, 0xd1, 0xcc, 0x65, 0xcd, 0xe9, 0xb9, 0xa7, 0x6b, 0x66, 0xf6, 0x74, 0xcf, 0x97, 0x63, 0x77,
+ 0xfc, 0x6e, 0xee, 0x77, 0x2a, 0x30, 0x65, 0x86, 0x5c, 0x0d, 0x70, 0x38, 0xde, 0x82, 0xd1, 0x58,
+ 0xc4, 0x21, 0x95, 0x7a, 0xcd, 0x3f, 0xfb, 0x49, 0xd3, 0x77, 0xea, 0x45, 0xe4, 0x91, 0x64, 0x97,
+ 0x1b, 0xea, 0x54, 0x7d, 0x14, 0xa1, 0x4e, 0xf6, 0xbf, 0x63, 0x2a, 0x55, 0x1f, 0xc0, 0x81, 0x2f,
+ 0x08, 0x6f, 0x9a, 0xaa, 0xf7, 0x42, 0x29, 0x39, 0x10, 0x8d, 0xeb, 0xb1, 0x30, 0xfc, 0x2b, 0x0b,
+ 0xc6, 0x05, 0xe1, 0xc0, 0x9b, 0xff, 0x39, 0xb3, 0xf9, 0x4f, 0x97, 0x6a, 0x7e, 0x8f, 0x76, 0xff,
+ 0x83, 0x8a, 0x6a, 0x77, 0x43, 0x3c, 0x1d, 0x5a, 0x98, 0xfb, 0x70, 0xac, 0x1d, 0x85, 0x49, 0xd8,
+ 0x0a, 0x7d, 0xb1, 0xb8, 0x3f, 0x91, 0x86, 0xa6, 0x73, 0xf8, 0x91, 0xf6, 0x1b, 0x2b, 0x6a, 0x16,
+ 0x75, 0x1d, 0x46, 0x89, 0x58, 0x9c, 0xf2, 0x1e, 0x2e, 0xdd, 0x94, 0x0f, 0x43, 0x53, 0x98, 0xb8,
+ 0xd1, 0xd1, 0xef, 0x83, 0xa8, 0x69, 0xac, 0xb9, 0xe2, 0x84, 0x35, 0xae, 0x32, 0x00, 0x92, 0xd5,
+ 0x30, 0x6c, 0xba, 0x4e, 0x6f, 0x08, 0x38, 0x56, 0x14, 0xf6, 0x2b, 0x4c, 0xbb, 0xb2, 0xe1, 0xe9,
+ 0x2f, 0x80, 0xfc, 0x57, 0x46, 0xd4, 0xc0, 0x32, 0xdf, 0xc8, 0x0d, 0x18, 0xa6, 0x5d, 0x94, 0xdb,
+ 0xbf, 0x72, 0xaa, 0x8c, 0x36, 0x41, 0x0f, 0x21, 0x8b, 0x92, 0x18, 0x73, 0x36, 0x88, 0x74, 0xf9,
+ 0xdb, 0x5f, 0x29, 0xad, 0x1d, 0xfb, 0xf0, 0xb0, 0xb3, 0x74, 0x32, 0x2c, 0x8b, 0xc6, 0x7a, 0x23,
+ 0x9b, 0xaf, 0x72, 0x45, 0x22, 0x70, 0x4a, 0x83, 0x16, 0x85, 0x95, 0x6e, 0xbe, 0x2b, 0x2b, 0xad,
+ 0x74, 0x39, 0x24, 0x9a, 0x99, 0x7e, 0x11, 0xc6, 0x55, 0xc6, 0xee, 0x06, 0x4f, 0xbc, 0x5c, 0xe3,
+ 0x96, 0xcb, 0x6a, 0x0a, 0xc6, 0x3a, 0x0d, 0x5a, 0x87, 0x93, 0xae, 0x8a, 0x77, 0x6d, 0x74, 0x36,
+ 0x7d, 0xaf, 0x45, 0x8b, 0xf2, 0xbb, 0x26, 0x8f, 0x1d, 0x1e, 0xcc, 0x9f, 0xac, 0x77, 0xa3, 0x71,
+ 0x5e, 0x19, 0xb4, 0x01, 0xd3, 0x31, 0xcf, 0x4c, 0x2e, 0xef, 0xa3, 0x89, 0x84, 0x6e, 0xcf, 0x49,
+ 0x47, 0x7f, 0xd3, 0x44, 0x1f, 0x31, 0x10, 0xd7, 0x08, 0x02, 0x84, 0xb3, 0x2c, 0xd0, 0x1b, 0x30,
+ 0xe5, 0xeb, 0x8f, 0x2b, 0x35, 0x44, 0xd8, 0xaf, 0x0a, 0x7f, 0x30, 0x9e, 0x5e, 0x6a, 0xe0, 0x0c,
+ 0x35, 0x7a, 0x0b, 0x66, 0x75, 0x88, 0xb8, 0xed, 0xee, 0x04, 0xdb, 0x24, 0x16, 0x29, 0x91, 0x9f,
+ 0x38, 0x3c, 0x98, 0x9f, 0xbd, 0xd6, 0x83, 0x06, 0xf7, 0x2c, 0x8d, 0x5e, 0x85, 0x09, 0x39, 0x92,
+ 0x5a, 0x08, 0x70, 0x1a, 0x78, 0xa3, 0xe1, 0xb0, 0x41, 0xf9, 0xc1, 0xce, 0x33, 0xbe, 0x46, 0x0b,
+ 0x6b, 0xcb, 0x29, 0xfa, 0x2a, 0x4c, 0xe8, 0x6d, 0x14, 0x3a, 0xf2, 0x13, 0xe5, 0x1f, 0xac, 0x12,
+ 0xcb, 0xb2, 0x6a, 0xb9, 0x8e, 0xc3, 0x06, 0x6f, 0xfb, 0x26, 0x8c, 0x34, 0xf7, 0xe3, 0x56, 0xe2,
+ 0x3f, 0xac, 0x27, 0x85, 0x5b, 0x30, 0x9d, 0x79, 0x7b, 0x57, 0x3d, 0xe2, 0x6c, 0x3d, 0xac, 0x47,
+ 0x9c, 0xed, 0xaf, 0x5b, 0x30, 0xbc, 0xe1, 0x78, 0xc5, 0x8f, 0x09, 0x94, 0x69, 0x32, 0x7a, 0x19,
+ 0x46, 0xc8, 0xd6, 0x16, 0x69, 0xc9, 0x47, 0xa1, 0x9f, 0x94, 0xe6, 0xcc, 0x2a, 0x83, 0xd2, 0xa9,
+ 0xc9, 0x2a, 0xe3, 0x7f, 0xb1, 0x20, 0xb6, 0xff, 0xa3, 0x05, 0xb0, 0x11, 0xfa, 0xf2, 0xa8, 0xa6,
+ 0xa0, 0x25, 0xcb, 0x5d, 0xcf, 0x1a, 0x3c, 0x93, 0xf3, 0xac, 0x01, 0x4a, 0x19, 0xe6, 0x3c, 0x6a,
+ 0xa0, 0x7a, 0x53, 0x2d, 0xd5, 0x9b, 0xa1, 0x7e, 0x7a, 0xf3, 0x4d, 0x0b, 0x44, 0xc4, 0x4c, 0x09,
+ 0x49, 0x70, 0x65, 0x2a, 0x72, 0x23, 0x8f, 0xc5, 0x73, 0x65, 0xae, 0x8a, 0x88, 0xec, 0x15, 0x4a,
+ 0x36, 0x8d, 0x9c, 0x15, 0x06, 0x57, 0xba, 0x85, 0x1f, 0xe7, 0xe8, 0xeb, 0xcc, 0x76, 0x2c, 0x6e,
+ 0x57, 0x5f, 0xf9, 0xba, 0x58, 0xa6, 0x6e, 0xca, 0x58, 0x65, 0x6e, 0xd2, 0x33, 0x75, 0x4b, 0x04,
+ 0x4e, 0x69, 0xd0, 0xb3, 0x30, 0x1a, 0x77, 0x36, 0x19, 0x79, 0x26, 0x7c, 0xa6, 0xc9, 0xc1, 0x58,
+ 0xe2, 0xed, 0x5f, 0x44, 0x60, 0x74, 0xcd, 0xc8, 0x12, 0x65, 0x3d, 0xf4, 0x2c, 0x51, 0x6f, 0xc3,
+ 0x18, 0xd9, 0x6d, 0x27, 0xfb, 0x75, 0x2f, 0x2a, 0x97, 0xab, 0x6f, 0x55, 0x50, 0x77, 0x73, 0x97,
+ 0x18, 0xac, 0x38, 0xf6, 0xc8, 0xf9, 0x55, 0xfd, 0x50, 0xe4, 0xfc, 0x1a, 0xfa, 0x0b, 0xc9, 0xf9,
+ 0xf5, 0x16, 0x8c, 0x6e, 0x7b, 0x09, 0x26, 0xed, 0x50, 0xdc, 0x0e, 0x2c, 0x38, 0x03, 0xbb, 0xcc,
+ 0x89, 0xbb, 0x13, 0xf9, 0x08, 0x04, 0x96, 0xec, 0xd0, 0x06, 0x8c, 0xf0, 0x7d, 0x87, 0x48, 0xa3,
+ 0xf5, 0x89, 0x32, 0x1e, 0x99, 0xee, 0x8c, 0x52, 0x22, 0x46, 0x4a, 0xf0, 0x92, 0x39, 0xbe, 0x46,
+ 0x3f, 0x78, 0x8e, 0x2f, 0x95, 0x99, 0x6b, 0xec, 0x61, 0x65, 0xe6, 0x32, 0x32, 0x9c, 0xd5, 0x06,
+ 0x91, 0xe1, 0xec, 0x9b, 0x16, 0x9c, 0x6e, 0xe7, 0x65, 0x07, 0x14, 0x39, 0xb6, 0x3e, 0xf3, 0x00,
+ 0xd9, 0x12, 0x8d, 0xaa, 0xd9, 0x8d, 0xad, 0x5c, 0x32, 0x9c, 0x5f, 0xb1, 0x4c, 0x95, 0x36, 0xfe,
+ 0xc1, 0x53, 0xa5, 0x0d, 0x3a, 0x19, 0x57, 0x9a, 0x38, 0x6d, 0x72, 0x20, 0x89, 0xd3, 0xa6, 0x1e,
+ 0x62, 0xe2, 0x34, 0x2d, 0xe5, 0xd9, 0xf4, 0xc3, 0x4d, 0x79, 0xb6, 0x03, 0xe3, 0x6e, 0x78, 0x2f,
+ 0xb8, 0xe7, 0x44, 0xee, 0x52, 0x63, 0x5d, 0x64, 0xd8, 0x2a, 0x48, 0xe8, 0x50, 0x4f, 0x0b, 0x18,
+ 0x35, 0x70, 0xd7, 0x63, 0x8a, 0xc4, 0x3a, 0x6b, 0x91, 0xfc, 0xed, 0xc4, 0x07, 0x4c, 0xfe, 0x66,
+ 0xa4, 0x50, 0x43, 0x83, 0x48, 0xa1, 0xf6, 0x15, 0x76, 0xbf, 0x7b, 0xcb, 0xdb, 0xbe, 0xee, 0xb4,
+ 0x67, 0x4f, 0x96, 0xa9, 0x61, 0x45, 0x92, 0x77, 0xd7, 0xa0, 0x50, 0x38, 0x65, 0xda, 0x9d, 0xa4,
+ 0xed, 0xd4, 0xa3, 0x4e, 0xd2, 0x76, 0x7a, 0x80, 0x49, 0xda, 0xce, 0x3c, 0xd2, 0x24, 0x6d, 0x8f,
+ 0xfd, 0x85, 0x24, 0x69, 0xfb, 0xab, 0x70, 0xf6, 0xf8, 0xcf, 0x91, 0x26, 0x00, 0x6e, 0xa4, 0x2e,
+ 0x83, 0x4c, 0x02, 0x60, 0x66, 0xea, 0x68, 0x54, 0xa5, 0x73, 0x45, 0x7d, 0xcf, 0x82, 0xc7, 0x7a,
+ 0x24, 0x55, 0x29, 0x7d, 0x77, 0xa1, 0x0d, 0xd3, 0x6d, 0xb3, 0x68, 0xe9, 0xfb, 0x45, 0x46, 0x12,
+ 0x17, 0x15, 0x1b, 0x97, 0x41, 0xe0, 0x2c, 0xfb, 0xe5, 0x8f, 0xfd, 0xf8, 0xfd, 0xb3, 0x1f, 0xf9,
+ 0xc9, 0xfb, 0x67, 0x3f, 0xf2, 0x47, 0xef, 0x9f, 0xfd, 0xc8, 0x2f, 0x1c, 0x9e, 0xb5, 0x7e, 0x7c,
+ 0x78, 0xd6, 0xfa, 0xc9, 0xe1, 0x59, 0xeb, 0x4f, 0x0f, 0xcf, 0x5a, 0xdf, 0xfc, 0xb3, 0xb3, 0x1f,
+ 0xf9, 0x42, 0x65, 0xef, 0xe2, 0xff, 0x0b, 0x00, 0x00, 0xff, 0xff, 0x04, 0xd2, 0x8a, 0x4f, 0x3d,
+ 0xb5, 0x00, 0x00,
}
diff --git a/pkg/api/v1/generated.proto b/pkg/api/v1/generated.proto
index 10098cf7b38..2b86c8c1ad8 100644
--- a/pkg/api/v1/generated.proto
+++ b/pkg/api/v1/generated.proto
@@ -2560,6 +2560,12 @@ message PodStatus {
// More info: http://kubernetes.io/docs/user-guide/pod-states#container-statuses
// +optional
repeated ContainerStatus containerStatuses = 8;
+
+ // The Quality of Service (QOS) classification assigned to the pod based on resource requirements
+ // See PodQOSClass type for available QOS classes
+ // More info: https://github.com/kubernetes/kubernetes/blob/master/docs/design/resource-qos.md
+ // +optional
+ optional string qosClass = 9;
}
// PodStatusResult is a wrapper for PodStatus returned by kubelet that can be encode/decoded
diff --git a/pkg/api/v1/types.generated.go b/pkg/api/v1/types.generated.go
index 0c75ec86f94..7fd5322f3ce 100644
--- a/pkg/api/v1/types.generated.go
+++ b/pkg/api/v1/types.generated.go
@@ -29041,6 +29041,32 @@ func (x *PodSecurityContext) codecDecodeSelfFromArray(l int, d *codec1978.Decode
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
+func (x PodQOSClass) CodecEncodeSelf(e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ yym2166 := z.EncBinary()
+ _ = yym2166
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x) {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x))
+ }
+}
+
+func (x *PodQOSClass) CodecDecodeSelf(d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+ yym2167 := z.DecBinary()
+ _ = yym2167
+ if false {
+ } else if z.HasExtensions() && z.DecExt(x) {
+ } else {
+ *((*string)(x)) = r.DecodeString()
+ }
+}
+
func (x *PodStatus) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
@@ -29048,60 +29074,61 @@ func (x *PodStatus) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym2166 := z.EncBinary()
- _ = yym2166
+ yym2168 := z.EncBinary()
+ _ = yym2168
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep2167 := !z.EncBinary()
- yy2arr2167 := z.EncBasicHandle().StructToArray
- var yyq2167 [8]bool
- _, _, _ = yysep2167, yyq2167, yy2arr2167
- const yyr2167 bool = false
- yyq2167[0] = x.Phase != ""
- yyq2167[1] = len(x.Conditions) != 0
- yyq2167[2] = x.Message != ""
- yyq2167[3] = x.Reason != ""
- yyq2167[4] = x.HostIP != ""
- yyq2167[5] = x.PodIP != ""
- yyq2167[6] = x.StartTime != nil
- yyq2167[7] = len(x.ContainerStatuses) != 0
- var yynn2167 int
- if yyr2167 || yy2arr2167 {
- r.EncodeArrayStart(8)
+ yysep2169 := !z.EncBinary()
+ yy2arr2169 := z.EncBasicHandle().StructToArray
+ var yyq2169 [9]bool
+ _, _, _ = yysep2169, yyq2169, yy2arr2169
+ const yyr2169 bool = false
+ yyq2169[0] = x.Phase != ""
+ yyq2169[1] = len(x.Conditions) != 0
+ yyq2169[2] = x.Message != ""
+ yyq2169[3] = x.Reason != ""
+ yyq2169[4] = x.HostIP != ""
+ yyq2169[5] = x.PodIP != ""
+ yyq2169[6] = x.StartTime != nil
+ yyq2169[7] = len(x.ContainerStatuses) != 0
+ yyq2169[8] = x.QOSClass != ""
+ var yynn2169 int
+ if yyr2169 || yy2arr2169 {
+ r.EncodeArrayStart(9)
} else {
- yynn2167 = 0
- for _, b := range yyq2167 {
+ yynn2169 = 0
+ for _, b := range yyq2169 {
if b {
- yynn2167++
+ yynn2169++
}
}
- r.EncodeMapStart(yynn2167)
- yynn2167 = 0
+ r.EncodeMapStart(yynn2169)
+ yynn2169 = 0
}
- if yyr2167 || yy2arr2167 {
+ if yyr2169 || yy2arr2169 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2167[0] {
+ if yyq2169[0] {
x.Phase.CodecEncodeSelf(e)
} else {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2167[0] {
+ if yyq2169[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("phase"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
x.Phase.CodecEncodeSelf(e)
}
}
- if yyr2167 || yy2arr2167 {
+ if yyr2169 || yy2arr2169 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2167[1] {
+ if yyq2169[1] {
if x.Conditions == nil {
r.EncodeNil()
} else {
- yym2170 := z.EncBinary()
- _ = yym2170
+ yym2172 := z.EncBinary()
+ _ = yym2172
if false {
} else {
h.encSlicePodCondition(([]PodCondition)(x.Conditions), e)
@@ -29111,15 +29138,15 @@ func (x *PodStatus) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeNil()
}
} else {
- if yyq2167[1] {
+ if yyq2169[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("conditions"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
if x.Conditions == nil {
r.EncodeNil()
} else {
- yym2171 := z.EncBinary()
- _ = yym2171
+ yym2173 := z.EncBinary()
+ _ = yym2173
if false {
} else {
h.encSlicePodCondition(([]PodCondition)(x.Conditions), e)
@@ -29127,11 +29154,11 @@ func (x *PodStatus) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
- if yyr2167 || yy2arr2167 {
+ if yyr2169 || yy2arr2169 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2167[2] {
- yym2173 := z.EncBinary()
- _ = yym2173
+ if yyq2169[2] {
+ yym2175 := z.EncBinary()
+ _ = yym2175
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Message))
@@ -29140,24 +29167,24 @@ func (x *PodStatus) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2167[2] {
+ if yyq2169[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("message"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym2174 := z.EncBinary()
- _ = yym2174
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Message))
- }
- }
- }
- if yyr2167 || yy2arr2167 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2167[3] {
yym2176 := z.EncBinary()
_ = yym2176
if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Message))
+ }
+ }
+ }
+ if yyr2169 || yy2arr2169 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2169[3] {
+ yym2178 := z.EncBinary()
+ _ = yym2178
+ if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Reason))
}
@@ -29165,24 +29192,24 @@ func (x *PodStatus) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2167[3] {
+ if yyq2169[3] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("reason"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym2177 := z.EncBinary()
- _ = yym2177
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Reason))
- }
- }
- }
- if yyr2167 || yy2arr2167 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2167[4] {
yym2179 := z.EncBinary()
_ = yym2179
if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Reason))
+ }
+ }
+ }
+ if yyr2169 || yy2arr2169 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2169[4] {
+ yym2181 := z.EncBinary()
+ _ = yym2181
+ if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.HostIP))
}
@@ -29190,24 +29217,24 @@ func (x *PodStatus) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2167[4] {
+ if yyq2169[4] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("hostIP"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym2180 := z.EncBinary()
- _ = yym2180
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.HostIP))
- }
- }
- }
- if yyr2167 || yy2arr2167 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2167[5] {
yym2182 := z.EncBinary()
_ = yym2182
if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.HostIP))
+ }
+ }
+ }
+ if yyr2169 || yy2arr2169 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2169[5] {
+ yym2184 := z.EncBinary()
+ _ = yym2184
+ if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.PodIP))
}
@@ -29215,31 +29242,31 @@ func (x *PodStatus) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2167[5] {
+ if yyq2169[5] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("podIP"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym2183 := z.EncBinary()
- _ = yym2183
+ yym2185 := z.EncBinary()
+ _ = yym2185
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.PodIP))
}
}
}
- if yyr2167 || yy2arr2167 {
+ if yyr2169 || yy2arr2169 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2167[6] {
+ if yyq2169[6] {
if x.StartTime == nil {
r.EncodeNil()
} else {
- yym2185 := z.EncBinary()
- _ = yym2185
+ yym2187 := z.EncBinary()
+ _ = yym2187
if false {
} else if z.HasExtensions() && z.EncExt(x.StartTime) {
- } else if yym2185 {
+ } else if yym2187 {
z.EncBinaryMarshal(x.StartTime)
- } else if !yym2185 && z.IsJSONHandle() {
+ } else if !yym2187 && z.IsJSONHandle() {
z.EncJSONMarshal(x.StartTime)
} else {
z.EncFallback(x.StartTime)
@@ -29249,20 +29276,20 @@ func (x *PodStatus) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeNil()
}
} else {
- if yyq2167[6] {
+ if yyq2169[6] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("startTime"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
if x.StartTime == nil {
r.EncodeNil()
} else {
- yym2186 := z.EncBinary()
- _ = yym2186
+ yym2188 := z.EncBinary()
+ _ = yym2188
if false {
} else if z.HasExtensions() && z.EncExt(x.StartTime) {
- } else if yym2186 {
+ } else if yym2188 {
z.EncBinaryMarshal(x.StartTime)
- } else if !yym2186 && z.IsJSONHandle() {
+ } else if !yym2188 && z.IsJSONHandle() {
z.EncJSONMarshal(x.StartTime)
} else {
z.EncFallback(x.StartTime)
@@ -29270,14 +29297,14 @@ func (x *PodStatus) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
- if yyr2167 || yy2arr2167 {
+ if yyr2169 || yy2arr2169 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2167[7] {
+ if yyq2169[7] {
if x.ContainerStatuses == nil {
r.EncodeNil()
} else {
- yym2188 := z.EncBinary()
- _ = yym2188
+ yym2190 := z.EncBinary()
+ _ = yym2190
if false {
} else {
h.encSliceContainerStatus(([]ContainerStatus)(x.ContainerStatuses), e)
@@ -29287,15 +29314,15 @@ func (x *PodStatus) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeNil()
}
} else {
- if yyq2167[7] {
+ if yyq2169[7] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("containerStatuses"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
if x.ContainerStatuses == nil {
r.EncodeNil()
} else {
- yym2189 := z.EncBinary()
- _ = yym2189
+ yym2191 := z.EncBinary()
+ _ = yym2191
if false {
} else {
h.encSliceContainerStatus(([]ContainerStatus)(x.ContainerStatuses), e)
@@ -29303,7 +29330,22 @@ func (x *PodStatus) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
- if yyr2167 || yy2arr2167 {
+ if yyr2169 || yy2arr2169 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2169[8] {
+ x.QOSClass.CodecEncodeSelf(e)
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2169[8] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("qosClass"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ x.QOSClass.CodecEncodeSelf(e)
+ }
+ }
+ if yyr2169 || yy2arr2169 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -29316,25 +29358,25 @@ func (x *PodStatus) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym2190 := z.DecBinary()
- _ = yym2190
+ yym2193 := z.DecBinary()
+ _ = yym2193
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct2191 := r.ContainerType()
- if yyct2191 == codecSelferValueTypeMap1234 {
- yyl2191 := r.ReadMapStart()
- if yyl2191 == 0 {
+ yyct2194 := r.ContainerType()
+ if yyct2194 == codecSelferValueTypeMap1234 {
+ yyl2194 := r.ReadMapStart()
+ if yyl2194 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl2191, d)
+ x.codecDecodeSelfFromMap(yyl2194, d)
}
- } else if yyct2191 == codecSelferValueTypeArray1234 {
- yyl2191 := r.ReadArrayStart()
- if yyl2191 == 0 {
+ } else if yyct2194 == codecSelferValueTypeArray1234 {
+ yyl2194 := r.ReadArrayStart()
+ if yyl2194 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl2191, d)
+ x.codecDecodeSelfFromArray(yyl2194, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -29346,12 +29388,12 @@ func (x *PodStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys2192Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys2192Slc
- var yyhl2192 bool = l >= 0
- for yyj2192 := 0; ; yyj2192++ {
- if yyhl2192 {
- if yyj2192 >= l {
+ var yys2195Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys2195Slc
+ var yyhl2195 bool = l >= 0
+ for yyj2195 := 0; ; yyj2195++ {
+ if yyhl2195 {
+ if yyj2195 >= l {
break
}
} else {
@@ -29360,10 +29402,10 @@ func (x *PodStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys2192Slc = r.DecodeBytes(yys2192Slc, true, true)
- yys2192 := string(yys2192Slc)
+ yys2195Slc = r.DecodeBytes(yys2195Slc, true, true)
+ yys2195 := string(yys2195Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys2192 {
+ switch yys2195 {
case "phase":
if r.TryDecodeAsNil() {
x.Phase = ""
@@ -29374,12 +29416,12 @@ func (x *PodStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Conditions = nil
} else {
- yyv2194 := &x.Conditions
- yym2195 := z.DecBinary()
- _ = yym2195
+ yyv2197 := &x.Conditions
+ yym2198 := z.DecBinary()
+ _ = yym2198
if false {
} else {
- h.decSlicePodCondition((*[]PodCondition)(yyv2194), d)
+ h.decSlicePodCondition((*[]PodCondition)(yyv2197), d)
}
}
case "message":
@@ -29415,13 +29457,13 @@ func (x *PodStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
if x.StartTime == nil {
x.StartTime = new(pkg2_v1.Time)
}
- yym2201 := z.DecBinary()
- _ = yym2201
+ yym2204 := z.DecBinary()
+ _ = yym2204
if false {
} else if z.HasExtensions() && z.DecExt(x.StartTime) {
- } else if yym2201 {
+ } else if yym2204 {
z.DecBinaryUnmarshal(x.StartTime)
- } else if !yym2201 && z.IsJSONHandle() {
+ } else if !yym2204 && z.IsJSONHandle() {
z.DecJSONUnmarshal(x.StartTime)
} else {
z.DecFallback(x.StartTime, false)
@@ -29431,18 +29473,24 @@ func (x *PodStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.ContainerStatuses = nil
} else {
- yyv2202 := &x.ContainerStatuses
- yym2203 := z.DecBinary()
- _ = yym2203
+ yyv2205 := &x.ContainerStatuses
+ yym2206 := z.DecBinary()
+ _ = yym2206
if false {
} else {
- h.decSliceContainerStatus((*[]ContainerStatus)(yyv2202), d)
+ h.decSliceContainerStatus((*[]ContainerStatus)(yyv2205), d)
}
}
+ case "qosClass":
+ if r.TryDecodeAsNil() {
+ x.QOSClass = ""
+ } else {
+ x.QOSClass = PodQOSClass(r.DecodeString())
+ }
default:
- z.DecStructFieldNotFound(-1, yys2192)
- } // end switch yys2192
- } // end for yyj2192
+ z.DecStructFieldNotFound(-1, yys2195)
+ } // end switch yys2195
+ } // end for yyj2195
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -29450,16 +29498,16 @@ func (x *PodStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj2204 int
- var yyb2204 bool
- var yyhl2204 bool = l >= 0
- yyj2204++
- if yyhl2204 {
- yyb2204 = yyj2204 > l
+ var yyj2208 int
+ var yyb2208 bool
+ var yyhl2208 bool = l >= 0
+ yyj2208++
+ if yyhl2208 {
+ yyb2208 = yyj2208 > l
} else {
- yyb2204 = r.CheckBreak()
+ yyb2208 = r.CheckBreak()
}
- if yyb2204 {
+ if yyb2208 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -29469,13 +29517,13 @@ func (x *PodStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Phase = PodPhase(r.DecodeString())
}
- yyj2204++
- if yyhl2204 {
- yyb2204 = yyj2204 > l
+ yyj2208++
+ if yyhl2208 {
+ yyb2208 = yyj2208 > l
} else {
- yyb2204 = r.CheckBreak()
+ yyb2208 = r.CheckBreak()
}
- if yyb2204 {
+ if yyb2208 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -29483,21 +29531,21 @@ func (x *PodStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Conditions = nil
} else {
- yyv2206 := &x.Conditions
- yym2207 := z.DecBinary()
- _ = yym2207
+ yyv2210 := &x.Conditions
+ yym2211 := z.DecBinary()
+ _ = yym2211
if false {
} else {
- h.decSlicePodCondition((*[]PodCondition)(yyv2206), d)
+ h.decSlicePodCondition((*[]PodCondition)(yyv2210), d)
}
}
- yyj2204++
- if yyhl2204 {
- yyb2204 = yyj2204 > l
+ yyj2208++
+ if yyhl2208 {
+ yyb2208 = yyj2208 > l
} else {
- yyb2204 = r.CheckBreak()
+ yyb2208 = r.CheckBreak()
}
- if yyb2204 {
+ if yyb2208 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -29507,13 +29555,13 @@ func (x *PodStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Message = string(r.DecodeString())
}
- yyj2204++
- if yyhl2204 {
- yyb2204 = yyj2204 > l
+ yyj2208++
+ if yyhl2208 {
+ yyb2208 = yyj2208 > l
} else {
- yyb2204 = r.CheckBreak()
+ yyb2208 = r.CheckBreak()
}
- if yyb2204 {
+ if yyb2208 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -29523,13 +29571,13 @@ func (x *PodStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Reason = string(r.DecodeString())
}
- yyj2204++
- if yyhl2204 {
- yyb2204 = yyj2204 > l
+ yyj2208++
+ if yyhl2208 {
+ yyb2208 = yyj2208 > l
} else {
- yyb2204 = r.CheckBreak()
+ yyb2208 = r.CheckBreak()
}
- if yyb2204 {
+ if yyb2208 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -29539,13 +29587,13 @@ func (x *PodStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.HostIP = string(r.DecodeString())
}
- yyj2204++
- if yyhl2204 {
- yyb2204 = yyj2204 > l
+ yyj2208++
+ if yyhl2208 {
+ yyb2208 = yyj2208 > l
} else {
- yyb2204 = r.CheckBreak()
+ yyb2208 = r.CheckBreak()
}
- if yyb2204 {
+ if yyb2208 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -29555,13 +29603,13 @@ func (x *PodStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.PodIP = string(r.DecodeString())
}
- yyj2204++
- if yyhl2204 {
- yyb2204 = yyj2204 > l
+ yyj2208++
+ if yyhl2208 {
+ yyb2208 = yyj2208 > l
} else {
- yyb2204 = r.CheckBreak()
+ yyb2208 = r.CheckBreak()
}
- if yyb2204 {
+ if yyb2208 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -29574,25 +29622,25 @@ func (x *PodStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if x.StartTime == nil {
x.StartTime = new(pkg2_v1.Time)
}
- yym2213 := z.DecBinary()
- _ = yym2213
+ yym2217 := z.DecBinary()
+ _ = yym2217
if false {
} else if z.HasExtensions() && z.DecExt(x.StartTime) {
- } else if yym2213 {
+ } else if yym2217 {
z.DecBinaryUnmarshal(x.StartTime)
- } else if !yym2213 && z.IsJSONHandle() {
+ } else if !yym2217 && z.IsJSONHandle() {
z.DecJSONUnmarshal(x.StartTime)
} else {
z.DecFallback(x.StartTime, false)
}
}
- yyj2204++
- if yyhl2204 {
- yyb2204 = yyj2204 > l
+ yyj2208++
+ if yyhl2208 {
+ yyb2208 = yyj2208 > l
} else {
- yyb2204 = r.CheckBreak()
+ yyb2208 = r.CheckBreak()
}
- if yyb2204 {
+ if yyb2208 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -29600,26 +29648,42 @@ func (x *PodStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.ContainerStatuses = nil
} else {
- yyv2214 := &x.ContainerStatuses
- yym2215 := z.DecBinary()
- _ = yym2215
+ yyv2218 := &x.ContainerStatuses
+ yym2219 := z.DecBinary()
+ _ = yym2219
if false {
} else {
- h.decSliceContainerStatus((*[]ContainerStatus)(yyv2214), d)
+ h.decSliceContainerStatus((*[]ContainerStatus)(yyv2218), d)
}
}
+ yyj2208++
+ if yyhl2208 {
+ yyb2208 = yyj2208 > l
+ } else {
+ yyb2208 = r.CheckBreak()
+ }
+ if yyb2208 {
+ z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
+ return
+ }
+ z.DecSendContainerState(codecSelfer_containerArrayElem1234)
+ if r.TryDecodeAsNil() {
+ x.QOSClass = ""
+ } else {
+ x.QOSClass = PodQOSClass(r.DecodeString())
+ }
for {
- yyj2204++
- if yyhl2204 {
- yyb2204 = yyj2204 > l
+ yyj2208++
+ if yyhl2208 {
+ yyb2208 = yyj2208 > l
} else {
- yyb2204 = r.CheckBreak()
+ yyb2208 = r.CheckBreak()
}
- if yyb2204 {
+ if yyb2208 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj2204-1, "")
+ z.DecStructFieldNotFound(yyj2208-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -29631,38 +29695,38 @@ func (x *PodStatusResult) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym2216 := z.EncBinary()
- _ = yym2216
+ yym2221 := z.EncBinary()
+ _ = yym2221
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep2217 := !z.EncBinary()
- yy2arr2217 := z.EncBasicHandle().StructToArray
- var yyq2217 [4]bool
- _, _, _ = yysep2217, yyq2217, yy2arr2217
- const yyr2217 bool = false
- yyq2217[0] = x.Kind != ""
- yyq2217[1] = x.APIVersion != ""
- yyq2217[2] = true
- yyq2217[3] = true
- var yynn2217 int
- if yyr2217 || yy2arr2217 {
+ yysep2222 := !z.EncBinary()
+ yy2arr2222 := z.EncBasicHandle().StructToArray
+ var yyq2222 [4]bool
+ _, _, _ = yysep2222, yyq2222, yy2arr2222
+ const yyr2222 bool = false
+ yyq2222[0] = x.Kind != ""
+ yyq2222[1] = x.APIVersion != ""
+ yyq2222[2] = true
+ yyq2222[3] = true
+ var yynn2222 int
+ if yyr2222 || yy2arr2222 {
r.EncodeArrayStart(4)
} else {
- yynn2217 = 0
- for _, b := range yyq2217 {
+ yynn2222 = 0
+ for _, b := range yyq2222 {
if b {
- yynn2217++
+ yynn2222++
}
}
- r.EncodeMapStart(yynn2217)
- yynn2217 = 0
+ r.EncodeMapStart(yynn2222)
+ yynn2222 = 0
}
- if yyr2217 || yy2arr2217 {
+ if yyr2222 || yy2arr2222 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2217[0] {
- yym2219 := z.EncBinary()
- _ = yym2219
+ if yyq2222[0] {
+ yym2224 := z.EncBinary()
+ _ = yym2224
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
@@ -29671,23 +29735,23 @@ func (x *PodStatusResult) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2217[0] {
+ if yyq2222[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("kind"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym2220 := z.EncBinary()
- _ = yym2220
+ yym2225 := z.EncBinary()
+ _ = yym2225
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
}
}
}
- if yyr2217 || yy2arr2217 {
+ if yyr2222 || yy2arr2222 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2217[1] {
- yym2222 := z.EncBinary()
- _ = yym2222
+ if yyq2222[1] {
+ yym2227 := z.EncBinary()
+ _ = yym2227
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
@@ -29696,53 +29760,53 @@ func (x *PodStatusResult) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2217[1] {
+ if yyq2222[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym2223 := z.EncBinary()
- _ = yym2223
+ yym2228 := z.EncBinary()
+ _ = yym2228
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
}
}
}
- if yyr2217 || yy2arr2217 {
+ if yyr2222 || yy2arr2222 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2217[2] {
- yy2225 := &x.ObjectMeta
- yy2225.CodecEncodeSelf(e)
+ if yyq2222[2] {
+ yy2230 := &x.ObjectMeta
+ yy2230.CodecEncodeSelf(e)
} else {
r.EncodeNil()
}
} else {
- if yyq2217[2] {
+ if yyq2222[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("metadata"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy2226 := &x.ObjectMeta
- yy2226.CodecEncodeSelf(e)
+ yy2231 := &x.ObjectMeta
+ yy2231.CodecEncodeSelf(e)
}
}
- if yyr2217 || yy2arr2217 {
+ if yyr2222 || yy2arr2222 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2217[3] {
- yy2228 := &x.Status
- yy2228.CodecEncodeSelf(e)
+ if yyq2222[3] {
+ yy2233 := &x.Status
+ yy2233.CodecEncodeSelf(e)
} else {
r.EncodeNil()
}
} else {
- if yyq2217[3] {
+ if yyq2222[3] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("status"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy2229 := &x.Status
- yy2229.CodecEncodeSelf(e)
+ yy2234 := &x.Status
+ yy2234.CodecEncodeSelf(e)
}
}
- if yyr2217 || yy2arr2217 {
+ if yyr2222 || yy2arr2222 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -29755,25 +29819,25 @@ func (x *PodStatusResult) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym2230 := z.DecBinary()
- _ = yym2230
+ yym2235 := z.DecBinary()
+ _ = yym2235
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct2231 := r.ContainerType()
- if yyct2231 == codecSelferValueTypeMap1234 {
- yyl2231 := r.ReadMapStart()
- if yyl2231 == 0 {
+ yyct2236 := r.ContainerType()
+ if yyct2236 == codecSelferValueTypeMap1234 {
+ yyl2236 := r.ReadMapStart()
+ if yyl2236 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl2231, d)
+ x.codecDecodeSelfFromMap(yyl2236, d)
}
- } else if yyct2231 == codecSelferValueTypeArray1234 {
- yyl2231 := r.ReadArrayStart()
- if yyl2231 == 0 {
+ } else if yyct2236 == codecSelferValueTypeArray1234 {
+ yyl2236 := r.ReadArrayStart()
+ if yyl2236 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl2231, d)
+ x.codecDecodeSelfFromArray(yyl2236, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -29785,12 +29849,12 @@ func (x *PodStatusResult) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys2232Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys2232Slc
- var yyhl2232 bool = l >= 0
- for yyj2232 := 0; ; yyj2232++ {
- if yyhl2232 {
- if yyj2232 >= l {
+ var yys2237Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys2237Slc
+ var yyhl2237 bool = l >= 0
+ for yyj2237 := 0; ; yyj2237++ {
+ if yyhl2237 {
+ if yyj2237 >= l {
break
}
} else {
@@ -29799,10 +29863,10 @@ func (x *PodStatusResult) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys2232Slc = r.DecodeBytes(yys2232Slc, true, true)
- yys2232 := string(yys2232Slc)
+ yys2237Slc = r.DecodeBytes(yys2237Slc, true, true)
+ yys2237 := string(yys2237Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys2232 {
+ switch yys2237 {
case "kind":
if r.TryDecodeAsNil() {
x.Kind = ""
@@ -29819,20 +29883,20 @@ func (x *PodStatusResult) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.ObjectMeta = ObjectMeta{}
} else {
- yyv2235 := &x.ObjectMeta
- yyv2235.CodecDecodeSelf(d)
+ yyv2240 := &x.ObjectMeta
+ yyv2240.CodecDecodeSelf(d)
}
case "status":
if r.TryDecodeAsNil() {
x.Status = PodStatus{}
} else {
- yyv2236 := &x.Status
- yyv2236.CodecDecodeSelf(d)
+ yyv2241 := &x.Status
+ yyv2241.CodecDecodeSelf(d)
}
default:
- z.DecStructFieldNotFound(-1, yys2232)
- } // end switch yys2232
- } // end for yyj2232
+ z.DecStructFieldNotFound(-1, yys2237)
+ } // end switch yys2237
+ } // end for yyj2237
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -29840,16 +29904,16 @@ func (x *PodStatusResult) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj2237 int
- var yyb2237 bool
- var yyhl2237 bool = l >= 0
- yyj2237++
- if yyhl2237 {
- yyb2237 = yyj2237 > l
+ var yyj2242 int
+ var yyb2242 bool
+ var yyhl2242 bool = l >= 0
+ yyj2242++
+ if yyhl2242 {
+ yyb2242 = yyj2242 > l
} else {
- yyb2237 = r.CheckBreak()
+ yyb2242 = r.CheckBreak()
}
- if yyb2237 {
+ if yyb2242 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -29859,13 +29923,13 @@ func (x *PodStatusResult) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
} else {
x.Kind = string(r.DecodeString())
}
- yyj2237++
- if yyhl2237 {
- yyb2237 = yyj2237 > l
+ yyj2242++
+ if yyhl2242 {
+ yyb2242 = yyj2242 > l
} else {
- yyb2237 = r.CheckBreak()
+ yyb2242 = r.CheckBreak()
}
- if yyb2237 {
+ if yyb2242 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -29875,13 +29939,13 @@ func (x *PodStatusResult) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
} else {
x.APIVersion = string(r.DecodeString())
}
- yyj2237++
- if yyhl2237 {
- yyb2237 = yyj2237 > l
+ yyj2242++
+ if yyhl2242 {
+ yyb2242 = yyj2242 > l
} else {
- yyb2237 = r.CheckBreak()
+ yyb2242 = r.CheckBreak()
}
- if yyb2237 {
+ if yyb2242 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -29889,16 +29953,16 @@ func (x *PodStatusResult) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
if r.TryDecodeAsNil() {
x.ObjectMeta = ObjectMeta{}
} else {
- yyv2240 := &x.ObjectMeta
- yyv2240.CodecDecodeSelf(d)
+ yyv2245 := &x.ObjectMeta
+ yyv2245.CodecDecodeSelf(d)
}
- yyj2237++
- if yyhl2237 {
- yyb2237 = yyj2237 > l
+ yyj2242++
+ if yyhl2242 {
+ yyb2242 = yyj2242 > l
} else {
- yyb2237 = r.CheckBreak()
+ yyb2242 = r.CheckBreak()
}
- if yyb2237 {
+ if yyb2242 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -29906,21 +29970,21 @@ func (x *PodStatusResult) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
if r.TryDecodeAsNil() {
x.Status = PodStatus{}
} else {
- yyv2241 := &x.Status
- yyv2241.CodecDecodeSelf(d)
+ yyv2246 := &x.Status
+ yyv2246.CodecDecodeSelf(d)
}
for {
- yyj2237++
- if yyhl2237 {
- yyb2237 = yyj2237 > l
+ yyj2242++
+ if yyhl2242 {
+ yyb2242 = yyj2242 > l
} else {
- yyb2237 = r.CheckBreak()
+ yyb2242 = r.CheckBreak()
}
- if yyb2237 {
+ if yyb2242 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj2237-1, "")
+ z.DecStructFieldNotFound(yyj2242-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -29932,39 +29996,39 @@ func (x *Pod) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym2242 := z.EncBinary()
- _ = yym2242
+ yym2247 := z.EncBinary()
+ _ = yym2247
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep2243 := !z.EncBinary()
- yy2arr2243 := z.EncBasicHandle().StructToArray
- var yyq2243 [5]bool
- _, _, _ = yysep2243, yyq2243, yy2arr2243
- const yyr2243 bool = false
- yyq2243[0] = x.Kind != ""
- yyq2243[1] = x.APIVersion != ""
- yyq2243[2] = true
- yyq2243[3] = true
- yyq2243[4] = true
- var yynn2243 int
- if yyr2243 || yy2arr2243 {
+ yysep2248 := !z.EncBinary()
+ yy2arr2248 := z.EncBasicHandle().StructToArray
+ var yyq2248 [5]bool
+ _, _, _ = yysep2248, yyq2248, yy2arr2248
+ const yyr2248 bool = false
+ yyq2248[0] = x.Kind != ""
+ yyq2248[1] = x.APIVersion != ""
+ yyq2248[2] = true
+ yyq2248[3] = true
+ yyq2248[4] = true
+ var yynn2248 int
+ if yyr2248 || yy2arr2248 {
r.EncodeArrayStart(5)
} else {
- yynn2243 = 0
- for _, b := range yyq2243 {
+ yynn2248 = 0
+ for _, b := range yyq2248 {
if b {
- yynn2243++
+ yynn2248++
}
}
- r.EncodeMapStart(yynn2243)
- yynn2243 = 0
+ r.EncodeMapStart(yynn2248)
+ yynn2248 = 0
}
- if yyr2243 || yy2arr2243 {
+ if yyr2248 || yy2arr2248 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2243[0] {
- yym2245 := z.EncBinary()
- _ = yym2245
+ if yyq2248[0] {
+ yym2250 := z.EncBinary()
+ _ = yym2250
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
@@ -29973,23 +30037,23 @@ func (x *Pod) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2243[0] {
+ if yyq2248[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("kind"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym2246 := z.EncBinary()
- _ = yym2246
+ yym2251 := z.EncBinary()
+ _ = yym2251
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
}
}
}
- if yyr2243 || yy2arr2243 {
+ if yyr2248 || yy2arr2248 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2243[1] {
- yym2248 := z.EncBinary()
- _ = yym2248
+ if yyq2248[1] {
+ yym2253 := z.EncBinary()
+ _ = yym2253
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
@@ -29998,70 +30062,70 @@ func (x *Pod) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2243[1] {
+ if yyq2248[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym2249 := z.EncBinary()
- _ = yym2249
+ yym2254 := z.EncBinary()
+ _ = yym2254
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
}
}
}
- if yyr2243 || yy2arr2243 {
+ if yyr2248 || yy2arr2248 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2243[2] {
- yy2251 := &x.ObjectMeta
- yy2251.CodecEncodeSelf(e)
+ if yyq2248[2] {
+ yy2256 := &x.ObjectMeta
+ yy2256.CodecEncodeSelf(e)
} else {
r.EncodeNil()
}
} else {
- if yyq2243[2] {
+ if yyq2248[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("metadata"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy2252 := &x.ObjectMeta
- yy2252.CodecEncodeSelf(e)
+ yy2257 := &x.ObjectMeta
+ yy2257.CodecEncodeSelf(e)
}
}
- if yyr2243 || yy2arr2243 {
+ if yyr2248 || yy2arr2248 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2243[3] {
- yy2254 := &x.Spec
- yy2254.CodecEncodeSelf(e)
+ if yyq2248[3] {
+ yy2259 := &x.Spec
+ yy2259.CodecEncodeSelf(e)
} else {
r.EncodeNil()
}
} else {
- if yyq2243[3] {
+ if yyq2248[3] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("spec"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy2255 := &x.Spec
- yy2255.CodecEncodeSelf(e)
+ yy2260 := &x.Spec
+ yy2260.CodecEncodeSelf(e)
}
}
- if yyr2243 || yy2arr2243 {
+ if yyr2248 || yy2arr2248 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2243[4] {
- yy2257 := &x.Status
- yy2257.CodecEncodeSelf(e)
+ if yyq2248[4] {
+ yy2262 := &x.Status
+ yy2262.CodecEncodeSelf(e)
} else {
r.EncodeNil()
}
} else {
- if yyq2243[4] {
+ if yyq2248[4] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("status"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy2258 := &x.Status
- yy2258.CodecEncodeSelf(e)
+ yy2263 := &x.Status
+ yy2263.CodecEncodeSelf(e)
}
}
- if yyr2243 || yy2arr2243 {
+ if yyr2248 || yy2arr2248 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -30074,25 +30138,25 @@ func (x *Pod) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym2259 := z.DecBinary()
- _ = yym2259
+ yym2264 := z.DecBinary()
+ _ = yym2264
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct2260 := r.ContainerType()
- if yyct2260 == codecSelferValueTypeMap1234 {
- yyl2260 := r.ReadMapStart()
- if yyl2260 == 0 {
+ yyct2265 := r.ContainerType()
+ if yyct2265 == codecSelferValueTypeMap1234 {
+ yyl2265 := r.ReadMapStart()
+ if yyl2265 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl2260, d)
+ x.codecDecodeSelfFromMap(yyl2265, d)
}
- } else if yyct2260 == codecSelferValueTypeArray1234 {
- yyl2260 := r.ReadArrayStart()
- if yyl2260 == 0 {
+ } else if yyct2265 == codecSelferValueTypeArray1234 {
+ yyl2265 := r.ReadArrayStart()
+ if yyl2265 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl2260, d)
+ x.codecDecodeSelfFromArray(yyl2265, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -30104,12 +30168,12 @@ func (x *Pod) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys2261Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys2261Slc
- var yyhl2261 bool = l >= 0
- for yyj2261 := 0; ; yyj2261++ {
- if yyhl2261 {
- if yyj2261 >= l {
+ var yys2266Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys2266Slc
+ var yyhl2266 bool = l >= 0
+ for yyj2266 := 0; ; yyj2266++ {
+ if yyhl2266 {
+ if yyj2266 >= l {
break
}
} else {
@@ -30118,10 +30182,10 @@ func (x *Pod) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys2261Slc = r.DecodeBytes(yys2261Slc, true, true)
- yys2261 := string(yys2261Slc)
+ yys2266Slc = r.DecodeBytes(yys2266Slc, true, true)
+ yys2266 := string(yys2266Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys2261 {
+ switch yys2266 {
case "kind":
if r.TryDecodeAsNil() {
x.Kind = ""
@@ -30138,27 +30202,27 @@ func (x *Pod) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.ObjectMeta = ObjectMeta{}
} else {
- yyv2264 := &x.ObjectMeta
- yyv2264.CodecDecodeSelf(d)
+ yyv2269 := &x.ObjectMeta
+ yyv2269.CodecDecodeSelf(d)
}
case "spec":
if r.TryDecodeAsNil() {
x.Spec = PodSpec{}
} else {
- yyv2265 := &x.Spec
- yyv2265.CodecDecodeSelf(d)
+ yyv2270 := &x.Spec
+ yyv2270.CodecDecodeSelf(d)
}
case "status":
if r.TryDecodeAsNil() {
x.Status = PodStatus{}
} else {
- yyv2266 := &x.Status
- yyv2266.CodecDecodeSelf(d)
+ yyv2271 := &x.Status
+ yyv2271.CodecDecodeSelf(d)
}
default:
- z.DecStructFieldNotFound(-1, yys2261)
- } // end switch yys2261
- } // end for yyj2261
+ z.DecStructFieldNotFound(-1, yys2266)
+ } // end switch yys2266
+ } // end for yyj2266
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -30166,16 +30230,16 @@ func (x *Pod) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj2267 int
- var yyb2267 bool
- var yyhl2267 bool = l >= 0
- yyj2267++
- if yyhl2267 {
- yyb2267 = yyj2267 > l
+ var yyj2272 int
+ var yyb2272 bool
+ var yyhl2272 bool = l >= 0
+ yyj2272++
+ if yyhl2272 {
+ yyb2272 = yyj2272 > l
} else {
- yyb2267 = r.CheckBreak()
+ yyb2272 = r.CheckBreak()
}
- if yyb2267 {
+ if yyb2272 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -30185,13 +30249,13 @@ func (x *Pod) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Kind = string(r.DecodeString())
}
- yyj2267++
- if yyhl2267 {
- yyb2267 = yyj2267 > l
+ yyj2272++
+ if yyhl2272 {
+ yyb2272 = yyj2272 > l
} else {
- yyb2267 = r.CheckBreak()
+ yyb2272 = r.CheckBreak()
}
- if yyb2267 {
+ if yyb2272 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -30201,13 +30265,13 @@ func (x *Pod) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.APIVersion = string(r.DecodeString())
}
- yyj2267++
- if yyhl2267 {
- yyb2267 = yyj2267 > l
+ yyj2272++
+ if yyhl2272 {
+ yyb2272 = yyj2272 > l
} else {
- yyb2267 = r.CheckBreak()
+ yyb2272 = r.CheckBreak()
}
- if yyb2267 {
+ if yyb2272 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -30215,16 +30279,16 @@ func (x *Pod) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.ObjectMeta = ObjectMeta{}
} else {
- yyv2270 := &x.ObjectMeta
- yyv2270.CodecDecodeSelf(d)
+ yyv2275 := &x.ObjectMeta
+ yyv2275.CodecDecodeSelf(d)
}
- yyj2267++
- if yyhl2267 {
- yyb2267 = yyj2267 > l
+ yyj2272++
+ if yyhl2272 {
+ yyb2272 = yyj2272 > l
} else {
- yyb2267 = r.CheckBreak()
+ yyb2272 = r.CheckBreak()
}
- if yyb2267 {
+ if yyb2272 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -30232,16 +30296,16 @@ func (x *Pod) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Spec = PodSpec{}
} else {
- yyv2271 := &x.Spec
- yyv2271.CodecDecodeSelf(d)
+ yyv2276 := &x.Spec
+ yyv2276.CodecDecodeSelf(d)
}
- yyj2267++
- if yyhl2267 {
- yyb2267 = yyj2267 > l
+ yyj2272++
+ if yyhl2272 {
+ yyb2272 = yyj2272 > l
} else {
- yyb2267 = r.CheckBreak()
+ yyb2272 = r.CheckBreak()
}
- if yyb2267 {
+ if yyb2272 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -30249,21 +30313,21 @@ func (x *Pod) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Status = PodStatus{}
} else {
- yyv2272 := &x.Status
- yyv2272.CodecDecodeSelf(d)
+ yyv2277 := &x.Status
+ yyv2277.CodecDecodeSelf(d)
}
for {
- yyj2267++
- if yyhl2267 {
- yyb2267 = yyj2267 > l
+ yyj2272++
+ if yyhl2272 {
+ yyb2272 = yyj2272 > l
} else {
- yyb2267 = r.CheckBreak()
+ yyb2272 = r.CheckBreak()
}
- if yyb2267 {
+ if yyb2272 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj2267-1, "")
+ z.DecStructFieldNotFound(yyj2272-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -30275,37 +30339,37 @@ func (x *PodList) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym2273 := z.EncBinary()
- _ = yym2273
+ yym2278 := z.EncBinary()
+ _ = yym2278
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep2274 := !z.EncBinary()
- yy2arr2274 := z.EncBasicHandle().StructToArray
- var yyq2274 [4]bool
- _, _, _ = yysep2274, yyq2274, yy2arr2274
- const yyr2274 bool = false
- yyq2274[0] = x.Kind != ""
- yyq2274[1] = x.APIVersion != ""
- yyq2274[2] = true
- var yynn2274 int
- if yyr2274 || yy2arr2274 {
+ yysep2279 := !z.EncBinary()
+ yy2arr2279 := z.EncBasicHandle().StructToArray
+ var yyq2279 [4]bool
+ _, _, _ = yysep2279, yyq2279, yy2arr2279
+ const yyr2279 bool = false
+ yyq2279[0] = x.Kind != ""
+ yyq2279[1] = x.APIVersion != ""
+ yyq2279[2] = true
+ var yynn2279 int
+ if yyr2279 || yy2arr2279 {
r.EncodeArrayStart(4)
} else {
- yynn2274 = 1
- for _, b := range yyq2274 {
+ yynn2279 = 1
+ for _, b := range yyq2279 {
if b {
- yynn2274++
+ yynn2279++
}
}
- r.EncodeMapStart(yynn2274)
- yynn2274 = 0
+ r.EncodeMapStart(yynn2279)
+ yynn2279 = 0
}
- if yyr2274 || yy2arr2274 {
+ if yyr2279 || yy2arr2279 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2274[0] {
- yym2276 := z.EncBinary()
- _ = yym2276
+ if yyq2279[0] {
+ yym2281 := z.EncBinary()
+ _ = yym2281
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
@@ -30314,23 +30378,23 @@ func (x *PodList) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2274[0] {
+ if yyq2279[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("kind"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym2277 := z.EncBinary()
- _ = yym2277
+ yym2282 := z.EncBinary()
+ _ = yym2282
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
}
}
}
- if yyr2274 || yy2arr2274 {
+ if yyr2279 || yy2arr2279 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2274[1] {
- yym2279 := z.EncBinary()
- _ = yym2279
+ if yyq2279[1] {
+ yym2284 := z.EncBinary()
+ _ = yym2284
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
@@ -30339,54 +30403,54 @@ func (x *PodList) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2274[1] {
+ if yyq2279[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym2280 := z.EncBinary()
- _ = yym2280
+ yym2285 := z.EncBinary()
+ _ = yym2285
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
}
}
}
- if yyr2274 || yy2arr2274 {
+ if yyr2279 || yy2arr2279 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2274[2] {
- yy2282 := &x.ListMeta
- yym2283 := z.EncBinary()
- _ = yym2283
+ if yyq2279[2] {
+ yy2287 := &x.ListMeta
+ yym2288 := z.EncBinary()
+ _ = yym2288
if false {
- } else if z.HasExtensions() && z.EncExt(yy2282) {
+ } else if z.HasExtensions() && z.EncExt(yy2287) {
} else {
- z.EncFallback(yy2282)
+ z.EncFallback(yy2287)
}
} else {
r.EncodeNil()
}
} else {
- if yyq2274[2] {
+ if yyq2279[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("metadata"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy2284 := &x.ListMeta
- yym2285 := z.EncBinary()
- _ = yym2285
+ yy2289 := &x.ListMeta
+ yym2290 := z.EncBinary()
+ _ = yym2290
if false {
- } else if z.HasExtensions() && z.EncExt(yy2284) {
+ } else if z.HasExtensions() && z.EncExt(yy2289) {
} else {
- z.EncFallback(yy2284)
+ z.EncFallback(yy2289)
}
}
}
- if yyr2274 || yy2arr2274 {
+ if yyr2279 || yy2arr2279 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if x.Items == nil {
r.EncodeNil()
} else {
- yym2287 := z.EncBinary()
- _ = yym2287
+ yym2292 := z.EncBinary()
+ _ = yym2292
if false {
} else {
h.encSlicePod(([]Pod)(x.Items), e)
@@ -30399,15 +30463,15 @@ func (x *PodList) CodecEncodeSelf(e *codec1978.Encoder) {
if x.Items == nil {
r.EncodeNil()
} else {
- yym2288 := z.EncBinary()
- _ = yym2288
+ yym2293 := z.EncBinary()
+ _ = yym2293
if false {
} else {
h.encSlicePod(([]Pod)(x.Items), e)
}
}
}
- if yyr2274 || yy2arr2274 {
+ if yyr2279 || yy2arr2279 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -30420,25 +30484,25 @@ func (x *PodList) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym2289 := z.DecBinary()
- _ = yym2289
+ yym2294 := z.DecBinary()
+ _ = yym2294
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct2290 := r.ContainerType()
- if yyct2290 == codecSelferValueTypeMap1234 {
- yyl2290 := r.ReadMapStart()
- if yyl2290 == 0 {
+ yyct2295 := r.ContainerType()
+ if yyct2295 == codecSelferValueTypeMap1234 {
+ yyl2295 := r.ReadMapStart()
+ if yyl2295 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl2290, d)
+ x.codecDecodeSelfFromMap(yyl2295, d)
}
- } else if yyct2290 == codecSelferValueTypeArray1234 {
- yyl2290 := r.ReadArrayStart()
- if yyl2290 == 0 {
+ } else if yyct2295 == codecSelferValueTypeArray1234 {
+ yyl2295 := r.ReadArrayStart()
+ if yyl2295 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl2290, d)
+ x.codecDecodeSelfFromArray(yyl2295, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -30450,12 +30514,12 @@ func (x *PodList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys2291Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys2291Slc
- var yyhl2291 bool = l >= 0
- for yyj2291 := 0; ; yyj2291++ {
- if yyhl2291 {
- if yyj2291 >= l {
+ var yys2296Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys2296Slc
+ var yyhl2296 bool = l >= 0
+ for yyj2296 := 0; ; yyj2296++ {
+ if yyhl2296 {
+ if yyj2296 >= l {
break
}
} else {
@@ -30464,10 +30528,10 @@ func (x *PodList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys2291Slc = r.DecodeBytes(yys2291Slc, true, true)
- yys2291 := string(yys2291Slc)
+ yys2296Slc = r.DecodeBytes(yys2296Slc, true, true)
+ yys2296 := string(yys2296Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys2291 {
+ switch yys2296 {
case "kind":
if r.TryDecodeAsNil() {
x.Kind = ""
@@ -30484,31 +30548,31 @@ func (x *PodList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.ListMeta = pkg2_v1.ListMeta{}
} else {
- yyv2294 := &x.ListMeta
- yym2295 := z.DecBinary()
- _ = yym2295
+ yyv2299 := &x.ListMeta
+ yym2300 := z.DecBinary()
+ _ = yym2300
if false {
- } else if z.HasExtensions() && z.DecExt(yyv2294) {
+ } else if z.HasExtensions() && z.DecExt(yyv2299) {
} else {
- z.DecFallback(yyv2294, false)
+ z.DecFallback(yyv2299, false)
}
}
case "items":
if r.TryDecodeAsNil() {
x.Items = nil
} else {
- yyv2296 := &x.Items
- yym2297 := z.DecBinary()
- _ = yym2297
+ yyv2301 := &x.Items
+ yym2302 := z.DecBinary()
+ _ = yym2302
if false {
} else {
- h.decSlicePod((*[]Pod)(yyv2296), d)
+ h.decSlicePod((*[]Pod)(yyv2301), d)
}
}
default:
- z.DecStructFieldNotFound(-1, yys2291)
- } // end switch yys2291
- } // end for yyj2291
+ z.DecStructFieldNotFound(-1, yys2296)
+ } // end switch yys2296
+ } // end for yyj2296
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -30516,16 +30580,16 @@ func (x *PodList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj2298 int
- var yyb2298 bool
- var yyhl2298 bool = l >= 0
- yyj2298++
- if yyhl2298 {
- yyb2298 = yyj2298 > l
+ var yyj2303 int
+ var yyb2303 bool
+ var yyhl2303 bool = l >= 0
+ yyj2303++
+ if yyhl2303 {
+ yyb2303 = yyj2303 > l
} else {
- yyb2298 = r.CheckBreak()
+ yyb2303 = r.CheckBreak()
}
- if yyb2298 {
+ if yyb2303 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -30535,13 +30599,13 @@ func (x *PodList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Kind = string(r.DecodeString())
}
- yyj2298++
- if yyhl2298 {
- yyb2298 = yyj2298 > l
+ yyj2303++
+ if yyhl2303 {
+ yyb2303 = yyj2303 > l
} else {
- yyb2298 = r.CheckBreak()
+ yyb2303 = r.CheckBreak()
}
- if yyb2298 {
+ if yyb2303 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -30551,13 +30615,13 @@ func (x *PodList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.APIVersion = string(r.DecodeString())
}
- yyj2298++
- if yyhl2298 {
- yyb2298 = yyj2298 > l
+ yyj2303++
+ if yyhl2303 {
+ yyb2303 = yyj2303 > l
} else {
- yyb2298 = r.CheckBreak()
+ yyb2303 = r.CheckBreak()
}
- if yyb2298 {
+ if yyb2303 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -30565,22 +30629,22 @@ func (x *PodList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.ListMeta = pkg2_v1.ListMeta{}
} else {
- yyv2301 := &x.ListMeta
- yym2302 := z.DecBinary()
- _ = yym2302
+ yyv2306 := &x.ListMeta
+ yym2307 := z.DecBinary()
+ _ = yym2307
if false {
- } else if z.HasExtensions() && z.DecExt(yyv2301) {
+ } else if z.HasExtensions() && z.DecExt(yyv2306) {
} else {
- z.DecFallback(yyv2301, false)
+ z.DecFallback(yyv2306, false)
}
}
- yyj2298++
- if yyhl2298 {
- yyb2298 = yyj2298 > l
+ yyj2303++
+ if yyhl2303 {
+ yyb2303 = yyj2303 > l
} else {
- yyb2298 = r.CheckBreak()
+ yyb2303 = r.CheckBreak()
}
- if yyb2298 {
+ if yyb2303 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -30588,26 +30652,26 @@ func (x *PodList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Items = nil
} else {
- yyv2303 := &x.Items
- yym2304 := z.DecBinary()
- _ = yym2304
+ yyv2308 := &x.Items
+ yym2309 := z.DecBinary()
+ _ = yym2309
if false {
} else {
- h.decSlicePod((*[]Pod)(yyv2303), d)
+ h.decSlicePod((*[]Pod)(yyv2308), d)
}
}
for {
- yyj2298++
- if yyhl2298 {
- yyb2298 = yyj2298 > l
+ yyj2303++
+ if yyhl2303 {
+ yyb2303 = yyj2303 > l
} else {
- yyb2298 = r.CheckBreak()
+ yyb2303 = r.CheckBreak()
}
- if yyb2298 {
+ if yyb2303 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj2298-1, "")
+ z.DecStructFieldNotFound(yyj2303-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -30619,66 +30683,66 @@ func (x *PodTemplateSpec) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym2305 := z.EncBinary()
- _ = yym2305
+ yym2310 := z.EncBinary()
+ _ = yym2310
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep2306 := !z.EncBinary()
- yy2arr2306 := z.EncBasicHandle().StructToArray
- var yyq2306 [2]bool
- _, _, _ = yysep2306, yyq2306, yy2arr2306
- const yyr2306 bool = false
- yyq2306[0] = true
- yyq2306[1] = true
- var yynn2306 int
- if yyr2306 || yy2arr2306 {
+ yysep2311 := !z.EncBinary()
+ yy2arr2311 := z.EncBasicHandle().StructToArray
+ var yyq2311 [2]bool
+ _, _, _ = yysep2311, yyq2311, yy2arr2311
+ const yyr2311 bool = false
+ yyq2311[0] = true
+ yyq2311[1] = true
+ var yynn2311 int
+ if yyr2311 || yy2arr2311 {
r.EncodeArrayStart(2)
} else {
- yynn2306 = 0
- for _, b := range yyq2306 {
+ yynn2311 = 0
+ for _, b := range yyq2311 {
if b {
- yynn2306++
+ yynn2311++
}
}
- r.EncodeMapStart(yynn2306)
- yynn2306 = 0
+ r.EncodeMapStart(yynn2311)
+ yynn2311 = 0
}
- if yyr2306 || yy2arr2306 {
+ if yyr2311 || yy2arr2311 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2306[0] {
- yy2308 := &x.ObjectMeta
- yy2308.CodecEncodeSelf(e)
+ if yyq2311[0] {
+ yy2313 := &x.ObjectMeta
+ yy2313.CodecEncodeSelf(e)
} else {
r.EncodeNil()
}
} else {
- if yyq2306[0] {
+ if yyq2311[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("metadata"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy2309 := &x.ObjectMeta
- yy2309.CodecEncodeSelf(e)
+ yy2314 := &x.ObjectMeta
+ yy2314.CodecEncodeSelf(e)
}
}
- if yyr2306 || yy2arr2306 {
+ if yyr2311 || yy2arr2311 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2306[1] {
- yy2311 := &x.Spec
- yy2311.CodecEncodeSelf(e)
+ if yyq2311[1] {
+ yy2316 := &x.Spec
+ yy2316.CodecEncodeSelf(e)
} else {
r.EncodeNil()
}
} else {
- if yyq2306[1] {
+ if yyq2311[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("spec"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy2312 := &x.Spec
- yy2312.CodecEncodeSelf(e)
+ yy2317 := &x.Spec
+ yy2317.CodecEncodeSelf(e)
}
}
- if yyr2306 || yy2arr2306 {
+ if yyr2311 || yy2arr2311 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -30691,25 +30755,25 @@ func (x *PodTemplateSpec) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym2313 := z.DecBinary()
- _ = yym2313
+ yym2318 := z.DecBinary()
+ _ = yym2318
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct2314 := r.ContainerType()
- if yyct2314 == codecSelferValueTypeMap1234 {
- yyl2314 := r.ReadMapStart()
- if yyl2314 == 0 {
+ yyct2319 := r.ContainerType()
+ if yyct2319 == codecSelferValueTypeMap1234 {
+ yyl2319 := r.ReadMapStart()
+ if yyl2319 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl2314, d)
+ x.codecDecodeSelfFromMap(yyl2319, d)
}
- } else if yyct2314 == codecSelferValueTypeArray1234 {
- yyl2314 := r.ReadArrayStart()
- if yyl2314 == 0 {
+ } else if yyct2319 == codecSelferValueTypeArray1234 {
+ yyl2319 := r.ReadArrayStart()
+ if yyl2319 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl2314, d)
+ x.codecDecodeSelfFromArray(yyl2319, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -30721,12 +30785,12 @@ func (x *PodTemplateSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys2315Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys2315Slc
- var yyhl2315 bool = l >= 0
- for yyj2315 := 0; ; yyj2315++ {
- if yyhl2315 {
- if yyj2315 >= l {
+ var yys2320Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys2320Slc
+ var yyhl2320 bool = l >= 0
+ for yyj2320 := 0; ; yyj2320++ {
+ if yyhl2320 {
+ if yyj2320 >= l {
break
}
} else {
@@ -30735,28 +30799,28 @@ func (x *PodTemplateSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys2315Slc = r.DecodeBytes(yys2315Slc, true, true)
- yys2315 := string(yys2315Slc)
+ yys2320Slc = r.DecodeBytes(yys2320Slc, true, true)
+ yys2320 := string(yys2320Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys2315 {
+ switch yys2320 {
case "metadata":
if r.TryDecodeAsNil() {
x.ObjectMeta = ObjectMeta{}
} else {
- yyv2316 := &x.ObjectMeta
- yyv2316.CodecDecodeSelf(d)
+ yyv2321 := &x.ObjectMeta
+ yyv2321.CodecDecodeSelf(d)
}
case "spec":
if r.TryDecodeAsNil() {
x.Spec = PodSpec{}
} else {
- yyv2317 := &x.Spec
- yyv2317.CodecDecodeSelf(d)
+ yyv2322 := &x.Spec
+ yyv2322.CodecDecodeSelf(d)
}
default:
- z.DecStructFieldNotFound(-1, yys2315)
- } // end switch yys2315
- } // end for yyj2315
+ z.DecStructFieldNotFound(-1, yys2320)
+ } // end switch yys2320
+ } // end for yyj2320
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -30764,16 +30828,16 @@ func (x *PodTemplateSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj2318 int
- var yyb2318 bool
- var yyhl2318 bool = l >= 0
- yyj2318++
- if yyhl2318 {
- yyb2318 = yyj2318 > l
+ var yyj2323 int
+ var yyb2323 bool
+ var yyhl2323 bool = l >= 0
+ yyj2323++
+ if yyhl2323 {
+ yyb2323 = yyj2323 > l
} else {
- yyb2318 = r.CheckBreak()
+ yyb2323 = r.CheckBreak()
}
- if yyb2318 {
+ if yyb2323 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -30781,16 +30845,16 @@ func (x *PodTemplateSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
if r.TryDecodeAsNil() {
x.ObjectMeta = ObjectMeta{}
} else {
- yyv2319 := &x.ObjectMeta
- yyv2319.CodecDecodeSelf(d)
+ yyv2324 := &x.ObjectMeta
+ yyv2324.CodecDecodeSelf(d)
}
- yyj2318++
- if yyhl2318 {
- yyb2318 = yyj2318 > l
+ yyj2323++
+ if yyhl2323 {
+ yyb2323 = yyj2323 > l
} else {
- yyb2318 = r.CheckBreak()
+ yyb2323 = r.CheckBreak()
}
- if yyb2318 {
+ if yyb2323 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -30798,21 +30862,21 @@ func (x *PodTemplateSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
if r.TryDecodeAsNil() {
x.Spec = PodSpec{}
} else {
- yyv2320 := &x.Spec
- yyv2320.CodecDecodeSelf(d)
+ yyv2325 := &x.Spec
+ yyv2325.CodecDecodeSelf(d)
}
for {
- yyj2318++
- if yyhl2318 {
- yyb2318 = yyj2318 > l
+ yyj2323++
+ if yyhl2323 {
+ yyb2323 = yyj2323 > l
} else {
- yyb2318 = r.CheckBreak()
+ yyb2323 = r.CheckBreak()
}
- if yyb2318 {
+ if yyb2323 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj2318-1, "")
+ z.DecStructFieldNotFound(yyj2323-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -30824,38 +30888,38 @@ func (x *PodTemplate) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym2321 := z.EncBinary()
- _ = yym2321
+ yym2326 := z.EncBinary()
+ _ = yym2326
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep2322 := !z.EncBinary()
- yy2arr2322 := z.EncBasicHandle().StructToArray
- var yyq2322 [4]bool
- _, _, _ = yysep2322, yyq2322, yy2arr2322
- const yyr2322 bool = false
- yyq2322[0] = x.Kind != ""
- yyq2322[1] = x.APIVersion != ""
- yyq2322[2] = true
- yyq2322[3] = true
- var yynn2322 int
- if yyr2322 || yy2arr2322 {
+ yysep2327 := !z.EncBinary()
+ yy2arr2327 := z.EncBasicHandle().StructToArray
+ var yyq2327 [4]bool
+ _, _, _ = yysep2327, yyq2327, yy2arr2327
+ const yyr2327 bool = false
+ yyq2327[0] = x.Kind != ""
+ yyq2327[1] = x.APIVersion != ""
+ yyq2327[2] = true
+ yyq2327[3] = true
+ var yynn2327 int
+ if yyr2327 || yy2arr2327 {
r.EncodeArrayStart(4)
} else {
- yynn2322 = 0
- for _, b := range yyq2322 {
+ yynn2327 = 0
+ for _, b := range yyq2327 {
if b {
- yynn2322++
+ yynn2327++
}
}
- r.EncodeMapStart(yynn2322)
- yynn2322 = 0
+ r.EncodeMapStart(yynn2327)
+ yynn2327 = 0
}
- if yyr2322 || yy2arr2322 {
+ if yyr2327 || yy2arr2327 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2322[0] {
- yym2324 := z.EncBinary()
- _ = yym2324
+ if yyq2327[0] {
+ yym2329 := z.EncBinary()
+ _ = yym2329
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
@@ -30864,23 +30928,23 @@ func (x *PodTemplate) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2322[0] {
+ if yyq2327[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("kind"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym2325 := z.EncBinary()
- _ = yym2325
+ yym2330 := z.EncBinary()
+ _ = yym2330
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
}
}
}
- if yyr2322 || yy2arr2322 {
+ if yyr2327 || yy2arr2327 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2322[1] {
- yym2327 := z.EncBinary()
- _ = yym2327
+ if yyq2327[1] {
+ yym2332 := z.EncBinary()
+ _ = yym2332
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
@@ -30889,53 +30953,53 @@ func (x *PodTemplate) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2322[1] {
+ if yyq2327[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym2328 := z.EncBinary()
- _ = yym2328
+ yym2333 := z.EncBinary()
+ _ = yym2333
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
}
}
}
- if yyr2322 || yy2arr2322 {
+ if yyr2327 || yy2arr2327 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2322[2] {
- yy2330 := &x.ObjectMeta
- yy2330.CodecEncodeSelf(e)
+ if yyq2327[2] {
+ yy2335 := &x.ObjectMeta
+ yy2335.CodecEncodeSelf(e)
} else {
r.EncodeNil()
}
} else {
- if yyq2322[2] {
+ if yyq2327[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("metadata"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy2331 := &x.ObjectMeta
- yy2331.CodecEncodeSelf(e)
+ yy2336 := &x.ObjectMeta
+ yy2336.CodecEncodeSelf(e)
}
}
- if yyr2322 || yy2arr2322 {
+ if yyr2327 || yy2arr2327 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2322[3] {
- yy2333 := &x.Template
- yy2333.CodecEncodeSelf(e)
+ if yyq2327[3] {
+ yy2338 := &x.Template
+ yy2338.CodecEncodeSelf(e)
} else {
r.EncodeNil()
}
} else {
- if yyq2322[3] {
+ if yyq2327[3] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("template"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy2334 := &x.Template
- yy2334.CodecEncodeSelf(e)
+ yy2339 := &x.Template
+ yy2339.CodecEncodeSelf(e)
}
}
- if yyr2322 || yy2arr2322 {
+ if yyr2327 || yy2arr2327 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -30948,25 +31012,25 @@ func (x *PodTemplate) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym2335 := z.DecBinary()
- _ = yym2335
+ yym2340 := z.DecBinary()
+ _ = yym2340
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct2336 := r.ContainerType()
- if yyct2336 == codecSelferValueTypeMap1234 {
- yyl2336 := r.ReadMapStart()
- if yyl2336 == 0 {
+ yyct2341 := r.ContainerType()
+ if yyct2341 == codecSelferValueTypeMap1234 {
+ yyl2341 := r.ReadMapStart()
+ if yyl2341 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl2336, d)
+ x.codecDecodeSelfFromMap(yyl2341, d)
}
- } else if yyct2336 == codecSelferValueTypeArray1234 {
- yyl2336 := r.ReadArrayStart()
- if yyl2336 == 0 {
+ } else if yyct2341 == codecSelferValueTypeArray1234 {
+ yyl2341 := r.ReadArrayStart()
+ if yyl2341 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl2336, d)
+ x.codecDecodeSelfFromArray(yyl2341, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -30978,12 +31042,12 @@ func (x *PodTemplate) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys2337Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys2337Slc
- var yyhl2337 bool = l >= 0
- for yyj2337 := 0; ; yyj2337++ {
- if yyhl2337 {
- if yyj2337 >= l {
+ var yys2342Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys2342Slc
+ var yyhl2342 bool = l >= 0
+ for yyj2342 := 0; ; yyj2342++ {
+ if yyhl2342 {
+ if yyj2342 >= l {
break
}
} else {
@@ -30992,10 +31056,10 @@ func (x *PodTemplate) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys2337Slc = r.DecodeBytes(yys2337Slc, true, true)
- yys2337 := string(yys2337Slc)
+ yys2342Slc = r.DecodeBytes(yys2342Slc, true, true)
+ yys2342 := string(yys2342Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys2337 {
+ switch yys2342 {
case "kind":
if r.TryDecodeAsNil() {
x.Kind = ""
@@ -31012,20 +31076,20 @@ func (x *PodTemplate) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.ObjectMeta = ObjectMeta{}
} else {
- yyv2340 := &x.ObjectMeta
- yyv2340.CodecDecodeSelf(d)
+ yyv2345 := &x.ObjectMeta
+ yyv2345.CodecDecodeSelf(d)
}
case "template":
if r.TryDecodeAsNil() {
x.Template = PodTemplateSpec{}
} else {
- yyv2341 := &x.Template
- yyv2341.CodecDecodeSelf(d)
+ yyv2346 := &x.Template
+ yyv2346.CodecDecodeSelf(d)
}
default:
- z.DecStructFieldNotFound(-1, yys2337)
- } // end switch yys2337
- } // end for yyj2337
+ z.DecStructFieldNotFound(-1, yys2342)
+ } // end switch yys2342
+ } // end for yyj2342
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -31033,16 +31097,16 @@ func (x *PodTemplate) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj2342 int
- var yyb2342 bool
- var yyhl2342 bool = l >= 0
- yyj2342++
- if yyhl2342 {
- yyb2342 = yyj2342 > l
+ var yyj2347 int
+ var yyb2347 bool
+ var yyhl2347 bool = l >= 0
+ yyj2347++
+ if yyhl2347 {
+ yyb2347 = yyj2347 > l
} else {
- yyb2342 = r.CheckBreak()
+ yyb2347 = r.CheckBreak()
}
- if yyb2342 {
+ if yyb2347 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -31052,13 +31116,13 @@ func (x *PodTemplate) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Kind = string(r.DecodeString())
}
- yyj2342++
- if yyhl2342 {
- yyb2342 = yyj2342 > l
+ yyj2347++
+ if yyhl2347 {
+ yyb2347 = yyj2347 > l
} else {
- yyb2342 = r.CheckBreak()
+ yyb2347 = r.CheckBreak()
}
- if yyb2342 {
+ if yyb2347 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -31068,13 +31132,13 @@ func (x *PodTemplate) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.APIVersion = string(r.DecodeString())
}
- yyj2342++
- if yyhl2342 {
- yyb2342 = yyj2342 > l
+ yyj2347++
+ if yyhl2347 {
+ yyb2347 = yyj2347 > l
} else {
- yyb2342 = r.CheckBreak()
+ yyb2347 = r.CheckBreak()
}
- if yyb2342 {
+ if yyb2347 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -31082,16 +31146,16 @@ func (x *PodTemplate) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.ObjectMeta = ObjectMeta{}
} else {
- yyv2345 := &x.ObjectMeta
- yyv2345.CodecDecodeSelf(d)
+ yyv2350 := &x.ObjectMeta
+ yyv2350.CodecDecodeSelf(d)
}
- yyj2342++
- if yyhl2342 {
- yyb2342 = yyj2342 > l
+ yyj2347++
+ if yyhl2347 {
+ yyb2347 = yyj2347 > l
} else {
- yyb2342 = r.CheckBreak()
+ yyb2347 = r.CheckBreak()
}
- if yyb2342 {
+ if yyb2347 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -31099,21 +31163,21 @@ func (x *PodTemplate) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Template = PodTemplateSpec{}
} else {
- yyv2346 := &x.Template
- yyv2346.CodecDecodeSelf(d)
+ yyv2351 := &x.Template
+ yyv2351.CodecDecodeSelf(d)
}
for {
- yyj2342++
- if yyhl2342 {
- yyb2342 = yyj2342 > l
+ yyj2347++
+ if yyhl2347 {
+ yyb2347 = yyj2347 > l
} else {
- yyb2342 = r.CheckBreak()
+ yyb2347 = r.CheckBreak()
}
- if yyb2342 {
+ if yyb2347 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj2342-1, "")
+ z.DecStructFieldNotFound(yyj2347-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -31125,37 +31189,37 @@ func (x *PodTemplateList) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym2347 := z.EncBinary()
- _ = yym2347
+ yym2352 := z.EncBinary()
+ _ = yym2352
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep2348 := !z.EncBinary()
- yy2arr2348 := z.EncBasicHandle().StructToArray
- var yyq2348 [4]bool
- _, _, _ = yysep2348, yyq2348, yy2arr2348
- const yyr2348 bool = false
- yyq2348[0] = x.Kind != ""
- yyq2348[1] = x.APIVersion != ""
- yyq2348[2] = true
- var yynn2348 int
- if yyr2348 || yy2arr2348 {
+ yysep2353 := !z.EncBinary()
+ yy2arr2353 := z.EncBasicHandle().StructToArray
+ var yyq2353 [4]bool
+ _, _, _ = yysep2353, yyq2353, yy2arr2353
+ const yyr2353 bool = false
+ yyq2353[0] = x.Kind != ""
+ yyq2353[1] = x.APIVersion != ""
+ yyq2353[2] = true
+ var yynn2353 int
+ if yyr2353 || yy2arr2353 {
r.EncodeArrayStart(4)
} else {
- yynn2348 = 1
- for _, b := range yyq2348 {
+ yynn2353 = 1
+ for _, b := range yyq2353 {
if b {
- yynn2348++
+ yynn2353++
}
}
- r.EncodeMapStart(yynn2348)
- yynn2348 = 0
+ r.EncodeMapStart(yynn2353)
+ yynn2353 = 0
}
- if yyr2348 || yy2arr2348 {
+ if yyr2353 || yy2arr2353 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2348[0] {
- yym2350 := z.EncBinary()
- _ = yym2350
+ if yyq2353[0] {
+ yym2355 := z.EncBinary()
+ _ = yym2355
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
@@ -31164,23 +31228,23 @@ func (x *PodTemplateList) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2348[0] {
+ if yyq2353[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("kind"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym2351 := z.EncBinary()
- _ = yym2351
+ yym2356 := z.EncBinary()
+ _ = yym2356
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
}
}
}
- if yyr2348 || yy2arr2348 {
+ if yyr2353 || yy2arr2353 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2348[1] {
- yym2353 := z.EncBinary()
- _ = yym2353
+ if yyq2353[1] {
+ yym2358 := z.EncBinary()
+ _ = yym2358
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
@@ -31189,54 +31253,54 @@ func (x *PodTemplateList) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2348[1] {
+ if yyq2353[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym2354 := z.EncBinary()
- _ = yym2354
+ yym2359 := z.EncBinary()
+ _ = yym2359
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
}
}
}
- if yyr2348 || yy2arr2348 {
+ if yyr2353 || yy2arr2353 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2348[2] {
- yy2356 := &x.ListMeta
- yym2357 := z.EncBinary()
- _ = yym2357
+ if yyq2353[2] {
+ yy2361 := &x.ListMeta
+ yym2362 := z.EncBinary()
+ _ = yym2362
if false {
- } else if z.HasExtensions() && z.EncExt(yy2356) {
+ } else if z.HasExtensions() && z.EncExt(yy2361) {
} else {
- z.EncFallback(yy2356)
+ z.EncFallback(yy2361)
}
} else {
r.EncodeNil()
}
} else {
- if yyq2348[2] {
+ if yyq2353[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("metadata"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy2358 := &x.ListMeta
- yym2359 := z.EncBinary()
- _ = yym2359
+ yy2363 := &x.ListMeta
+ yym2364 := z.EncBinary()
+ _ = yym2364
if false {
- } else if z.HasExtensions() && z.EncExt(yy2358) {
+ } else if z.HasExtensions() && z.EncExt(yy2363) {
} else {
- z.EncFallback(yy2358)
+ z.EncFallback(yy2363)
}
}
}
- if yyr2348 || yy2arr2348 {
+ if yyr2353 || yy2arr2353 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if x.Items == nil {
r.EncodeNil()
} else {
- yym2361 := z.EncBinary()
- _ = yym2361
+ yym2366 := z.EncBinary()
+ _ = yym2366
if false {
} else {
h.encSlicePodTemplate(([]PodTemplate)(x.Items), e)
@@ -31249,15 +31313,15 @@ func (x *PodTemplateList) CodecEncodeSelf(e *codec1978.Encoder) {
if x.Items == nil {
r.EncodeNil()
} else {
- yym2362 := z.EncBinary()
- _ = yym2362
+ yym2367 := z.EncBinary()
+ _ = yym2367
if false {
} else {
h.encSlicePodTemplate(([]PodTemplate)(x.Items), e)
}
}
}
- if yyr2348 || yy2arr2348 {
+ if yyr2353 || yy2arr2353 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -31270,25 +31334,25 @@ func (x *PodTemplateList) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym2363 := z.DecBinary()
- _ = yym2363
+ yym2368 := z.DecBinary()
+ _ = yym2368
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct2364 := r.ContainerType()
- if yyct2364 == codecSelferValueTypeMap1234 {
- yyl2364 := r.ReadMapStart()
- if yyl2364 == 0 {
+ yyct2369 := r.ContainerType()
+ if yyct2369 == codecSelferValueTypeMap1234 {
+ yyl2369 := r.ReadMapStart()
+ if yyl2369 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl2364, d)
+ x.codecDecodeSelfFromMap(yyl2369, d)
}
- } else if yyct2364 == codecSelferValueTypeArray1234 {
- yyl2364 := r.ReadArrayStart()
- if yyl2364 == 0 {
+ } else if yyct2369 == codecSelferValueTypeArray1234 {
+ yyl2369 := r.ReadArrayStart()
+ if yyl2369 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl2364, d)
+ x.codecDecodeSelfFromArray(yyl2369, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -31300,12 +31364,12 @@ func (x *PodTemplateList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys2365Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys2365Slc
- var yyhl2365 bool = l >= 0
- for yyj2365 := 0; ; yyj2365++ {
- if yyhl2365 {
- if yyj2365 >= l {
+ var yys2370Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys2370Slc
+ var yyhl2370 bool = l >= 0
+ for yyj2370 := 0; ; yyj2370++ {
+ if yyhl2370 {
+ if yyj2370 >= l {
break
}
} else {
@@ -31314,10 +31378,10 @@ func (x *PodTemplateList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys2365Slc = r.DecodeBytes(yys2365Slc, true, true)
- yys2365 := string(yys2365Slc)
+ yys2370Slc = r.DecodeBytes(yys2370Slc, true, true)
+ yys2370 := string(yys2370Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys2365 {
+ switch yys2370 {
case "kind":
if r.TryDecodeAsNil() {
x.Kind = ""
@@ -31334,31 +31398,31 @@ func (x *PodTemplateList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.ListMeta = pkg2_v1.ListMeta{}
} else {
- yyv2368 := &x.ListMeta
- yym2369 := z.DecBinary()
- _ = yym2369
+ yyv2373 := &x.ListMeta
+ yym2374 := z.DecBinary()
+ _ = yym2374
if false {
- } else if z.HasExtensions() && z.DecExt(yyv2368) {
+ } else if z.HasExtensions() && z.DecExt(yyv2373) {
} else {
- z.DecFallback(yyv2368, false)
+ z.DecFallback(yyv2373, false)
}
}
case "items":
if r.TryDecodeAsNil() {
x.Items = nil
} else {
- yyv2370 := &x.Items
- yym2371 := z.DecBinary()
- _ = yym2371
+ yyv2375 := &x.Items
+ yym2376 := z.DecBinary()
+ _ = yym2376
if false {
} else {
- h.decSlicePodTemplate((*[]PodTemplate)(yyv2370), d)
+ h.decSlicePodTemplate((*[]PodTemplate)(yyv2375), d)
}
}
default:
- z.DecStructFieldNotFound(-1, yys2365)
- } // end switch yys2365
- } // end for yyj2365
+ z.DecStructFieldNotFound(-1, yys2370)
+ } // end switch yys2370
+ } // end for yyj2370
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -31366,16 +31430,16 @@ func (x *PodTemplateList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj2372 int
- var yyb2372 bool
- var yyhl2372 bool = l >= 0
- yyj2372++
- if yyhl2372 {
- yyb2372 = yyj2372 > l
+ var yyj2377 int
+ var yyb2377 bool
+ var yyhl2377 bool = l >= 0
+ yyj2377++
+ if yyhl2377 {
+ yyb2377 = yyj2377 > l
} else {
- yyb2372 = r.CheckBreak()
+ yyb2377 = r.CheckBreak()
}
- if yyb2372 {
+ if yyb2377 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -31385,13 +31449,13 @@ func (x *PodTemplateList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
} else {
x.Kind = string(r.DecodeString())
}
- yyj2372++
- if yyhl2372 {
- yyb2372 = yyj2372 > l
+ yyj2377++
+ if yyhl2377 {
+ yyb2377 = yyj2377 > l
} else {
- yyb2372 = r.CheckBreak()
+ yyb2377 = r.CheckBreak()
}
- if yyb2372 {
+ if yyb2377 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -31401,13 +31465,13 @@ func (x *PodTemplateList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
} else {
x.APIVersion = string(r.DecodeString())
}
- yyj2372++
- if yyhl2372 {
- yyb2372 = yyj2372 > l
+ yyj2377++
+ if yyhl2377 {
+ yyb2377 = yyj2377 > l
} else {
- yyb2372 = r.CheckBreak()
+ yyb2377 = r.CheckBreak()
}
- if yyb2372 {
+ if yyb2377 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -31415,22 +31479,22 @@ func (x *PodTemplateList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
if r.TryDecodeAsNil() {
x.ListMeta = pkg2_v1.ListMeta{}
} else {
- yyv2375 := &x.ListMeta
- yym2376 := z.DecBinary()
- _ = yym2376
+ yyv2380 := &x.ListMeta
+ yym2381 := z.DecBinary()
+ _ = yym2381
if false {
- } else if z.HasExtensions() && z.DecExt(yyv2375) {
+ } else if z.HasExtensions() && z.DecExt(yyv2380) {
} else {
- z.DecFallback(yyv2375, false)
+ z.DecFallback(yyv2380, false)
}
}
- yyj2372++
- if yyhl2372 {
- yyb2372 = yyj2372 > l
+ yyj2377++
+ if yyhl2377 {
+ yyb2377 = yyj2377 > l
} else {
- yyb2372 = r.CheckBreak()
+ yyb2377 = r.CheckBreak()
}
- if yyb2372 {
+ if yyb2377 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -31438,26 +31502,26 @@ func (x *PodTemplateList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
if r.TryDecodeAsNil() {
x.Items = nil
} else {
- yyv2377 := &x.Items
- yym2378 := z.DecBinary()
- _ = yym2378
+ yyv2382 := &x.Items
+ yym2383 := z.DecBinary()
+ _ = yym2383
if false {
} else {
- h.decSlicePodTemplate((*[]PodTemplate)(yyv2377), d)
+ h.decSlicePodTemplate((*[]PodTemplate)(yyv2382), d)
}
}
for {
- yyj2372++
- if yyhl2372 {
- yyb2372 = yyj2372 > l
+ yyj2377++
+ if yyhl2377 {
+ yyb2377 = yyj2377 > l
} else {
- yyb2372 = r.CheckBreak()
+ yyb2377 = r.CheckBreak()
}
- if yyb2372 {
+ if yyb2377 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj2372-1, "")
+ z.DecStructFieldNotFound(yyj2377-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -31469,73 +31533,73 @@ func (x *ReplicationControllerSpec) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym2379 := z.EncBinary()
- _ = yym2379
+ yym2384 := z.EncBinary()
+ _ = yym2384
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep2380 := !z.EncBinary()
- yy2arr2380 := z.EncBasicHandle().StructToArray
- var yyq2380 [4]bool
- _, _, _ = yysep2380, yyq2380, yy2arr2380
- const yyr2380 bool = false
- yyq2380[0] = x.Replicas != nil
- yyq2380[1] = x.MinReadySeconds != 0
- yyq2380[2] = len(x.Selector) != 0
- yyq2380[3] = x.Template != nil
- var yynn2380 int
- if yyr2380 || yy2arr2380 {
+ yysep2385 := !z.EncBinary()
+ yy2arr2385 := z.EncBasicHandle().StructToArray
+ var yyq2385 [4]bool
+ _, _, _ = yysep2385, yyq2385, yy2arr2385
+ const yyr2385 bool = false
+ yyq2385[0] = x.Replicas != nil
+ yyq2385[1] = x.MinReadySeconds != 0
+ yyq2385[2] = len(x.Selector) != 0
+ yyq2385[3] = x.Template != nil
+ var yynn2385 int
+ if yyr2385 || yy2arr2385 {
r.EncodeArrayStart(4)
} else {
- yynn2380 = 0
- for _, b := range yyq2380 {
+ yynn2385 = 0
+ for _, b := range yyq2385 {
if b {
- yynn2380++
+ yynn2385++
}
}
- r.EncodeMapStart(yynn2380)
- yynn2380 = 0
+ r.EncodeMapStart(yynn2385)
+ yynn2385 = 0
}
- if yyr2380 || yy2arr2380 {
+ if yyr2385 || yy2arr2385 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2380[0] {
+ if yyq2385[0] {
if x.Replicas == nil {
r.EncodeNil()
} else {
- yy2382 := *x.Replicas
- yym2383 := z.EncBinary()
- _ = yym2383
+ yy2387 := *x.Replicas
+ yym2388 := z.EncBinary()
+ _ = yym2388
if false {
} else {
- r.EncodeInt(int64(yy2382))
+ r.EncodeInt(int64(yy2387))
}
}
} else {
r.EncodeNil()
}
} else {
- if yyq2380[0] {
+ if yyq2385[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("replicas"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
if x.Replicas == nil {
r.EncodeNil()
} else {
- yy2384 := *x.Replicas
- yym2385 := z.EncBinary()
- _ = yym2385
+ yy2389 := *x.Replicas
+ yym2390 := z.EncBinary()
+ _ = yym2390
if false {
} else {
- r.EncodeInt(int64(yy2384))
+ r.EncodeInt(int64(yy2389))
}
}
}
}
- if yyr2380 || yy2arr2380 {
+ if yyr2385 || yy2arr2385 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2380[1] {
- yym2387 := z.EncBinary()
- _ = yym2387
+ if yyq2385[1] {
+ yym2392 := z.EncBinary()
+ _ = yym2392
if false {
} else {
r.EncodeInt(int64(x.MinReadySeconds))
@@ -31544,26 +31608,26 @@ func (x *ReplicationControllerSpec) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeInt(0)
}
} else {
- if yyq2380[1] {
+ if yyq2385[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("minReadySeconds"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym2388 := z.EncBinary()
- _ = yym2388
+ yym2393 := z.EncBinary()
+ _ = yym2393
if false {
} else {
r.EncodeInt(int64(x.MinReadySeconds))
}
}
}
- if yyr2380 || yy2arr2380 {
+ if yyr2385 || yy2arr2385 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2380[2] {
+ if yyq2385[2] {
if x.Selector == nil {
r.EncodeNil()
} else {
- yym2390 := z.EncBinary()
- _ = yym2390
+ yym2395 := z.EncBinary()
+ _ = yym2395
if false {
} else {
z.F.EncMapStringStringV(x.Selector, false, e)
@@ -31573,15 +31637,15 @@ func (x *ReplicationControllerSpec) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeNil()
}
} else {
- if yyq2380[2] {
+ if yyq2385[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("selector"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
if x.Selector == nil {
r.EncodeNil()
} else {
- yym2391 := z.EncBinary()
- _ = yym2391
+ yym2396 := z.EncBinary()
+ _ = yym2396
if false {
} else {
z.F.EncMapStringStringV(x.Selector, false, e)
@@ -31589,9 +31653,9 @@ func (x *ReplicationControllerSpec) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
- if yyr2380 || yy2arr2380 {
+ if yyr2385 || yy2arr2385 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2380[3] {
+ if yyq2385[3] {
if x.Template == nil {
r.EncodeNil()
} else {
@@ -31601,7 +31665,7 @@ func (x *ReplicationControllerSpec) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeNil()
}
} else {
- if yyq2380[3] {
+ if yyq2385[3] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("template"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
@@ -31612,7 +31676,7 @@ func (x *ReplicationControllerSpec) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
- if yyr2380 || yy2arr2380 {
+ if yyr2385 || yy2arr2385 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -31625,25 +31689,25 @@ func (x *ReplicationControllerSpec) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym2393 := z.DecBinary()
- _ = yym2393
+ yym2398 := z.DecBinary()
+ _ = yym2398
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct2394 := r.ContainerType()
- if yyct2394 == codecSelferValueTypeMap1234 {
- yyl2394 := r.ReadMapStart()
- if yyl2394 == 0 {
+ yyct2399 := r.ContainerType()
+ if yyct2399 == codecSelferValueTypeMap1234 {
+ yyl2399 := r.ReadMapStart()
+ if yyl2399 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl2394, d)
+ x.codecDecodeSelfFromMap(yyl2399, d)
}
- } else if yyct2394 == codecSelferValueTypeArray1234 {
- yyl2394 := r.ReadArrayStart()
- if yyl2394 == 0 {
+ } else if yyct2399 == codecSelferValueTypeArray1234 {
+ yyl2399 := r.ReadArrayStart()
+ if yyl2399 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl2394, d)
+ x.codecDecodeSelfFromArray(yyl2399, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -31655,12 +31719,12 @@ func (x *ReplicationControllerSpec) codecDecodeSelfFromMap(l int, d *codec1978.D
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys2395Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys2395Slc
- var yyhl2395 bool = l >= 0
- for yyj2395 := 0; ; yyj2395++ {
- if yyhl2395 {
- if yyj2395 >= l {
+ var yys2400Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys2400Slc
+ var yyhl2400 bool = l >= 0
+ for yyj2400 := 0; ; yyj2400++ {
+ if yyhl2400 {
+ if yyj2400 >= l {
break
}
} else {
@@ -31669,10 +31733,10 @@ func (x *ReplicationControllerSpec) codecDecodeSelfFromMap(l int, d *codec1978.D
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys2395Slc = r.DecodeBytes(yys2395Slc, true, true)
- yys2395 := string(yys2395Slc)
+ yys2400Slc = r.DecodeBytes(yys2400Slc, true, true)
+ yys2400 := string(yys2400Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys2395 {
+ switch yys2400 {
case "replicas":
if r.TryDecodeAsNil() {
if x.Replicas != nil {
@@ -31682,8 +31746,8 @@ func (x *ReplicationControllerSpec) codecDecodeSelfFromMap(l int, d *codec1978.D
if x.Replicas == nil {
x.Replicas = new(int32)
}
- yym2397 := z.DecBinary()
- _ = yym2397
+ yym2402 := z.DecBinary()
+ _ = yym2402
if false {
} else {
*((*int32)(x.Replicas)) = int32(r.DecodeInt(32))
@@ -31699,12 +31763,12 @@ func (x *ReplicationControllerSpec) codecDecodeSelfFromMap(l int, d *codec1978.D
if r.TryDecodeAsNil() {
x.Selector = nil
} else {
- yyv2399 := &x.Selector
- yym2400 := z.DecBinary()
- _ = yym2400
+ yyv2404 := &x.Selector
+ yym2405 := z.DecBinary()
+ _ = yym2405
if false {
} else {
- z.F.DecMapStringStringX(yyv2399, false, d)
+ z.F.DecMapStringStringX(yyv2404, false, d)
}
}
case "template":
@@ -31719,9 +31783,9 @@ func (x *ReplicationControllerSpec) codecDecodeSelfFromMap(l int, d *codec1978.D
x.Template.CodecDecodeSelf(d)
}
default:
- z.DecStructFieldNotFound(-1, yys2395)
- } // end switch yys2395
- } // end for yyj2395
+ z.DecStructFieldNotFound(-1, yys2400)
+ } // end switch yys2400
+ } // end for yyj2400
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -31729,16 +31793,16 @@ func (x *ReplicationControllerSpec) codecDecodeSelfFromArray(l int, d *codec1978
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj2402 int
- var yyb2402 bool
- var yyhl2402 bool = l >= 0
- yyj2402++
- if yyhl2402 {
- yyb2402 = yyj2402 > l
+ var yyj2407 int
+ var yyb2407 bool
+ var yyhl2407 bool = l >= 0
+ yyj2407++
+ if yyhl2407 {
+ yyb2407 = yyj2407 > l
} else {
- yyb2402 = r.CheckBreak()
+ yyb2407 = r.CheckBreak()
}
- if yyb2402 {
+ if yyb2407 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -31751,20 +31815,20 @@ func (x *ReplicationControllerSpec) codecDecodeSelfFromArray(l int, d *codec1978
if x.Replicas == nil {
x.Replicas = new(int32)
}
- yym2404 := z.DecBinary()
- _ = yym2404
+ yym2409 := z.DecBinary()
+ _ = yym2409
if false {
} else {
*((*int32)(x.Replicas)) = int32(r.DecodeInt(32))
}
}
- yyj2402++
- if yyhl2402 {
- yyb2402 = yyj2402 > l
+ yyj2407++
+ if yyhl2407 {
+ yyb2407 = yyj2407 > l
} else {
- yyb2402 = r.CheckBreak()
+ yyb2407 = r.CheckBreak()
}
- if yyb2402 {
+ if yyb2407 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -31774,13 +31838,13 @@ func (x *ReplicationControllerSpec) codecDecodeSelfFromArray(l int, d *codec1978
} else {
x.MinReadySeconds = int32(r.DecodeInt(32))
}
- yyj2402++
- if yyhl2402 {
- yyb2402 = yyj2402 > l
+ yyj2407++
+ if yyhl2407 {
+ yyb2407 = yyj2407 > l
} else {
- yyb2402 = r.CheckBreak()
+ yyb2407 = r.CheckBreak()
}
- if yyb2402 {
+ if yyb2407 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -31788,21 +31852,21 @@ func (x *ReplicationControllerSpec) codecDecodeSelfFromArray(l int, d *codec1978
if r.TryDecodeAsNil() {
x.Selector = nil
} else {
- yyv2406 := &x.Selector
- yym2407 := z.DecBinary()
- _ = yym2407
+ yyv2411 := &x.Selector
+ yym2412 := z.DecBinary()
+ _ = yym2412
if false {
} else {
- z.F.DecMapStringStringX(yyv2406, false, d)
+ z.F.DecMapStringStringX(yyv2411, false, d)
}
}
- yyj2402++
- if yyhl2402 {
- yyb2402 = yyj2402 > l
+ yyj2407++
+ if yyhl2407 {
+ yyb2407 = yyj2407 > l
} else {
- yyb2402 = r.CheckBreak()
+ yyb2407 = r.CheckBreak()
}
- if yyb2402 {
+ if yyb2407 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -31818,17 +31882,17 @@ func (x *ReplicationControllerSpec) codecDecodeSelfFromArray(l int, d *codec1978
x.Template.CodecDecodeSelf(d)
}
for {
- yyj2402++
- if yyhl2402 {
- yyb2402 = yyj2402 > l
+ yyj2407++
+ if yyhl2407 {
+ yyb2407 = yyj2407 > l
} else {
- yyb2402 = r.CheckBreak()
+ yyb2407 = r.CheckBreak()
}
- if yyb2402 {
+ if yyb2407 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj2402-1, "")
+ z.DecStructFieldNotFound(yyj2407-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -31840,38 +31904,38 @@ func (x *ReplicationControllerStatus) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym2409 := z.EncBinary()
- _ = yym2409
+ yym2414 := z.EncBinary()
+ _ = yym2414
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep2410 := !z.EncBinary()
- yy2arr2410 := z.EncBasicHandle().StructToArray
- var yyq2410 [6]bool
- _, _, _ = yysep2410, yyq2410, yy2arr2410
- const yyr2410 bool = false
- yyq2410[1] = x.FullyLabeledReplicas != 0
- yyq2410[2] = x.ReadyReplicas != 0
- yyq2410[3] = x.AvailableReplicas != 0
- yyq2410[4] = x.ObservedGeneration != 0
- yyq2410[5] = len(x.Conditions) != 0
- var yynn2410 int
- if yyr2410 || yy2arr2410 {
+ yysep2415 := !z.EncBinary()
+ yy2arr2415 := z.EncBasicHandle().StructToArray
+ var yyq2415 [6]bool
+ _, _, _ = yysep2415, yyq2415, yy2arr2415
+ const yyr2415 bool = false
+ yyq2415[1] = x.FullyLabeledReplicas != 0
+ yyq2415[2] = x.ReadyReplicas != 0
+ yyq2415[3] = x.AvailableReplicas != 0
+ yyq2415[4] = x.ObservedGeneration != 0
+ yyq2415[5] = len(x.Conditions) != 0
+ var yynn2415 int
+ if yyr2415 || yy2arr2415 {
r.EncodeArrayStart(6)
} else {
- yynn2410 = 1
- for _, b := range yyq2410 {
+ yynn2415 = 1
+ for _, b := range yyq2415 {
if b {
- yynn2410++
+ yynn2415++
}
}
- r.EncodeMapStart(yynn2410)
- yynn2410 = 0
+ r.EncodeMapStart(yynn2415)
+ yynn2415 = 0
}
- if yyr2410 || yy2arr2410 {
+ if yyr2415 || yy2arr2415 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym2412 := z.EncBinary()
- _ = yym2412
+ yym2417 := z.EncBinary()
+ _ = yym2417
if false {
} else {
r.EncodeInt(int64(x.Replicas))
@@ -31880,18 +31944,18 @@ func (x *ReplicationControllerStatus) CodecEncodeSelf(e *codec1978.Encoder) {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("replicas"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym2413 := z.EncBinary()
- _ = yym2413
+ yym2418 := z.EncBinary()
+ _ = yym2418
if false {
} else {
r.EncodeInt(int64(x.Replicas))
}
}
- if yyr2410 || yy2arr2410 {
+ if yyr2415 || yy2arr2415 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2410[1] {
- yym2415 := z.EncBinary()
- _ = yym2415
+ if yyq2415[1] {
+ yym2420 := z.EncBinary()
+ _ = yym2420
if false {
} else {
r.EncodeInt(int64(x.FullyLabeledReplicas))
@@ -31900,74 +31964,74 @@ func (x *ReplicationControllerStatus) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeInt(0)
}
} else {
- if yyq2410[1] {
+ if yyq2415[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("fullyLabeledReplicas"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym2416 := z.EncBinary()
- _ = yym2416
- if false {
- } else {
- r.EncodeInt(int64(x.FullyLabeledReplicas))
- }
- }
- }
- if yyr2410 || yy2arr2410 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2410[2] {
- yym2418 := z.EncBinary()
- _ = yym2418
- if false {
- } else {
- r.EncodeInt(int64(x.ReadyReplicas))
- }
- } else {
- r.EncodeInt(0)
- }
- } else {
- if yyq2410[2] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("readyReplicas"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym2419 := z.EncBinary()
- _ = yym2419
- if false {
- } else {
- r.EncodeInt(int64(x.ReadyReplicas))
- }
- }
- }
- if yyr2410 || yy2arr2410 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2410[3] {
yym2421 := z.EncBinary()
_ = yym2421
if false {
} else {
- r.EncodeInt(int64(x.AvailableReplicas))
+ r.EncodeInt(int64(x.FullyLabeledReplicas))
+ }
+ }
+ }
+ if yyr2415 || yy2arr2415 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2415[2] {
+ yym2423 := z.EncBinary()
+ _ = yym2423
+ if false {
+ } else {
+ r.EncodeInt(int64(x.ReadyReplicas))
}
} else {
r.EncodeInt(0)
}
} else {
- if yyq2410[3] {
+ if yyq2415[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("availableReplicas"))
+ r.EncodeString(codecSelferC_UTF81234, string("readyReplicas"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym2422 := z.EncBinary()
- _ = yym2422
- if false {
- } else {
- r.EncodeInt(int64(x.AvailableReplicas))
- }
- }
- }
- if yyr2410 || yy2arr2410 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2410[4] {
yym2424 := z.EncBinary()
_ = yym2424
if false {
+ } else {
+ r.EncodeInt(int64(x.ReadyReplicas))
+ }
+ }
+ }
+ if yyr2415 || yy2arr2415 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2415[3] {
+ yym2426 := z.EncBinary()
+ _ = yym2426
+ if false {
+ } else {
+ r.EncodeInt(int64(x.AvailableReplicas))
+ }
+ } else {
+ r.EncodeInt(0)
+ }
+ } else {
+ if yyq2415[3] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("availableReplicas"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym2427 := z.EncBinary()
+ _ = yym2427
+ if false {
+ } else {
+ r.EncodeInt(int64(x.AvailableReplicas))
+ }
+ }
+ }
+ if yyr2415 || yy2arr2415 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2415[4] {
+ yym2429 := z.EncBinary()
+ _ = yym2429
+ if false {
} else {
r.EncodeInt(int64(x.ObservedGeneration))
}
@@ -31975,26 +32039,26 @@ func (x *ReplicationControllerStatus) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeInt(0)
}
} else {
- if yyq2410[4] {
+ if yyq2415[4] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("observedGeneration"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym2425 := z.EncBinary()
- _ = yym2425
+ yym2430 := z.EncBinary()
+ _ = yym2430
if false {
} else {
r.EncodeInt(int64(x.ObservedGeneration))
}
}
}
- if yyr2410 || yy2arr2410 {
+ if yyr2415 || yy2arr2415 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2410[5] {
+ if yyq2415[5] {
if x.Conditions == nil {
r.EncodeNil()
} else {
- yym2427 := z.EncBinary()
- _ = yym2427
+ yym2432 := z.EncBinary()
+ _ = yym2432
if false {
} else {
h.encSliceReplicationControllerCondition(([]ReplicationControllerCondition)(x.Conditions), e)
@@ -32004,15 +32068,15 @@ func (x *ReplicationControllerStatus) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeNil()
}
} else {
- if yyq2410[5] {
+ if yyq2415[5] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("conditions"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
if x.Conditions == nil {
r.EncodeNil()
} else {
- yym2428 := z.EncBinary()
- _ = yym2428
+ yym2433 := z.EncBinary()
+ _ = yym2433
if false {
} else {
h.encSliceReplicationControllerCondition(([]ReplicationControllerCondition)(x.Conditions), e)
@@ -32020,7 +32084,7 @@ func (x *ReplicationControllerStatus) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
- if yyr2410 || yy2arr2410 {
+ if yyr2415 || yy2arr2415 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -32033,25 +32097,25 @@ func (x *ReplicationControllerStatus) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym2429 := z.DecBinary()
- _ = yym2429
+ yym2434 := z.DecBinary()
+ _ = yym2434
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct2430 := r.ContainerType()
- if yyct2430 == codecSelferValueTypeMap1234 {
- yyl2430 := r.ReadMapStart()
- if yyl2430 == 0 {
+ yyct2435 := r.ContainerType()
+ if yyct2435 == codecSelferValueTypeMap1234 {
+ yyl2435 := r.ReadMapStart()
+ if yyl2435 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl2430, d)
+ x.codecDecodeSelfFromMap(yyl2435, d)
}
- } else if yyct2430 == codecSelferValueTypeArray1234 {
- yyl2430 := r.ReadArrayStart()
- if yyl2430 == 0 {
+ } else if yyct2435 == codecSelferValueTypeArray1234 {
+ yyl2435 := r.ReadArrayStart()
+ if yyl2435 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl2430, d)
+ x.codecDecodeSelfFromArray(yyl2435, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -32063,12 +32127,12 @@ func (x *ReplicationControllerStatus) codecDecodeSelfFromMap(l int, d *codec1978
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys2431Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys2431Slc
- var yyhl2431 bool = l >= 0
- for yyj2431 := 0; ; yyj2431++ {
- if yyhl2431 {
- if yyj2431 >= l {
+ var yys2436Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys2436Slc
+ var yyhl2436 bool = l >= 0
+ for yyj2436 := 0; ; yyj2436++ {
+ if yyhl2436 {
+ if yyj2436 >= l {
break
}
} else {
@@ -32077,10 +32141,10 @@ func (x *ReplicationControllerStatus) codecDecodeSelfFromMap(l int, d *codec1978
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys2431Slc = r.DecodeBytes(yys2431Slc, true, true)
- yys2431 := string(yys2431Slc)
+ yys2436Slc = r.DecodeBytes(yys2436Slc, true, true)
+ yys2436 := string(yys2436Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys2431 {
+ switch yys2436 {
case "replicas":
if r.TryDecodeAsNil() {
x.Replicas = 0
@@ -32115,18 +32179,18 @@ func (x *ReplicationControllerStatus) codecDecodeSelfFromMap(l int, d *codec1978
if r.TryDecodeAsNil() {
x.Conditions = nil
} else {
- yyv2437 := &x.Conditions
- yym2438 := z.DecBinary()
- _ = yym2438
+ yyv2442 := &x.Conditions
+ yym2443 := z.DecBinary()
+ _ = yym2443
if false {
} else {
- h.decSliceReplicationControllerCondition((*[]ReplicationControllerCondition)(yyv2437), d)
+ h.decSliceReplicationControllerCondition((*[]ReplicationControllerCondition)(yyv2442), d)
}
}
default:
- z.DecStructFieldNotFound(-1, yys2431)
- } // end switch yys2431
- } // end for yyj2431
+ z.DecStructFieldNotFound(-1, yys2436)
+ } // end switch yys2436
+ } // end for yyj2436
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -32134,16 +32198,16 @@ func (x *ReplicationControllerStatus) codecDecodeSelfFromArray(l int, d *codec19
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj2439 int
- var yyb2439 bool
- var yyhl2439 bool = l >= 0
- yyj2439++
- if yyhl2439 {
- yyb2439 = yyj2439 > l
+ var yyj2444 int
+ var yyb2444 bool
+ var yyhl2444 bool = l >= 0
+ yyj2444++
+ if yyhl2444 {
+ yyb2444 = yyj2444 > l
} else {
- yyb2439 = r.CheckBreak()
+ yyb2444 = r.CheckBreak()
}
- if yyb2439 {
+ if yyb2444 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -32153,13 +32217,13 @@ func (x *ReplicationControllerStatus) codecDecodeSelfFromArray(l int, d *codec19
} else {
x.Replicas = int32(r.DecodeInt(32))
}
- yyj2439++
- if yyhl2439 {
- yyb2439 = yyj2439 > l
+ yyj2444++
+ if yyhl2444 {
+ yyb2444 = yyj2444 > l
} else {
- yyb2439 = r.CheckBreak()
+ yyb2444 = r.CheckBreak()
}
- if yyb2439 {
+ if yyb2444 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -32169,13 +32233,13 @@ func (x *ReplicationControllerStatus) codecDecodeSelfFromArray(l int, d *codec19
} else {
x.FullyLabeledReplicas = int32(r.DecodeInt(32))
}
- yyj2439++
- if yyhl2439 {
- yyb2439 = yyj2439 > l
+ yyj2444++
+ if yyhl2444 {
+ yyb2444 = yyj2444 > l
} else {
- yyb2439 = r.CheckBreak()
+ yyb2444 = r.CheckBreak()
}
- if yyb2439 {
+ if yyb2444 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -32185,13 +32249,13 @@ func (x *ReplicationControllerStatus) codecDecodeSelfFromArray(l int, d *codec19
} else {
x.ReadyReplicas = int32(r.DecodeInt(32))
}
- yyj2439++
- if yyhl2439 {
- yyb2439 = yyj2439 > l
+ yyj2444++
+ if yyhl2444 {
+ yyb2444 = yyj2444 > l
} else {
- yyb2439 = r.CheckBreak()
+ yyb2444 = r.CheckBreak()
}
- if yyb2439 {
+ if yyb2444 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -32201,13 +32265,13 @@ func (x *ReplicationControllerStatus) codecDecodeSelfFromArray(l int, d *codec19
} else {
x.AvailableReplicas = int32(r.DecodeInt(32))
}
- yyj2439++
- if yyhl2439 {
- yyb2439 = yyj2439 > l
+ yyj2444++
+ if yyhl2444 {
+ yyb2444 = yyj2444 > l
} else {
- yyb2439 = r.CheckBreak()
+ yyb2444 = r.CheckBreak()
}
- if yyb2439 {
+ if yyb2444 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -32217,13 +32281,13 @@ func (x *ReplicationControllerStatus) codecDecodeSelfFromArray(l int, d *codec19
} else {
x.ObservedGeneration = int64(r.DecodeInt(64))
}
- yyj2439++
- if yyhl2439 {
- yyb2439 = yyj2439 > l
+ yyj2444++
+ if yyhl2444 {
+ yyb2444 = yyj2444 > l
} else {
- yyb2439 = r.CheckBreak()
+ yyb2444 = r.CheckBreak()
}
- if yyb2439 {
+ if yyb2444 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -32231,26 +32295,26 @@ func (x *ReplicationControllerStatus) codecDecodeSelfFromArray(l int, d *codec19
if r.TryDecodeAsNil() {
x.Conditions = nil
} else {
- yyv2445 := &x.Conditions
- yym2446 := z.DecBinary()
- _ = yym2446
+ yyv2450 := &x.Conditions
+ yym2451 := z.DecBinary()
+ _ = yym2451
if false {
} else {
- h.decSliceReplicationControllerCondition((*[]ReplicationControllerCondition)(yyv2445), d)
+ h.decSliceReplicationControllerCondition((*[]ReplicationControllerCondition)(yyv2450), d)
}
}
for {
- yyj2439++
- if yyhl2439 {
- yyb2439 = yyj2439 > l
+ yyj2444++
+ if yyhl2444 {
+ yyb2444 = yyj2444 > l
} else {
- yyb2439 = r.CheckBreak()
+ yyb2444 = r.CheckBreak()
}
- if yyb2439 {
+ if yyb2444 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj2439-1, "")
+ z.DecStructFieldNotFound(yyj2444-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -32259,8 +32323,8 @@ func (x ReplicationControllerConditionType) CodecEncodeSelf(e *codec1978.Encoder
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
- yym2447 := z.EncBinary()
- _ = yym2447
+ yym2452 := z.EncBinary()
+ _ = yym2452
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
@@ -32272,8 +32336,8 @@ func (x *ReplicationControllerConditionType) CodecDecodeSelf(d *codec1978.Decode
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym2448 := z.DecBinary()
- _ = yym2448
+ yym2453 := z.DecBinary()
+ _ = yym2453
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
@@ -32288,33 +32352,33 @@ func (x *ReplicationControllerCondition) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym2449 := z.EncBinary()
- _ = yym2449
+ yym2454 := z.EncBinary()
+ _ = yym2454
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep2450 := !z.EncBinary()
- yy2arr2450 := z.EncBasicHandle().StructToArray
- var yyq2450 [5]bool
- _, _, _ = yysep2450, yyq2450, yy2arr2450
- const yyr2450 bool = false
- yyq2450[2] = true
- yyq2450[3] = x.Reason != ""
- yyq2450[4] = x.Message != ""
- var yynn2450 int
- if yyr2450 || yy2arr2450 {
+ yysep2455 := !z.EncBinary()
+ yy2arr2455 := z.EncBasicHandle().StructToArray
+ var yyq2455 [5]bool
+ _, _, _ = yysep2455, yyq2455, yy2arr2455
+ const yyr2455 bool = false
+ yyq2455[2] = true
+ yyq2455[3] = x.Reason != ""
+ yyq2455[4] = x.Message != ""
+ var yynn2455 int
+ if yyr2455 || yy2arr2455 {
r.EncodeArrayStart(5)
} else {
- yynn2450 = 2
- for _, b := range yyq2450 {
+ yynn2455 = 2
+ for _, b := range yyq2455 {
if b {
- yynn2450++
+ yynn2455++
}
}
- r.EncodeMapStart(yynn2450)
- yynn2450 = 0
+ r.EncodeMapStart(yynn2455)
+ yynn2455 = 0
}
- if yyr2450 || yy2arr2450 {
+ if yyr2455 || yy2arr2455 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
x.Type.CodecEncodeSelf(e)
} else {
@@ -32323,7 +32387,7 @@ func (x *ReplicationControllerCondition) CodecEncodeSelf(e *codec1978.Encoder) {
z.EncSendContainerState(codecSelfer_containerMapValue1234)
x.Type.CodecEncodeSelf(e)
}
- if yyr2450 || yy2arr2450 {
+ if yyr2455 || yy2arr2455 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
x.Status.CodecEncodeSelf(e)
} else {
@@ -32332,74 +32396,74 @@ func (x *ReplicationControllerCondition) CodecEncodeSelf(e *codec1978.Encoder) {
z.EncSendContainerState(codecSelfer_containerMapValue1234)
x.Status.CodecEncodeSelf(e)
}
- if yyr2450 || yy2arr2450 {
+ if yyr2455 || yy2arr2455 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2450[2] {
- yy2454 := &x.LastTransitionTime
- yym2455 := z.EncBinary()
- _ = yym2455
+ if yyq2455[2] {
+ yy2459 := &x.LastTransitionTime
+ yym2460 := z.EncBinary()
+ _ = yym2460
if false {
- } else if z.HasExtensions() && z.EncExt(yy2454) {
- } else if yym2455 {
- z.EncBinaryMarshal(yy2454)
- } else if !yym2455 && z.IsJSONHandle() {
- z.EncJSONMarshal(yy2454)
+ } else if z.HasExtensions() && z.EncExt(yy2459) {
+ } else if yym2460 {
+ z.EncBinaryMarshal(yy2459)
+ } else if !yym2460 && z.IsJSONHandle() {
+ z.EncJSONMarshal(yy2459)
} else {
- z.EncFallback(yy2454)
+ z.EncFallback(yy2459)
}
} else {
r.EncodeNil()
}
} else {
- if yyq2450[2] {
+ if yyq2455[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("lastTransitionTime"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy2456 := &x.LastTransitionTime
- yym2457 := z.EncBinary()
- _ = yym2457
- if false {
- } else if z.HasExtensions() && z.EncExt(yy2456) {
- } else if yym2457 {
- z.EncBinaryMarshal(yy2456)
- } else if !yym2457 && z.IsJSONHandle() {
- z.EncJSONMarshal(yy2456)
- } else {
- z.EncFallback(yy2456)
- }
- }
- }
- if yyr2450 || yy2arr2450 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2450[3] {
- yym2459 := z.EncBinary()
- _ = yym2459
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Reason))
- }
- } else {
- r.EncodeString(codecSelferC_UTF81234, "")
- }
- } else {
- if yyq2450[3] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("reason"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym2460 := z.EncBinary()
- _ = yym2460
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Reason))
- }
- }
- }
- if yyr2450 || yy2arr2450 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2450[4] {
+ yy2461 := &x.LastTransitionTime
yym2462 := z.EncBinary()
_ = yym2462
if false {
+ } else if z.HasExtensions() && z.EncExt(yy2461) {
+ } else if yym2462 {
+ z.EncBinaryMarshal(yy2461)
+ } else if !yym2462 && z.IsJSONHandle() {
+ z.EncJSONMarshal(yy2461)
+ } else {
+ z.EncFallback(yy2461)
+ }
+ }
+ }
+ if yyr2455 || yy2arr2455 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2455[3] {
+ yym2464 := z.EncBinary()
+ _ = yym2464
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Reason))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2455[3] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("reason"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym2465 := z.EncBinary()
+ _ = yym2465
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Reason))
+ }
+ }
+ }
+ if yyr2455 || yy2arr2455 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2455[4] {
+ yym2467 := z.EncBinary()
+ _ = yym2467
+ if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Message))
}
@@ -32407,19 +32471,19 @@ func (x *ReplicationControllerCondition) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2450[4] {
+ if yyq2455[4] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("message"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym2463 := z.EncBinary()
- _ = yym2463
+ yym2468 := z.EncBinary()
+ _ = yym2468
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Message))
}
}
}
- if yyr2450 || yy2arr2450 {
+ if yyr2455 || yy2arr2455 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -32432,25 +32496,25 @@ func (x *ReplicationControllerCondition) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym2464 := z.DecBinary()
- _ = yym2464
+ yym2469 := z.DecBinary()
+ _ = yym2469
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct2465 := r.ContainerType()
- if yyct2465 == codecSelferValueTypeMap1234 {
- yyl2465 := r.ReadMapStart()
- if yyl2465 == 0 {
+ yyct2470 := r.ContainerType()
+ if yyct2470 == codecSelferValueTypeMap1234 {
+ yyl2470 := r.ReadMapStart()
+ if yyl2470 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl2465, d)
+ x.codecDecodeSelfFromMap(yyl2470, d)
}
- } else if yyct2465 == codecSelferValueTypeArray1234 {
- yyl2465 := r.ReadArrayStart()
- if yyl2465 == 0 {
+ } else if yyct2470 == codecSelferValueTypeArray1234 {
+ yyl2470 := r.ReadArrayStart()
+ if yyl2470 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl2465, d)
+ x.codecDecodeSelfFromArray(yyl2470, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -32462,12 +32526,12 @@ func (x *ReplicationControllerCondition) codecDecodeSelfFromMap(l int, d *codec1
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys2466Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys2466Slc
- var yyhl2466 bool = l >= 0
- for yyj2466 := 0; ; yyj2466++ {
- if yyhl2466 {
- if yyj2466 >= l {
+ var yys2471Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys2471Slc
+ var yyhl2471 bool = l >= 0
+ for yyj2471 := 0; ; yyj2471++ {
+ if yyhl2471 {
+ if yyj2471 >= l {
break
}
} else {
@@ -32476,10 +32540,10 @@ func (x *ReplicationControllerCondition) codecDecodeSelfFromMap(l int, d *codec1
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys2466Slc = r.DecodeBytes(yys2466Slc, true, true)
- yys2466 := string(yys2466Slc)
+ yys2471Slc = r.DecodeBytes(yys2471Slc, true, true)
+ yys2471 := string(yys2471Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys2466 {
+ switch yys2471 {
case "type":
if r.TryDecodeAsNil() {
x.Type = ""
@@ -32496,17 +32560,17 @@ func (x *ReplicationControllerCondition) codecDecodeSelfFromMap(l int, d *codec1
if r.TryDecodeAsNil() {
x.LastTransitionTime = pkg2_v1.Time{}
} else {
- yyv2469 := &x.LastTransitionTime
- yym2470 := z.DecBinary()
- _ = yym2470
+ yyv2474 := &x.LastTransitionTime
+ yym2475 := z.DecBinary()
+ _ = yym2475
if false {
- } else if z.HasExtensions() && z.DecExt(yyv2469) {
- } else if yym2470 {
- z.DecBinaryUnmarshal(yyv2469)
- } else if !yym2470 && z.IsJSONHandle() {
- z.DecJSONUnmarshal(yyv2469)
+ } else if z.HasExtensions() && z.DecExt(yyv2474) {
+ } else if yym2475 {
+ z.DecBinaryUnmarshal(yyv2474)
+ } else if !yym2475 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv2474)
} else {
- z.DecFallback(yyv2469, false)
+ z.DecFallback(yyv2474, false)
}
}
case "reason":
@@ -32522,9 +32586,9 @@ func (x *ReplicationControllerCondition) codecDecodeSelfFromMap(l int, d *codec1
x.Message = string(r.DecodeString())
}
default:
- z.DecStructFieldNotFound(-1, yys2466)
- } // end switch yys2466
- } // end for yyj2466
+ z.DecStructFieldNotFound(-1, yys2471)
+ } // end switch yys2471
+ } // end for yyj2471
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -32532,16 +32596,16 @@ func (x *ReplicationControllerCondition) codecDecodeSelfFromArray(l int, d *code
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj2473 int
- var yyb2473 bool
- var yyhl2473 bool = l >= 0
- yyj2473++
- if yyhl2473 {
- yyb2473 = yyj2473 > l
+ var yyj2478 int
+ var yyb2478 bool
+ var yyhl2478 bool = l >= 0
+ yyj2478++
+ if yyhl2478 {
+ yyb2478 = yyj2478 > l
} else {
- yyb2473 = r.CheckBreak()
+ yyb2478 = r.CheckBreak()
}
- if yyb2473 {
+ if yyb2478 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -32551,13 +32615,13 @@ func (x *ReplicationControllerCondition) codecDecodeSelfFromArray(l int, d *code
} else {
x.Type = ReplicationControllerConditionType(r.DecodeString())
}
- yyj2473++
- if yyhl2473 {
- yyb2473 = yyj2473 > l
+ yyj2478++
+ if yyhl2478 {
+ yyb2478 = yyj2478 > l
} else {
- yyb2473 = r.CheckBreak()
+ yyb2478 = r.CheckBreak()
}
- if yyb2473 {
+ if yyb2478 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -32567,13 +32631,13 @@ func (x *ReplicationControllerCondition) codecDecodeSelfFromArray(l int, d *code
} else {
x.Status = ConditionStatus(r.DecodeString())
}
- yyj2473++
- if yyhl2473 {
- yyb2473 = yyj2473 > l
+ yyj2478++
+ if yyhl2478 {
+ yyb2478 = yyj2478 > l
} else {
- yyb2473 = r.CheckBreak()
+ yyb2478 = r.CheckBreak()
}
- if yyb2473 {
+ if yyb2478 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -32581,26 +32645,26 @@ func (x *ReplicationControllerCondition) codecDecodeSelfFromArray(l int, d *code
if r.TryDecodeAsNil() {
x.LastTransitionTime = pkg2_v1.Time{}
} else {
- yyv2476 := &x.LastTransitionTime
- yym2477 := z.DecBinary()
- _ = yym2477
+ yyv2481 := &x.LastTransitionTime
+ yym2482 := z.DecBinary()
+ _ = yym2482
if false {
- } else if z.HasExtensions() && z.DecExt(yyv2476) {
- } else if yym2477 {
- z.DecBinaryUnmarshal(yyv2476)
- } else if !yym2477 && z.IsJSONHandle() {
- z.DecJSONUnmarshal(yyv2476)
+ } else if z.HasExtensions() && z.DecExt(yyv2481) {
+ } else if yym2482 {
+ z.DecBinaryUnmarshal(yyv2481)
+ } else if !yym2482 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv2481)
} else {
- z.DecFallback(yyv2476, false)
+ z.DecFallback(yyv2481, false)
}
}
- yyj2473++
- if yyhl2473 {
- yyb2473 = yyj2473 > l
+ yyj2478++
+ if yyhl2478 {
+ yyb2478 = yyj2478 > l
} else {
- yyb2473 = r.CheckBreak()
+ yyb2478 = r.CheckBreak()
}
- if yyb2473 {
+ if yyb2478 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -32610,13 +32674,13 @@ func (x *ReplicationControllerCondition) codecDecodeSelfFromArray(l int, d *code
} else {
x.Reason = string(r.DecodeString())
}
- yyj2473++
- if yyhl2473 {
- yyb2473 = yyj2473 > l
+ yyj2478++
+ if yyhl2478 {
+ yyb2478 = yyj2478 > l
} else {
- yyb2473 = r.CheckBreak()
+ yyb2478 = r.CheckBreak()
}
- if yyb2473 {
+ if yyb2478 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -32627,17 +32691,17 @@ func (x *ReplicationControllerCondition) codecDecodeSelfFromArray(l int, d *code
x.Message = string(r.DecodeString())
}
for {
- yyj2473++
- if yyhl2473 {
- yyb2473 = yyj2473 > l
+ yyj2478++
+ if yyhl2478 {
+ yyb2478 = yyj2478 > l
} else {
- yyb2473 = r.CheckBreak()
+ yyb2478 = r.CheckBreak()
}
- if yyb2473 {
+ if yyb2478 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj2473-1, "")
+ z.DecStructFieldNotFound(yyj2478-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -32649,39 +32713,39 @@ func (x *ReplicationController) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym2480 := z.EncBinary()
- _ = yym2480
+ yym2485 := z.EncBinary()
+ _ = yym2485
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep2481 := !z.EncBinary()
- yy2arr2481 := z.EncBasicHandle().StructToArray
- var yyq2481 [5]bool
- _, _, _ = yysep2481, yyq2481, yy2arr2481
- const yyr2481 bool = false
- yyq2481[0] = x.Kind != ""
- yyq2481[1] = x.APIVersion != ""
- yyq2481[2] = true
- yyq2481[3] = true
- yyq2481[4] = true
- var yynn2481 int
- if yyr2481 || yy2arr2481 {
+ yysep2486 := !z.EncBinary()
+ yy2arr2486 := z.EncBasicHandle().StructToArray
+ var yyq2486 [5]bool
+ _, _, _ = yysep2486, yyq2486, yy2arr2486
+ const yyr2486 bool = false
+ yyq2486[0] = x.Kind != ""
+ yyq2486[1] = x.APIVersion != ""
+ yyq2486[2] = true
+ yyq2486[3] = true
+ yyq2486[4] = true
+ var yynn2486 int
+ if yyr2486 || yy2arr2486 {
r.EncodeArrayStart(5)
} else {
- yynn2481 = 0
- for _, b := range yyq2481 {
+ yynn2486 = 0
+ for _, b := range yyq2486 {
if b {
- yynn2481++
+ yynn2486++
}
}
- r.EncodeMapStart(yynn2481)
- yynn2481 = 0
+ r.EncodeMapStart(yynn2486)
+ yynn2486 = 0
}
- if yyr2481 || yy2arr2481 {
+ if yyr2486 || yy2arr2486 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2481[0] {
- yym2483 := z.EncBinary()
- _ = yym2483
+ if yyq2486[0] {
+ yym2488 := z.EncBinary()
+ _ = yym2488
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
@@ -32690,23 +32754,23 @@ func (x *ReplicationController) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2481[0] {
+ if yyq2486[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("kind"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym2484 := z.EncBinary()
- _ = yym2484
+ yym2489 := z.EncBinary()
+ _ = yym2489
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
}
}
}
- if yyr2481 || yy2arr2481 {
+ if yyr2486 || yy2arr2486 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2481[1] {
- yym2486 := z.EncBinary()
- _ = yym2486
+ if yyq2486[1] {
+ yym2491 := z.EncBinary()
+ _ = yym2491
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
@@ -32715,70 +32779,70 @@ func (x *ReplicationController) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2481[1] {
+ if yyq2486[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym2487 := z.EncBinary()
- _ = yym2487
+ yym2492 := z.EncBinary()
+ _ = yym2492
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
}
}
}
- if yyr2481 || yy2arr2481 {
+ if yyr2486 || yy2arr2486 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2481[2] {
- yy2489 := &x.ObjectMeta
- yy2489.CodecEncodeSelf(e)
+ if yyq2486[2] {
+ yy2494 := &x.ObjectMeta
+ yy2494.CodecEncodeSelf(e)
} else {
r.EncodeNil()
}
} else {
- if yyq2481[2] {
+ if yyq2486[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("metadata"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy2490 := &x.ObjectMeta
- yy2490.CodecEncodeSelf(e)
+ yy2495 := &x.ObjectMeta
+ yy2495.CodecEncodeSelf(e)
}
}
- if yyr2481 || yy2arr2481 {
+ if yyr2486 || yy2arr2486 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2481[3] {
- yy2492 := &x.Spec
- yy2492.CodecEncodeSelf(e)
+ if yyq2486[3] {
+ yy2497 := &x.Spec
+ yy2497.CodecEncodeSelf(e)
} else {
r.EncodeNil()
}
} else {
- if yyq2481[3] {
+ if yyq2486[3] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("spec"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy2493 := &x.Spec
- yy2493.CodecEncodeSelf(e)
+ yy2498 := &x.Spec
+ yy2498.CodecEncodeSelf(e)
}
}
- if yyr2481 || yy2arr2481 {
+ if yyr2486 || yy2arr2486 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2481[4] {
- yy2495 := &x.Status
- yy2495.CodecEncodeSelf(e)
+ if yyq2486[4] {
+ yy2500 := &x.Status
+ yy2500.CodecEncodeSelf(e)
} else {
r.EncodeNil()
}
} else {
- if yyq2481[4] {
+ if yyq2486[4] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("status"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy2496 := &x.Status
- yy2496.CodecEncodeSelf(e)
+ yy2501 := &x.Status
+ yy2501.CodecEncodeSelf(e)
}
}
- if yyr2481 || yy2arr2481 {
+ if yyr2486 || yy2arr2486 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -32791,25 +32855,25 @@ func (x *ReplicationController) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym2497 := z.DecBinary()
- _ = yym2497
+ yym2502 := z.DecBinary()
+ _ = yym2502
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct2498 := r.ContainerType()
- if yyct2498 == codecSelferValueTypeMap1234 {
- yyl2498 := r.ReadMapStart()
- if yyl2498 == 0 {
+ yyct2503 := r.ContainerType()
+ if yyct2503 == codecSelferValueTypeMap1234 {
+ yyl2503 := r.ReadMapStart()
+ if yyl2503 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl2498, d)
+ x.codecDecodeSelfFromMap(yyl2503, d)
}
- } else if yyct2498 == codecSelferValueTypeArray1234 {
- yyl2498 := r.ReadArrayStart()
- if yyl2498 == 0 {
+ } else if yyct2503 == codecSelferValueTypeArray1234 {
+ yyl2503 := r.ReadArrayStart()
+ if yyl2503 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl2498, d)
+ x.codecDecodeSelfFromArray(yyl2503, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -32821,12 +32885,12 @@ func (x *ReplicationController) codecDecodeSelfFromMap(l int, d *codec1978.Decod
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys2499Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys2499Slc
- var yyhl2499 bool = l >= 0
- for yyj2499 := 0; ; yyj2499++ {
- if yyhl2499 {
- if yyj2499 >= l {
+ var yys2504Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys2504Slc
+ var yyhl2504 bool = l >= 0
+ for yyj2504 := 0; ; yyj2504++ {
+ if yyhl2504 {
+ if yyj2504 >= l {
break
}
} else {
@@ -32835,10 +32899,10 @@ func (x *ReplicationController) codecDecodeSelfFromMap(l int, d *codec1978.Decod
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys2499Slc = r.DecodeBytes(yys2499Slc, true, true)
- yys2499 := string(yys2499Slc)
+ yys2504Slc = r.DecodeBytes(yys2504Slc, true, true)
+ yys2504 := string(yys2504Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys2499 {
+ switch yys2504 {
case "kind":
if r.TryDecodeAsNil() {
x.Kind = ""
@@ -32855,27 +32919,27 @@ func (x *ReplicationController) codecDecodeSelfFromMap(l int, d *codec1978.Decod
if r.TryDecodeAsNil() {
x.ObjectMeta = ObjectMeta{}
} else {
- yyv2502 := &x.ObjectMeta
- yyv2502.CodecDecodeSelf(d)
+ yyv2507 := &x.ObjectMeta
+ yyv2507.CodecDecodeSelf(d)
}
case "spec":
if r.TryDecodeAsNil() {
x.Spec = ReplicationControllerSpec{}
} else {
- yyv2503 := &x.Spec
- yyv2503.CodecDecodeSelf(d)
+ yyv2508 := &x.Spec
+ yyv2508.CodecDecodeSelf(d)
}
case "status":
if r.TryDecodeAsNil() {
x.Status = ReplicationControllerStatus{}
} else {
- yyv2504 := &x.Status
- yyv2504.CodecDecodeSelf(d)
+ yyv2509 := &x.Status
+ yyv2509.CodecDecodeSelf(d)
}
default:
- z.DecStructFieldNotFound(-1, yys2499)
- } // end switch yys2499
- } // end for yyj2499
+ z.DecStructFieldNotFound(-1, yys2504)
+ } // end switch yys2504
+ } // end for yyj2504
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -32883,16 +32947,16 @@ func (x *ReplicationController) codecDecodeSelfFromArray(l int, d *codec1978.Dec
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj2505 int
- var yyb2505 bool
- var yyhl2505 bool = l >= 0
- yyj2505++
- if yyhl2505 {
- yyb2505 = yyj2505 > l
+ var yyj2510 int
+ var yyb2510 bool
+ var yyhl2510 bool = l >= 0
+ yyj2510++
+ if yyhl2510 {
+ yyb2510 = yyj2510 > l
} else {
- yyb2505 = r.CheckBreak()
+ yyb2510 = r.CheckBreak()
}
- if yyb2505 {
+ if yyb2510 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -32902,13 +32966,13 @@ func (x *ReplicationController) codecDecodeSelfFromArray(l int, d *codec1978.Dec
} else {
x.Kind = string(r.DecodeString())
}
- yyj2505++
- if yyhl2505 {
- yyb2505 = yyj2505 > l
+ yyj2510++
+ if yyhl2510 {
+ yyb2510 = yyj2510 > l
} else {
- yyb2505 = r.CheckBreak()
+ yyb2510 = r.CheckBreak()
}
- if yyb2505 {
+ if yyb2510 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -32918,13 +32982,13 @@ func (x *ReplicationController) codecDecodeSelfFromArray(l int, d *codec1978.Dec
} else {
x.APIVersion = string(r.DecodeString())
}
- yyj2505++
- if yyhl2505 {
- yyb2505 = yyj2505 > l
+ yyj2510++
+ if yyhl2510 {
+ yyb2510 = yyj2510 > l
} else {
- yyb2505 = r.CheckBreak()
+ yyb2510 = r.CheckBreak()
}
- if yyb2505 {
+ if yyb2510 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -32932,16 +32996,16 @@ func (x *ReplicationController) codecDecodeSelfFromArray(l int, d *codec1978.Dec
if r.TryDecodeAsNil() {
x.ObjectMeta = ObjectMeta{}
} else {
- yyv2508 := &x.ObjectMeta
- yyv2508.CodecDecodeSelf(d)
+ yyv2513 := &x.ObjectMeta
+ yyv2513.CodecDecodeSelf(d)
}
- yyj2505++
- if yyhl2505 {
- yyb2505 = yyj2505 > l
+ yyj2510++
+ if yyhl2510 {
+ yyb2510 = yyj2510 > l
} else {
- yyb2505 = r.CheckBreak()
+ yyb2510 = r.CheckBreak()
}
- if yyb2505 {
+ if yyb2510 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -32949,16 +33013,16 @@ func (x *ReplicationController) codecDecodeSelfFromArray(l int, d *codec1978.Dec
if r.TryDecodeAsNil() {
x.Spec = ReplicationControllerSpec{}
} else {
- yyv2509 := &x.Spec
- yyv2509.CodecDecodeSelf(d)
+ yyv2514 := &x.Spec
+ yyv2514.CodecDecodeSelf(d)
}
- yyj2505++
- if yyhl2505 {
- yyb2505 = yyj2505 > l
+ yyj2510++
+ if yyhl2510 {
+ yyb2510 = yyj2510 > l
} else {
- yyb2505 = r.CheckBreak()
+ yyb2510 = r.CheckBreak()
}
- if yyb2505 {
+ if yyb2510 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -32966,21 +33030,21 @@ func (x *ReplicationController) codecDecodeSelfFromArray(l int, d *codec1978.Dec
if r.TryDecodeAsNil() {
x.Status = ReplicationControllerStatus{}
} else {
- yyv2510 := &x.Status
- yyv2510.CodecDecodeSelf(d)
+ yyv2515 := &x.Status
+ yyv2515.CodecDecodeSelf(d)
}
for {
- yyj2505++
- if yyhl2505 {
- yyb2505 = yyj2505 > l
+ yyj2510++
+ if yyhl2510 {
+ yyb2510 = yyj2510 > l
} else {
- yyb2505 = r.CheckBreak()
+ yyb2510 = r.CheckBreak()
}
- if yyb2505 {
+ if yyb2510 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj2505-1, "")
+ z.DecStructFieldNotFound(yyj2510-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -32992,37 +33056,37 @@ func (x *ReplicationControllerList) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym2511 := z.EncBinary()
- _ = yym2511
+ yym2516 := z.EncBinary()
+ _ = yym2516
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep2512 := !z.EncBinary()
- yy2arr2512 := z.EncBasicHandle().StructToArray
- var yyq2512 [4]bool
- _, _, _ = yysep2512, yyq2512, yy2arr2512
- const yyr2512 bool = false
- yyq2512[0] = x.Kind != ""
- yyq2512[1] = x.APIVersion != ""
- yyq2512[2] = true
- var yynn2512 int
- if yyr2512 || yy2arr2512 {
+ yysep2517 := !z.EncBinary()
+ yy2arr2517 := z.EncBasicHandle().StructToArray
+ var yyq2517 [4]bool
+ _, _, _ = yysep2517, yyq2517, yy2arr2517
+ const yyr2517 bool = false
+ yyq2517[0] = x.Kind != ""
+ yyq2517[1] = x.APIVersion != ""
+ yyq2517[2] = true
+ var yynn2517 int
+ if yyr2517 || yy2arr2517 {
r.EncodeArrayStart(4)
} else {
- yynn2512 = 1
- for _, b := range yyq2512 {
+ yynn2517 = 1
+ for _, b := range yyq2517 {
if b {
- yynn2512++
+ yynn2517++
}
}
- r.EncodeMapStart(yynn2512)
- yynn2512 = 0
+ r.EncodeMapStart(yynn2517)
+ yynn2517 = 0
}
- if yyr2512 || yy2arr2512 {
+ if yyr2517 || yy2arr2517 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2512[0] {
- yym2514 := z.EncBinary()
- _ = yym2514
+ if yyq2517[0] {
+ yym2519 := z.EncBinary()
+ _ = yym2519
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
@@ -33031,23 +33095,23 @@ func (x *ReplicationControllerList) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2512[0] {
+ if yyq2517[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("kind"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym2515 := z.EncBinary()
- _ = yym2515
+ yym2520 := z.EncBinary()
+ _ = yym2520
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
}
}
}
- if yyr2512 || yy2arr2512 {
+ if yyr2517 || yy2arr2517 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2512[1] {
- yym2517 := z.EncBinary()
- _ = yym2517
+ if yyq2517[1] {
+ yym2522 := z.EncBinary()
+ _ = yym2522
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
@@ -33056,54 +33120,54 @@ func (x *ReplicationControllerList) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2512[1] {
+ if yyq2517[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym2518 := z.EncBinary()
- _ = yym2518
+ yym2523 := z.EncBinary()
+ _ = yym2523
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
}
}
}
- if yyr2512 || yy2arr2512 {
+ if yyr2517 || yy2arr2517 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2512[2] {
- yy2520 := &x.ListMeta
- yym2521 := z.EncBinary()
- _ = yym2521
+ if yyq2517[2] {
+ yy2525 := &x.ListMeta
+ yym2526 := z.EncBinary()
+ _ = yym2526
if false {
- } else if z.HasExtensions() && z.EncExt(yy2520) {
+ } else if z.HasExtensions() && z.EncExt(yy2525) {
} else {
- z.EncFallback(yy2520)
+ z.EncFallback(yy2525)
}
} else {
r.EncodeNil()
}
} else {
- if yyq2512[2] {
+ if yyq2517[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("metadata"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy2522 := &x.ListMeta
- yym2523 := z.EncBinary()
- _ = yym2523
+ yy2527 := &x.ListMeta
+ yym2528 := z.EncBinary()
+ _ = yym2528
if false {
- } else if z.HasExtensions() && z.EncExt(yy2522) {
+ } else if z.HasExtensions() && z.EncExt(yy2527) {
} else {
- z.EncFallback(yy2522)
+ z.EncFallback(yy2527)
}
}
}
- if yyr2512 || yy2arr2512 {
+ if yyr2517 || yy2arr2517 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if x.Items == nil {
r.EncodeNil()
} else {
- yym2525 := z.EncBinary()
- _ = yym2525
+ yym2530 := z.EncBinary()
+ _ = yym2530
if false {
} else {
h.encSliceReplicationController(([]ReplicationController)(x.Items), e)
@@ -33116,15 +33180,15 @@ func (x *ReplicationControllerList) CodecEncodeSelf(e *codec1978.Encoder) {
if x.Items == nil {
r.EncodeNil()
} else {
- yym2526 := z.EncBinary()
- _ = yym2526
+ yym2531 := z.EncBinary()
+ _ = yym2531
if false {
} else {
h.encSliceReplicationController(([]ReplicationController)(x.Items), e)
}
}
}
- if yyr2512 || yy2arr2512 {
+ if yyr2517 || yy2arr2517 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -33137,25 +33201,25 @@ func (x *ReplicationControllerList) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym2527 := z.DecBinary()
- _ = yym2527
+ yym2532 := z.DecBinary()
+ _ = yym2532
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct2528 := r.ContainerType()
- if yyct2528 == codecSelferValueTypeMap1234 {
- yyl2528 := r.ReadMapStart()
- if yyl2528 == 0 {
+ yyct2533 := r.ContainerType()
+ if yyct2533 == codecSelferValueTypeMap1234 {
+ yyl2533 := r.ReadMapStart()
+ if yyl2533 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl2528, d)
+ x.codecDecodeSelfFromMap(yyl2533, d)
}
- } else if yyct2528 == codecSelferValueTypeArray1234 {
- yyl2528 := r.ReadArrayStart()
- if yyl2528 == 0 {
+ } else if yyct2533 == codecSelferValueTypeArray1234 {
+ yyl2533 := r.ReadArrayStart()
+ if yyl2533 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl2528, d)
+ x.codecDecodeSelfFromArray(yyl2533, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -33167,12 +33231,12 @@ func (x *ReplicationControllerList) codecDecodeSelfFromMap(l int, d *codec1978.D
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys2529Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys2529Slc
- var yyhl2529 bool = l >= 0
- for yyj2529 := 0; ; yyj2529++ {
- if yyhl2529 {
- if yyj2529 >= l {
+ var yys2534Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys2534Slc
+ var yyhl2534 bool = l >= 0
+ for yyj2534 := 0; ; yyj2534++ {
+ if yyhl2534 {
+ if yyj2534 >= l {
break
}
} else {
@@ -33181,10 +33245,10 @@ func (x *ReplicationControllerList) codecDecodeSelfFromMap(l int, d *codec1978.D
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys2529Slc = r.DecodeBytes(yys2529Slc, true, true)
- yys2529 := string(yys2529Slc)
+ yys2534Slc = r.DecodeBytes(yys2534Slc, true, true)
+ yys2534 := string(yys2534Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys2529 {
+ switch yys2534 {
case "kind":
if r.TryDecodeAsNil() {
x.Kind = ""
@@ -33201,31 +33265,31 @@ func (x *ReplicationControllerList) codecDecodeSelfFromMap(l int, d *codec1978.D
if r.TryDecodeAsNil() {
x.ListMeta = pkg2_v1.ListMeta{}
} else {
- yyv2532 := &x.ListMeta
- yym2533 := z.DecBinary()
- _ = yym2533
+ yyv2537 := &x.ListMeta
+ yym2538 := z.DecBinary()
+ _ = yym2538
if false {
- } else if z.HasExtensions() && z.DecExt(yyv2532) {
+ } else if z.HasExtensions() && z.DecExt(yyv2537) {
} else {
- z.DecFallback(yyv2532, false)
+ z.DecFallback(yyv2537, false)
}
}
case "items":
if r.TryDecodeAsNil() {
x.Items = nil
} else {
- yyv2534 := &x.Items
- yym2535 := z.DecBinary()
- _ = yym2535
+ yyv2539 := &x.Items
+ yym2540 := z.DecBinary()
+ _ = yym2540
if false {
} else {
- h.decSliceReplicationController((*[]ReplicationController)(yyv2534), d)
+ h.decSliceReplicationController((*[]ReplicationController)(yyv2539), d)
}
}
default:
- z.DecStructFieldNotFound(-1, yys2529)
- } // end switch yys2529
- } // end for yyj2529
+ z.DecStructFieldNotFound(-1, yys2534)
+ } // end switch yys2534
+ } // end for yyj2534
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -33233,16 +33297,16 @@ func (x *ReplicationControllerList) codecDecodeSelfFromArray(l int, d *codec1978
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj2536 int
- var yyb2536 bool
- var yyhl2536 bool = l >= 0
- yyj2536++
- if yyhl2536 {
- yyb2536 = yyj2536 > l
+ var yyj2541 int
+ var yyb2541 bool
+ var yyhl2541 bool = l >= 0
+ yyj2541++
+ if yyhl2541 {
+ yyb2541 = yyj2541 > l
} else {
- yyb2536 = r.CheckBreak()
+ yyb2541 = r.CheckBreak()
}
- if yyb2536 {
+ if yyb2541 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -33252,13 +33316,13 @@ func (x *ReplicationControllerList) codecDecodeSelfFromArray(l int, d *codec1978
} else {
x.Kind = string(r.DecodeString())
}
- yyj2536++
- if yyhl2536 {
- yyb2536 = yyj2536 > l
+ yyj2541++
+ if yyhl2541 {
+ yyb2541 = yyj2541 > l
} else {
- yyb2536 = r.CheckBreak()
+ yyb2541 = r.CheckBreak()
}
- if yyb2536 {
+ if yyb2541 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -33268,13 +33332,13 @@ func (x *ReplicationControllerList) codecDecodeSelfFromArray(l int, d *codec1978
} else {
x.APIVersion = string(r.DecodeString())
}
- yyj2536++
- if yyhl2536 {
- yyb2536 = yyj2536 > l
+ yyj2541++
+ if yyhl2541 {
+ yyb2541 = yyj2541 > l
} else {
- yyb2536 = r.CheckBreak()
+ yyb2541 = r.CheckBreak()
}
- if yyb2536 {
+ if yyb2541 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -33282,22 +33346,22 @@ func (x *ReplicationControllerList) codecDecodeSelfFromArray(l int, d *codec1978
if r.TryDecodeAsNil() {
x.ListMeta = pkg2_v1.ListMeta{}
} else {
- yyv2539 := &x.ListMeta
- yym2540 := z.DecBinary()
- _ = yym2540
+ yyv2544 := &x.ListMeta
+ yym2545 := z.DecBinary()
+ _ = yym2545
if false {
- } else if z.HasExtensions() && z.DecExt(yyv2539) {
+ } else if z.HasExtensions() && z.DecExt(yyv2544) {
} else {
- z.DecFallback(yyv2539, false)
+ z.DecFallback(yyv2544, false)
}
}
- yyj2536++
- if yyhl2536 {
- yyb2536 = yyj2536 > l
+ yyj2541++
+ if yyhl2541 {
+ yyb2541 = yyj2541 > l
} else {
- yyb2536 = r.CheckBreak()
+ yyb2541 = r.CheckBreak()
}
- if yyb2536 {
+ if yyb2541 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -33305,26 +33369,26 @@ func (x *ReplicationControllerList) codecDecodeSelfFromArray(l int, d *codec1978
if r.TryDecodeAsNil() {
x.Items = nil
} else {
- yyv2541 := &x.Items
- yym2542 := z.DecBinary()
- _ = yym2542
+ yyv2546 := &x.Items
+ yym2547 := z.DecBinary()
+ _ = yym2547
if false {
} else {
- h.decSliceReplicationController((*[]ReplicationController)(yyv2541), d)
+ h.decSliceReplicationController((*[]ReplicationController)(yyv2546), d)
}
}
for {
- yyj2536++
- if yyhl2536 {
- yyb2536 = yyj2536 > l
+ yyj2541++
+ if yyhl2541 {
+ yyb2541 = yyj2541 > l
} else {
- yyb2536 = r.CheckBreak()
+ yyb2541 = r.CheckBreak()
}
- if yyb2536 {
+ if yyb2541 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj2536-1, "")
+ z.DecStructFieldNotFound(yyj2541-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -33333,8 +33397,8 @@ func (x ServiceAffinity) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
- yym2543 := z.EncBinary()
- _ = yym2543
+ yym2548 := z.EncBinary()
+ _ = yym2548
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
@@ -33346,8 +33410,8 @@ func (x *ServiceAffinity) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym2544 := z.DecBinary()
- _ = yym2544
+ yym2549 := z.DecBinary()
+ _ = yym2549
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
@@ -33359,8 +33423,8 @@ func (x ServiceType) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
- yym2545 := z.EncBinary()
- _ = yym2545
+ yym2550 := z.EncBinary()
+ _ = yym2550
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
@@ -33372,8 +33436,8 @@ func (x *ServiceType) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym2546 := z.DecBinary()
- _ = yym2546
+ yym2551 := z.DecBinary()
+ _ = yym2551
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
@@ -33388,48 +33452,48 @@ func (x *ServiceStatus) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym2547 := z.EncBinary()
- _ = yym2547
+ yym2552 := z.EncBinary()
+ _ = yym2552
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep2548 := !z.EncBinary()
- yy2arr2548 := z.EncBasicHandle().StructToArray
- var yyq2548 [1]bool
- _, _, _ = yysep2548, yyq2548, yy2arr2548
- const yyr2548 bool = false
- yyq2548[0] = true
- var yynn2548 int
- if yyr2548 || yy2arr2548 {
+ yysep2553 := !z.EncBinary()
+ yy2arr2553 := z.EncBasicHandle().StructToArray
+ var yyq2553 [1]bool
+ _, _, _ = yysep2553, yyq2553, yy2arr2553
+ const yyr2553 bool = false
+ yyq2553[0] = true
+ var yynn2553 int
+ if yyr2553 || yy2arr2553 {
r.EncodeArrayStart(1)
} else {
- yynn2548 = 0
- for _, b := range yyq2548 {
+ yynn2553 = 0
+ for _, b := range yyq2553 {
if b {
- yynn2548++
+ yynn2553++
}
}
- r.EncodeMapStart(yynn2548)
- yynn2548 = 0
+ r.EncodeMapStart(yynn2553)
+ yynn2553 = 0
}
- if yyr2548 || yy2arr2548 {
+ if yyr2553 || yy2arr2553 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2548[0] {
- yy2550 := &x.LoadBalancer
- yy2550.CodecEncodeSelf(e)
+ if yyq2553[0] {
+ yy2555 := &x.LoadBalancer
+ yy2555.CodecEncodeSelf(e)
} else {
r.EncodeNil()
}
} else {
- if yyq2548[0] {
+ if yyq2553[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("loadBalancer"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy2551 := &x.LoadBalancer
- yy2551.CodecEncodeSelf(e)
+ yy2556 := &x.LoadBalancer
+ yy2556.CodecEncodeSelf(e)
}
}
- if yyr2548 || yy2arr2548 {
+ if yyr2553 || yy2arr2553 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -33442,25 +33506,25 @@ func (x *ServiceStatus) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym2552 := z.DecBinary()
- _ = yym2552
+ yym2557 := z.DecBinary()
+ _ = yym2557
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct2553 := r.ContainerType()
- if yyct2553 == codecSelferValueTypeMap1234 {
- yyl2553 := r.ReadMapStart()
- if yyl2553 == 0 {
+ yyct2558 := r.ContainerType()
+ if yyct2558 == codecSelferValueTypeMap1234 {
+ yyl2558 := r.ReadMapStart()
+ if yyl2558 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl2553, d)
+ x.codecDecodeSelfFromMap(yyl2558, d)
}
- } else if yyct2553 == codecSelferValueTypeArray1234 {
- yyl2553 := r.ReadArrayStart()
- if yyl2553 == 0 {
+ } else if yyct2558 == codecSelferValueTypeArray1234 {
+ yyl2558 := r.ReadArrayStart()
+ if yyl2558 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl2553, d)
+ x.codecDecodeSelfFromArray(yyl2558, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -33472,12 +33536,12 @@ func (x *ServiceStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys2554Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys2554Slc
- var yyhl2554 bool = l >= 0
- for yyj2554 := 0; ; yyj2554++ {
- if yyhl2554 {
- if yyj2554 >= l {
+ var yys2559Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys2559Slc
+ var yyhl2559 bool = l >= 0
+ for yyj2559 := 0; ; yyj2559++ {
+ if yyhl2559 {
+ if yyj2559 >= l {
break
}
} else {
@@ -33486,21 +33550,21 @@ func (x *ServiceStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys2554Slc = r.DecodeBytes(yys2554Slc, true, true)
- yys2554 := string(yys2554Slc)
+ yys2559Slc = r.DecodeBytes(yys2559Slc, true, true)
+ yys2559 := string(yys2559Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys2554 {
+ switch yys2559 {
case "loadBalancer":
if r.TryDecodeAsNil() {
x.LoadBalancer = LoadBalancerStatus{}
} else {
- yyv2555 := &x.LoadBalancer
- yyv2555.CodecDecodeSelf(d)
+ yyv2560 := &x.LoadBalancer
+ yyv2560.CodecDecodeSelf(d)
}
default:
- z.DecStructFieldNotFound(-1, yys2554)
- } // end switch yys2554
- } // end for yyj2554
+ z.DecStructFieldNotFound(-1, yys2559)
+ } // end switch yys2559
+ } // end for yyj2559
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -33508,16 +33572,16 @@ func (x *ServiceStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj2556 int
- var yyb2556 bool
- var yyhl2556 bool = l >= 0
- yyj2556++
- if yyhl2556 {
- yyb2556 = yyj2556 > l
+ var yyj2561 int
+ var yyb2561 bool
+ var yyhl2561 bool = l >= 0
+ yyj2561++
+ if yyhl2561 {
+ yyb2561 = yyj2561 > l
} else {
- yyb2556 = r.CheckBreak()
+ yyb2561 = r.CheckBreak()
}
- if yyb2556 {
+ if yyb2561 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -33525,21 +33589,21 @@ func (x *ServiceStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.LoadBalancer = LoadBalancerStatus{}
} else {
- yyv2557 := &x.LoadBalancer
- yyv2557.CodecDecodeSelf(d)
+ yyv2562 := &x.LoadBalancer
+ yyv2562.CodecDecodeSelf(d)
}
for {
- yyj2556++
- if yyhl2556 {
- yyb2556 = yyj2556 > l
+ yyj2561++
+ if yyhl2561 {
+ yyb2561 = yyj2561 > l
} else {
- yyb2556 = r.CheckBreak()
+ yyb2561 = r.CheckBreak()
}
- if yyb2556 {
+ if yyb2561 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj2556-1, "")
+ z.DecStructFieldNotFound(yyj2561-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -33551,38 +33615,38 @@ func (x *LoadBalancerStatus) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym2558 := z.EncBinary()
- _ = yym2558
+ yym2563 := z.EncBinary()
+ _ = yym2563
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep2559 := !z.EncBinary()
- yy2arr2559 := z.EncBasicHandle().StructToArray
- var yyq2559 [1]bool
- _, _, _ = yysep2559, yyq2559, yy2arr2559
- const yyr2559 bool = false
- yyq2559[0] = len(x.Ingress) != 0
- var yynn2559 int
- if yyr2559 || yy2arr2559 {
+ yysep2564 := !z.EncBinary()
+ yy2arr2564 := z.EncBasicHandle().StructToArray
+ var yyq2564 [1]bool
+ _, _, _ = yysep2564, yyq2564, yy2arr2564
+ const yyr2564 bool = false
+ yyq2564[0] = len(x.Ingress) != 0
+ var yynn2564 int
+ if yyr2564 || yy2arr2564 {
r.EncodeArrayStart(1)
} else {
- yynn2559 = 0
- for _, b := range yyq2559 {
+ yynn2564 = 0
+ for _, b := range yyq2564 {
if b {
- yynn2559++
+ yynn2564++
}
}
- r.EncodeMapStart(yynn2559)
- yynn2559 = 0
+ r.EncodeMapStart(yynn2564)
+ yynn2564 = 0
}
- if yyr2559 || yy2arr2559 {
+ if yyr2564 || yy2arr2564 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2559[0] {
+ if yyq2564[0] {
if x.Ingress == nil {
r.EncodeNil()
} else {
- yym2561 := z.EncBinary()
- _ = yym2561
+ yym2566 := z.EncBinary()
+ _ = yym2566
if false {
} else {
h.encSliceLoadBalancerIngress(([]LoadBalancerIngress)(x.Ingress), e)
@@ -33592,15 +33656,15 @@ func (x *LoadBalancerStatus) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeNil()
}
} else {
- if yyq2559[0] {
+ if yyq2564[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("ingress"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
if x.Ingress == nil {
r.EncodeNil()
} else {
- yym2562 := z.EncBinary()
- _ = yym2562
+ yym2567 := z.EncBinary()
+ _ = yym2567
if false {
} else {
h.encSliceLoadBalancerIngress(([]LoadBalancerIngress)(x.Ingress), e)
@@ -33608,7 +33672,7 @@ func (x *LoadBalancerStatus) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
- if yyr2559 || yy2arr2559 {
+ if yyr2564 || yy2arr2564 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -33621,25 +33685,25 @@ func (x *LoadBalancerStatus) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym2563 := z.DecBinary()
- _ = yym2563
+ yym2568 := z.DecBinary()
+ _ = yym2568
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct2564 := r.ContainerType()
- if yyct2564 == codecSelferValueTypeMap1234 {
- yyl2564 := r.ReadMapStart()
- if yyl2564 == 0 {
+ yyct2569 := r.ContainerType()
+ if yyct2569 == codecSelferValueTypeMap1234 {
+ yyl2569 := r.ReadMapStart()
+ if yyl2569 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl2564, d)
+ x.codecDecodeSelfFromMap(yyl2569, d)
}
- } else if yyct2564 == codecSelferValueTypeArray1234 {
- yyl2564 := r.ReadArrayStart()
- if yyl2564 == 0 {
+ } else if yyct2569 == codecSelferValueTypeArray1234 {
+ yyl2569 := r.ReadArrayStart()
+ if yyl2569 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl2564, d)
+ x.codecDecodeSelfFromArray(yyl2569, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -33651,12 +33715,12 @@ func (x *LoadBalancerStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder)
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys2565Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys2565Slc
- var yyhl2565 bool = l >= 0
- for yyj2565 := 0; ; yyj2565++ {
- if yyhl2565 {
- if yyj2565 >= l {
+ var yys2570Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys2570Slc
+ var yyhl2570 bool = l >= 0
+ for yyj2570 := 0; ; yyj2570++ {
+ if yyhl2570 {
+ if yyj2570 >= l {
break
}
} else {
@@ -33665,26 +33729,26 @@ func (x *LoadBalancerStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder)
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys2565Slc = r.DecodeBytes(yys2565Slc, true, true)
- yys2565 := string(yys2565Slc)
+ yys2570Slc = r.DecodeBytes(yys2570Slc, true, true)
+ yys2570 := string(yys2570Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys2565 {
+ switch yys2570 {
case "ingress":
if r.TryDecodeAsNil() {
x.Ingress = nil
} else {
- yyv2566 := &x.Ingress
- yym2567 := z.DecBinary()
- _ = yym2567
+ yyv2571 := &x.Ingress
+ yym2572 := z.DecBinary()
+ _ = yym2572
if false {
} else {
- h.decSliceLoadBalancerIngress((*[]LoadBalancerIngress)(yyv2566), d)
+ h.decSliceLoadBalancerIngress((*[]LoadBalancerIngress)(yyv2571), d)
}
}
default:
- z.DecStructFieldNotFound(-1, yys2565)
- } // end switch yys2565
- } // end for yyj2565
+ z.DecStructFieldNotFound(-1, yys2570)
+ } // end switch yys2570
+ } // end for yyj2570
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -33692,16 +33756,16 @@ func (x *LoadBalancerStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decode
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj2568 int
- var yyb2568 bool
- var yyhl2568 bool = l >= 0
- yyj2568++
- if yyhl2568 {
- yyb2568 = yyj2568 > l
+ var yyj2573 int
+ var yyb2573 bool
+ var yyhl2573 bool = l >= 0
+ yyj2573++
+ if yyhl2573 {
+ yyb2573 = yyj2573 > l
} else {
- yyb2568 = r.CheckBreak()
+ yyb2573 = r.CheckBreak()
}
- if yyb2568 {
+ if yyb2573 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -33709,26 +33773,26 @@ func (x *LoadBalancerStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decode
if r.TryDecodeAsNil() {
x.Ingress = nil
} else {
- yyv2569 := &x.Ingress
- yym2570 := z.DecBinary()
- _ = yym2570
+ yyv2574 := &x.Ingress
+ yym2575 := z.DecBinary()
+ _ = yym2575
if false {
} else {
- h.decSliceLoadBalancerIngress((*[]LoadBalancerIngress)(yyv2569), d)
+ h.decSliceLoadBalancerIngress((*[]LoadBalancerIngress)(yyv2574), d)
}
}
for {
- yyj2568++
- if yyhl2568 {
- yyb2568 = yyj2568 > l
+ yyj2573++
+ if yyhl2573 {
+ yyb2573 = yyj2573 > l
} else {
- yyb2568 = r.CheckBreak()
+ yyb2573 = r.CheckBreak()
}
- if yyb2568 {
+ if yyb2573 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj2568-1, "")
+ z.DecStructFieldNotFound(yyj2573-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -33740,36 +33804,36 @@ func (x *LoadBalancerIngress) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym2571 := z.EncBinary()
- _ = yym2571
+ yym2576 := z.EncBinary()
+ _ = yym2576
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep2572 := !z.EncBinary()
- yy2arr2572 := z.EncBasicHandle().StructToArray
- var yyq2572 [2]bool
- _, _, _ = yysep2572, yyq2572, yy2arr2572
- const yyr2572 bool = false
- yyq2572[0] = x.IP != ""
- yyq2572[1] = x.Hostname != ""
- var yynn2572 int
- if yyr2572 || yy2arr2572 {
+ yysep2577 := !z.EncBinary()
+ yy2arr2577 := z.EncBasicHandle().StructToArray
+ var yyq2577 [2]bool
+ _, _, _ = yysep2577, yyq2577, yy2arr2577
+ const yyr2577 bool = false
+ yyq2577[0] = x.IP != ""
+ yyq2577[1] = x.Hostname != ""
+ var yynn2577 int
+ if yyr2577 || yy2arr2577 {
r.EncodeArrayStart(2)
} else {
- yynn2572 = 0
- for _, b := range yyq2572 {
+ yynn2577 = 0
+ for _, b := range yyq2577 {
if b {
- yynn2572++
+ yynn2577++
}
}
- r.EncodeMapStart(yynn2572)
- yynn2572 = 0
+ r.EncodeMapStart(yynn2577)
+ yynn2577 = 0
}
- if yyr2572 || yy2arr2572 {
+ if yyr2577 || yy2arr2577 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2572[0] {
- yym2574 := z.EncBinary()
- _ = yym2574
+ if yyq2577[0] {
+ yym2579 := z.EncBinary()
+ _ = yym2579
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.IP))
@@ -33778,23 +33842,23 @@ func (x *LoadBalancerIngress) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2572[0] {
+ if yyq2577[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("ip"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym2575 := z.EncBinary()
- _ = yym2575
+ yym2580 := z.EncBinary()
+ _ = yym2580
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.IP))
}
}
}
- if yyr2572 || yy2arr2572 {
+ if yyr2577 || yy2arr2577 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2572[1] {
- yym2577 := z.EncBinary()
- _ = yym2577
+ if yyq2577[1] {
+ yym2582 := z.EncBinary()
+ _ = yym2582
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Hostname))
@@ -33803,19 +33867,19 @@ func (x *LoadBalancerIngress) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2572[1] {
+ if yyq2577[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("hostname"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym2578 := z.EncBinary()
- _ = yym2578
+ yym2583 := z.EncBinary()
+ _ = yym2583
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Hostname))
}
}
}
- if yyr2572 || yy2arr2572 {
+ if yyr2577 || yy2arr2577 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -33828,25 +33892,25 @@ func (x *LoadBalancerIngress) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym2579 := z.DecBinary()
- _ = yym2579
+ yym2584 := z.DecBinary()
+ _ = yym2584
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct2580 := r.ContainerType()
- if yyct2580 == codecSelferValueTypeMap1234 {
- yyl2580 := r.ReadMapStart()
- if yyl2580 == 0 {
+ yyct2585 := r.ContainerType()
+ if yyct2585 == codecSelferValueTypeMap1234 {
+ yyl2585 := r.ReadMapStart()
+ if yyl2585 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl2580, d)
+ x.codecDecodeSelfFromMap(yyl2585, d)
}
- } else if yyct2580 == codecSelferValueTypeArray1234 {
- yyl2580 := r.ReadArrayStart()
- if yyl2580 == 0 {
+ } else if yyct2585 == codecSelferValueTypeArray1234 {
+ yyl2585 := r.ReadArrayStart()
+ if yyl2585 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl2580, d)
+ x.codecDecodeSelfFromArray(yyl2585, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -33858,12 +33922,12 @@ func (x *LoadBalancerIngress) codecDecodeSelfFromMap(l int, d *codec1978.Decoder
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys2581Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys2581Slc
- var yyhl2581 bool = l >= 0
- for yyj2581 := 0; ; yyj2581++ {
- if yyhl2581 {
- if yyj2581 >= l {
+ var yys2586Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys2586Slc
+ var yyhl2586 bool = l >= 0
+ for yyj2586 := 0; ; yyj2586++ {
+ if yyhl2586 {
+ if yyj2586 >= l {
break
}
} else {
@@ -33872,10 +33936,10 @@ func (x *LoadBalancerIngress) codecDecodeSelfFromMap(l int, d *codec1978.Decoder
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys2581Slc = r.DecodeBytes(yys2581Slc, true, true)
- yys2581 := string(yys2581Slc)
+ yys2586Slc = r.DecodeBytes(yys2586Slc, true, true)
+ yys2586 := string(yys2586Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys2581 {
+ switch yys2586 {
case "ip":
if r.TryDecodeAsNil() {
x.IP = ""
@@ -33889,9 +33953,9 @@ func (x *LoadBalancerIngress) codecDecodeSelfFromMap(l int, d *codec1978.Decoder
x.Hostname = string(r.DecodeString())
}
default:
- z.DecStructFieldNotFound(-1, yys2581)
- } // end switch yys2581
- } // end for yyj2581
+ z.DecStructFieldNotFound(-1, yys2586)
+ } // end switch yys2586
+ } // end for yyj2586
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -33899,16 +33963,16 @@ func (x *LoadBalancerIngress) codecDecodeSelfFromArray(l int, d *codec1978.Decod
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj2584 int
- var yyb2584 bool
- var yyhl2584 bool = l >= 0
- yyj2584++
- if yyhl2584 {
- yyb2584 = yyj2584 > l
+ var yyj2589 int
+ var yyb2589 bool
+ var yyhl2589 bool = l >= 0
+ yyj2589++
+ if yyhl2589 {
+ yyb2589 = yyj2589 > l
} else {
- yyb2584 = r.CheckBreak()
+ yyb2589 = r.CheckBreak()
}
- if yyb2584 {
+ if yyb2589 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -33918,13 +33982,13 @@ func (x *LoadBalancerIngress) codecDecodeSelfFromArray(l int, d *codec1978.Decod
} else {
x.IP = string(r.DecodeString())
}
- yyj2584++
- if yyhl2584 {
- yyb2584 = yyj2584 > l
+ yyj2589++
+ if yyhl2589 {
+ yyb2589 = yyj2589 > l
} else {
- yyb2584 = r.CheckBreak()
+ yyb2589 = r.CheckBreak()
}
- if yyb2584 {
+ if yyb2589 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -33935,17 +33999,17 @@ func (x *LoadBalancerIngress) codecDecodeSelfFromArray(l int, d *codec1978.Decod
x.Hostname = string(r.DecodeString())
}
for {
- yyj2584++
- if yyhl2584 {
- yyb2584 = yyj2584 > l
+ yyj2589++
+ if yyhl2589 {
+ yyb2589 = yyj2589 > l
} else {
- yyb2584 = r.CheckBreak()
+ yyb2589 = r.CheckBreak()
}
- if yyb2584 {
+ if yyb2589 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj2584-1, "")
+ z.DecStructFieldNotFound(yyj2589-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -33957,47 +34021,47 @@ func (x *ServiceSpec) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym2587 := z.EncBinary()
- _ = yym2587
+ yym2592 := z.EncBinary()
+ _ = yym2592
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep2588 := !z.EncBinary()
- yy2arr2588 := z.EncBasicHandle().StructToArray
- var yyq2588 [10]bool
- _, _, _ = yysep2588, yyq2588, yy2arr2588
- const yyr2588 bool = false
- yyq2588[0] = len(x.Ports) != 0
- yyq2588[1] = len(x.Selector) != 0
- yyq2588[2] = x.ClusterIP != ""
- yyq2588[3] = x.Type != ""
- yyq2588[4] = len(x.ExternalIPs) != 0
- yyq2588[5] = len(x.DeprecatedPublicIPs) != 0
- yyq2588[6] = x.SessionAffinity != ""
- yyq2588[7] = x.LoadBalancerIP != ""
- yyq2588[8] = len(x.LoadBalancerSourceRanges) != 0
- yyq2588[9] = x.ExternalName != ""
- var yynn2588 int
- if yyr2588 || yy2arr2588 {
+ yysep2593 := !z.EncBinary()
+ yy2arr2593 := z.EncBasicHandle().StructToArray
+ var yyq2593 [10]bool
+ _, _, _ = yysep2593, yyq2593, yy2arr2593
+ const yyr2593 bool = false
+ yyq2593[0] = len(x.Ports) != 0
+ yyq2593[1] = len(x.Selector) != 0
+ yyq2593[2] = x.ClusterIP != ""
+ yyq2593[3] = x.Type != ""
+ yyq2593[4] = len(x.ExternalIPs) != 0
+ yyq2593[5] = len(x.DeprecatedPublicIPs) != 0
+ yyq2593[6] = x.SessionAffinity != ""
+ yyq2593[7] = x.LoadBalancerIP != ""
+ yyq2593[8] = len(x.LoadBalancerSourceRanges) != 0
+ yyq2593[9] = x.ExternalName != ""
+ var yynn2593 int
+ if yyr2593 || yy2arr2593 {
r.EncodeArrayStart(10)
} else {
- yynn2588 = 0
- for _, b := range yyq2588 {
+ yynn2593 = 0
+ for _, b := range yyq2593 {
if b {
- yynn2588++
+ yynn2593++
}
}
- r.EncodeMapStart(yynn2588)
- yynn2588 = 0
+ r.EncodeMapStart(yynn2593)
+ yynn2593 = 0
}
- if yyr2588 || yy2arr2588 {
+ if yyr2593 || yy2arr2593 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2588[0] {
+ if yyq2593[0] {
if x.Ports == nil {
r.EncodeNil()
} else {
- yym2590 := z.EncBinary()
- _ = yym2590
+ yym2595 := z.EncBinary()
+ _ = yym2595
if false {
} else {
h.encSliceServicePort(([]ServicePort)(x.Ports), e)
@@ -34007,15 +34071,15 @@ func (x *ServiceSpec) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeNil()
}
} else {
- if yyq2588[0] {
+ if yyq2593[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("ports"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
if x.Ports == nil {
r.EncodeNil()
} else {
- yym2591 := z.EncBinary()
- _ = yym2591
+ yym2596 := z.EncBinary()
+ _ = yym2596
if false {
} else {
h.encSliceServicePort(([]ServicePort)(x.Ports), e)
@@ -34023,14 +34087,14 @@ func (x *ServiceSpec) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
- if yyr2588 || yy2arr2588 {
+ if yyr2593 || yy2arr2593 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2588[1] {
+ if yyq2593[1] {
if x.Selector == nil {
r.EncodeNil()
} else {
- yym2593 := z.EncBinary()
- _ = yym2593
+ yym2598 := z.EncBinary()
+ _ = yym2598
if false {
} else {
z.F.EncMapStringStringV(x.Selector, false, e)
@@ -34040,15 +34104,15 @@ func (x *ServiceSpec) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeNil()
}
} else {
- if yyq2588[1] {
+ if yyq2593[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("selector"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
if x.Selector == nil {
r.EncodeNil()
} else {
- yym2594 := z.EncBinary()
- _ = yym2594
+ yym2599 := z.EncBinary()
+ _ = yym2599
if false {
} else {
z.F.EncMapStringStringV(x.Selector, false, e)
@@ -34056,11 +34120,11 @@ func (x *ServiceSpec) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
- if yyr2588 || yy2arr2588 {
+ if yyr2593 || yy2arr2593 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2588[2] {
- yym2596 := z.EncBinary()
- _ = yym2596
+ if yyq2593[2] {
+ yym2601 := z.EncBinary()
+ _ = yym2601
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.ClusterIP))
@@ -34069,41 +34133,41 @@ func (x *ServiceSpec) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2588[2] {
+ if yyq2593[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("clusterIP"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym2597 := z.EncBinary()
- _ = yym2597
+ yym2602 := z.EncBinary()
+ _ = yym2602
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.ClusterIP))
}
}
}
- if yyr2588 || yy2arr2588 {
+ if yyr2593 || yy2arr2593 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2588[3] {
+ if yyq2593[3] {
x.Type.CodecEncodeSelf(e)
} else {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2588[3] {
+ if yyq2593[3] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("type"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
x.Type.CodecEncodeSelf(e)
}
}
- if yyr2588 || yy2arr2588 {
+ if yyr2593 || yy2arr2593 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2588[4] {
+ if yyq2593[4] {
if x.ExternalIPs == nil {
r.EncodeNil()
} else {
- yym2600 := z.EncBinary()
- _ = yym2600
+ yym2605 := z.EncBinary()
+ _ = yym2605
if false {
} else {
z.F.EncSliceStringV(x.ExternalIPs, false, e)
@@ -34113,15 +34177,15 @@ func (x *ServiceSpec) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeNil()
}
} else {
- if yyq2588[4] {
+ if yyq2593[4] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("externalIPs"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
if x.ExternalIPs == nil {
r.EncodeNil()
} else {
- yym2601 := z.EncBinary()
- _ = yym2601
+ yym2606 := z.EncBinary()
+ _ = yym2606
if false {
} else {
z.F.EncSliceStringV(x.ExternalIPs, false, e)
@@ -34129,14 +34193,14 @@ func (x *ServiceSpec) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
- if yyr2588 || yy2arr2588 {
+ if yyr2593 || yy2arr2593 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2588[5] {
+ if yyq2593[5] {
if x.DeprecatedPublicIPs == nil {
r.EncodeNil()
} else {
- yym2603 := z.EncBinary()
- _ = yym2603
+ yym2608 := z.EncBinary()
+ _ = yym2608
if false {
} else {
z.F.EncSliceStringV(x.DeprecatedPublicIPs, false, e)
@@ -34146,15 +34210,15 @@ func (x *ServiceSpec) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeNil()
}
} else {
- if yyq2588[5] {
+ if yyq2593[5] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("deprecatedPublicIPs"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
if x.DeprecatedPublicIPs == nil {
r.EncodeNil()
} else {
- yym2604 := z.EncBinary()
- _ = yym2604
+ yym2609 := z.EncBinary()
+ _ = yym2609
if false {
} else {
z.F.EncSliceStringV(x.DeprecatedPublicIPs, false, e)
@@ -34162,26 +34226,26 @@ func (x *ServiceSpec) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
- if yyr2588 || yy2arr2588 {
+ if yyr2593 || yy2arr2593 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2588[6] {
+ if yyq2593[6] {
x.SessionAffinity.CodecEncodeSelf(e)
} else {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2588[6] {
+ if yyq2593[6] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("sessionAffinity"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
x.SessionAffinity.CodecEncodeSelf(e)
}
}
- if yyr2588 || yy2arr2588 {
+ if yyr2593 || yy2arr2593 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2588[7] {
- yym2607 := z.EncBinary()
- _ = yym2607
+ if yyq2593[7] {
+ yym2612 := z.EncBinary()
+ _ = yym2612
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.LoadBalancerIP))
@@ -34190,26 +34254,26 @@ func (x *ServiceSpec) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2588[7] {
+ if yyq2593[7] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("loadBalancerIP"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym2608 := z.EncBinary()
- _ = yym2608
+ yym2613 := z.EncBinary()
+ _ = yym2613
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.LoadBalancerIP))
}
}
}
- if yyr2588 || yy2arr2588 {
+ if yyr2593 || yy2arr2593 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2588[8] {
+ if yyq2593[8] {
if x.LoadBalancerSourceRanges == nil {
r.EncodeNil()
} else {
- yym2610 := z.EncBinary()
- _ = yym2610
+ yym2615 := z.EncBinary()
+ _ = yym2615
if false {
} else {
z.F.EncSliceStringV(x.LoadBalancerSourceRanges, false, e)
@@ -34219,15 +34283,15 @@ func (x *ServiceSpec) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeNil()
}
} else {
- if yyq2588[8] {
+ if yyq2593[8] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("loadBalancerSourceRanges"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
if x.LoadBalancerSourceRanges == nil {
r.EncodeNil()
} else {
- yym2611 := z.EncBinary()
- _ = yym2611
+ yym2616 := z.EncBinary()
+ _ = yym2616
if false {
} else {
z.F.EncSliceStringV(x.LoadBalancerSourceRanges, false, e)
@@ -34235,11 +34299,11 @@ func (x *ServiceSpec) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
- if yyr2588 || yy2arr2588 {
+ if yyr2593 || yy2arr2593 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2588[9] {
- yym2613 := z.EncBinary()
- _ = yym2613
+ if yyq2593[9] {
+ yym2618 := z.EncBinary()
+ _ = yym2618
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.ExternalName))
@@ -34248,19 +34312,19 @@ func (x *ServiceSpec) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2588[9] {
+ if yyq2593[9] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("externalName"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym2614 := z.EncBinary()
- _ = yym2614
+ yym2619 := z.EncBinary()
+ _ = yym2619
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.ExternalName))
}
}
}
- if yyr2588 || yy2arr2588 {
+ if yyr2593 || yy2arr2593 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -34273,25 +34337,25 @@ func (x *ServiceSpec) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym2615 := z.DecBinary()
- _ = yym2615
+ yym2620 := z.DecBinary()
+ _ = yym2620
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct2616 := r.ContainerType()
- if yyct2616 == codecSelferValueTypeMap1234 {
- yyl2616 := r.ReadMapStart()
- if yyl2616 == 0 {
+ yyct2621 := r.ContainerType()
+ if yyct2621 == codecSelferValueTypeMap1234 {
+ yyl2621 := r.ReadMapStart()
+ if yyl2621 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl2616, d)
+ x.codecDecodeSelfFromMap(yyl2621, d)
}
- } else if yyct2616 == codecSelferValueTypeArray1234 {
- yyl2616 := r.ReadArrayStart()
- if yyl2616 == 0 {
+ } else if yyct2621 == codecSelferValueTypeArray1234 {
+ yyl2621 := r.ReadArrayStart()
+ if yyl2621 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl2616, d)
+ x.codecDecodeSelfFromArray(yyl2621, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -34303,12 +34367,12 @@ func (x *ServiceSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys2617Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys2617Slc
- var yyhl2617 bool = l >= 0
- for yyj2617 := 0; ; yyj2617++ {
- if yyhl2617 {
- if yyj2617 >= l {
+ var yys2622Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys2622Slc
+ var yyhl2622 bool = l >= 0
+ for yyj2622 := 0; ; yyj2622++ {
+ if yyhl2622 {
+ if yyj2622 >= l {
break
}
} else {
@@ -34317,32 +34381,32 @@ func (x *ServiceSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys2617Slc = r.DecodeBytes(yys2617Slc, true, true)
- yys2617 := string(yys2617Slc)
+ yys2622Slc = r.DecodeBytes(yys2622Slc, true, true)
+ yys2622 := string(yys2622Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys2617 {
+ switch yys2622 {
case "ports":
if r.TryDecodeAsNil() {
x.Ports = nil
} else {
- yyv2618 := &x.Ports
- yym2619 := z.DecBinary()
- _ = yym2619
+ yyv2623 := &x.Ports
+ yym2624 := z.DecBinary()
+ _ = yym2624
if false {
} else {
- h.decSliceServicePort((*[]ServicePort)(yyv2618), d)
+ h.decSliceServicePort((*[]ServicePort)(yyv2623), d)
}
}
case "selector":
if r.TryDecodeAsNil() {
x.Selector = nil
} else {
- yyv2620 := &x.Selector
- yym2621 := z.DecBinary()
- _ = yym2621
+ yyv2625 := &x.Selector
+ yym2626 := z.DecBinary()
+ _ = yym2626
if false {
} else {
- z.F.DecMapStringStringX(yyv2620, false, d)
+ z.F.DecMapStringStringX(yyv2625, false, d)
}
}
case "clusterIP":
@@ -34361,24 +34425,24 @@ func (x *ServiceSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.ExternalIPs = nil
} else {
- yyv2624 := &x.ExternalIPs
- yym2625 := z.DecBinary()
- _ = yym2625
+ yyv2629 := &x.ExternalIPs
+ yym2630 := z.DecBinary()
+ _ = yym2630
if false {
} else {
- z.F.DecSliceStringX(yyv2624, false, d)
+ z.F.DecSliceStringX(yyv2629, false, d)
}
}
case "deprecatedPublicIPs":
if r.TryDecodeAsNil() {
x.DeprecatedPublicIPs = nil
} else {
- yyv2626 := &x.DeprecatedPublicIPs
- yym2627 := z.DecBinary()
- _ = yym2627
+ yyv2631 := &x.DeprecatedPublicIPs
+ yym2632 := z.DecBinary()
+ _ = yym2632
if false {
} else {
- z.F.DecSliceStringX(yyv2626, false, d)
+ z.F.DecSliceStringX(yyv2631, false, d)
}
}
case "sessionAffinity":
@@ -34397,12 +34461,12 @@ func (x *ServiceSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.LoadBalancerSourceRanges = nil
} else {
- yyv2630 := &x.LoadBalancerSourceRanges
- yym2631 := z.DecBinary()
- _ = yym2631
+ yyv2635 := &x.LoadBalancerSourceRanges
+ yym2636 := z.DecBinary()
+ _ = yym2636
if false {
} else {
- z.F.DecSliceStringX(yyv2630, false, d)
+ z.F.DecSliceStringX(yyv2635, false, d)
}
}
case "externalName":
@@ -34412,9 +34476,9 @@ func (x *ServiceSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
x.ExternalName = string(r.DecodeString())
}
default:
- z.DecStructFieldNotFound(-1, yys2617)
- } // end switch yys2617
- } // end for yyj2617
+ z.DecStructFieldNotFound(-1, yys2622)
+ } // end switch yys2622
+ } // end for yyj2622
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -34422,16 +34486,16 @@ func (x *ServiceSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj2633 int
- var yyb2633 bool
- var yyhl2633 bool = l >= 0
- yyj2633++
- if yyhl2633 {
- yyb2633 = yyj2633 > l
+ var yyj2638 int
+ var yyb2638 bool
+ var yyhl2638 bool = l >= 0
+ yyj2638++
+ if yyhl2638 {
+ yyb2638 = yyj2638 > l
} else {
- yyb2633 = r.CheckBreak()
+ yyb2638 = r.CheckBreak()
}
- if yyb2633 {
+ if yyb2638 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -34439,21 +34503,21 @@ func (x *ServiceSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Ports = nil
} else {
- yyv2634 := &x.Ports
- yym2635 := z.DecBinary()
- _ = yym2635
+ yyv2639 := &x.Ports
+ yym2640 := z.DecBinary()
+ _ = yym2640
if false {
} else {
- h.decSliceServicePort((*[]ServicePort)(yyv2634), d)
+ h.decSliceServicePort((*[]ServicePort)(yyv2639), d)
}
}
- yyj2633++
- if yyhl2633 {
- yyb2633 = yyj2633 > l
+ yyj2638++
+ if yyhl2638 {
+ yyb2638 = yyj2638 > l
} else {
- yyb2633 = r.CheckBreak()
+ yyb2638 = r.CheckBreak()
}
- if yyb2633 {
+ if yyb2638 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -34461,21 +34525,21 @@ func (x *ServiceSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Selector = nil
} else {
- yyv2636 := &x.Selector
- yym2637 := z.DecBinary()
- _ = yym2637
+ yyv2641 := &x.Selector
+ yym2642 := z.DecBinary()
+ _ = yym2642
if false {
} else {
- z.F.DecMapStringStringX(yyv2636, false, d)
+ z.F.DecMapStringStringX(yyv2641, false, d)
}
}
- yyj2633++
- if yyhl2633 {
- yyb2633 = yyj2633 > l
+ yyj2638++
+ if yyhl2638 {
+ yyb2638 = yyj2638 > l
} else {
- yyb2633 = r.CheckBreak()
+ yyb2638 = r.CheckBreak()
}
- if yyb2633 {
+ if yyb2638 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -34485,13 +34549,13 @@ func (x *ServiceSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.ClusterIP = string(r.DecodeString())
}
- yyj2633++
- if yyhl2633 {
- yyb2633 = yyj2633 > l
+ yyj2638++
+ if yyhl2638 {
+ yyb2638 = yyj2638 > l
} else {
- yyb2633 = r.CheckBreak()
+ yyb2638 = r.CheckBreak()
}
- if yyb2633 {
+ if yyb2638 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -34501,13 +34565,13 @@ func (x *ServiceSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Type = ServiceType(r.DecodeString())
}
- yyj2633++
- if yyhl2633 {
- yyb2633 = yyj2633 > l
+ yyj2638++
+ if yyhl2638 {
+ yyb2638 = yyj2638 > l
} else {
- yyb2633 = r.CheckBreak()
+ yyb2638 = r.CheckBreak()
}
- if yyb2633 {
+ if yyb2638 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -34515,21 +34579,21 @@ func (x *ServiceSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.ExternalIPs = nil
} else {
- yyv2640 := &x.ExternalIPs
- yym2641 := z.DecBinary()
- _ = yym2641
+ yyv2645 := &x.ExternalIPs
+ yym2646 := z.DecBinary()
+ _ = yym2646
if false {
} else {
- z.F.DecSliceStringX(yyv2640, false, d)
+ z.F.DecSliceStringX(yyv2645, false, d)
}
}
- yyj2633++
- if yyhl2633 {
- yyb2633 = yyj2633 > l
+ yyj2638++
+ if yyhl2638 {
+ yyb2638 = yyj2638 > l
} else {
- yyb2633 = r.CheckBreak()
+ yyb2638 = r.CheckBreak()
}
- if yyb2633 {
+ if yyb2638 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -34537,21 +34601,21 @@ func (x *ServiceSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.DeprecatedPublicIPs = nil
} else {
- yyv2642 := &x.DeprecatedPublicIPs
- yym2643 := z.DecBinary()
- _ = yym2643
+ yyv2647 := &x.DeprecatedPublicIPs
+ yym2648 := z.DecBinary()
+ _ = yym2648
if false {
} else {
- z.F.DecSliceStringX(yyv2642, false, d)
+ z.F.DecSliceStringX(yyv2647, false, d)
}
}
- yyj2633++
- if yyhl2633 {
- yyb2633 = yyj2633 > l
+ yyj2638++
+ if yyhl2638 {
+ yyb2638 = yyj2638 > l
} else {
- yyb2633 = r.CheckBreak()
+ yyb2638 = r.CheckBreak()
}
- if yyb2633 {
+ if yyb2638 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -34561,13 +34625,13 @@ func (x *ServiceSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.SessionAffinity = ServiceAffinity(r.DecodeString())
}
- yyj2633++
- if yyhl2633 {
- yyb2633 = yyj2633 > l
+ yyj2638++
+ if yyhl2638 {
+ yyb2638 = yyj2638 > l
} else {
- yyb2633 = r.CheckBreak()
+ yyb2638 = r.CheckBreak()
}
- if yyb2633 {
+ if yyb2638 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -34577,13 +34641,13 @@ func (x *ServiceSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.LoadBalancerIP = string(r.DecodeString())
}
- yyj2633++
- if yyhl2633 {
- yyb2633 = yyj2633 > l
+ yyj2638++
+ if yyhl2638 {
+ yyb2638 = yyj2638 > l
} else {
- yyb2633 = r.CheckBreak()
+ yyb2638 = r.CheckBreak()
}
- if yyb2633 {
+ if yyb2638 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -34591,21 +34655,21 @@ func (x *ServiceSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.LoadBalancerSourceRanges = nil
} else {
- yyv2646 := &x.LoadBalancerSourceRanges
- yym2647 := z.DecBinary()
- _ = yym2647
+ yyv2651 := &x.LoadBalancerSourceRanges
+ yym2652 := z.DecBinary()
+ _ = yym2652
if false {
} else {
- z.F.DecSliceStringX(yyv2646, false, d)
+ z.F.DecSliceStringX(yyv2651, false, d)
}
}
- yyj2633++
- if yyhl2633 {
- yyb2633 = yyj2633 > l
+ yyj2638++
+ if yyhl2638 {
+ yyb2638 = yyj2638 > l
} else {
- yyb2633 = r.CheckBreak()
+ yyb2638 = r.CheckBreak()
}
- if yyb2633 {
+ if yyb2638 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -34616,17 +34680,17 @@ func (x *ServiceSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
x.ExternalName = string(r.DecodeString())
}
for {
- yyj2633++
- if yyhl2633 {
- yyb2633 = yyj2633 > l
+ yyj2638++
+ if yyhl2638 {
+ yyb2638 = yyj2638 > l
} else {
- yyb2633 = r.CheckBreak()
+ yyb2638 = r.CheckBreak()
}
- if yyb2633 {
+ if yyb2638 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj2633-1, "")
+ z.DecStructFieldNotFound(yyj2638-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -34638,38 +34702,38 @@ func (x *ServicePort) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym2649 := z.EncBinary()
- _ = yym2649
+ yym2654 := z.EncBinary()
+ _ = yym2654
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep2650 := !z.EncBinary()
- yy2arr2650 := z.EncBasicHandle().StructToArray
- var yyq2650 [5]bool
- _, _, _ = yysep2650, yyq2650, yy2arr2650
- const yyr2650 bool = false
- yyq2650[0] = x.Name != ""
- yyq2650[1] = x.Protocol != ""
- yyq2650[3] = true
- yyq2650[4] = x.NodePort != 0
- var yynn2650 int
- if yyr2650 || yy2arr2650 {
+ yysep2655 := !z.EncBinary()
+ yy2arr2655 := z.EncBasicHandle().StructToArray
+ var yyq2655 [5]bool
+ _, _, _ = yysep2655, yyq2655, yy2arr2655
+ const yyr2655 bool = false
+ yyq2655[0] = x.Name != ""
+ yyq2655[1] = x.Protocol != ""
+ yyq2655[3] = true
+ yyq2655[4] = x.NodePort != 0
+ var yynn2655 int
+ if yyr2655 || yy2arr2655 {
r.EncodeArrayStart(5)
} else {
- yynn2650 = 1
- for _, b := range yyq2650 {
+ yynn2655 = 1
+ for _, b := range yyq2655 {
if b {
- yynn2650++
+ yynn2655++
}
}
- r.EncodeMapStart(yynn2650)
- yynn2650 = 0
+ r.EncodeMapStart(yynn2655)
+ yynn2655 = 0
}
- if yyr2650 || yy2arr2650 {
+ if yyr2655 || yy2arr2655 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2650[0] {
- yym2652 := z.EncBinary()
- _ = yym2652
+ if yyq2655[0] {
+ yym2657 := z.EncBinary()
+ _ = yym2657
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Name))
@@ -34678,37 +34742,37 @@ func (x *ServicePort) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2650[0] {
+ if yyq2655[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("name"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym2653 := z.EncBinary()
- _ = yym2653
+ yym2658 := z.EncBinary()
+ _ = yym2658
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Name))
}
}
}
- if yyr2650 || yy2arr2650 {
+ if yyr2655 || yy2arr2655 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2650[1] {
+ if yyq2655[1] {
x.Protocol.CodecEncodeSelf(e)
} else {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2650[1] {
+ if yyq2655[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("protocol"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
x.Protocol.CodecEncodeSelf(e)
}
}
- if yyr2650 || yy2arr2650 {
+ if yyr2655 || yy2arr2655 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym2656 := z.EncBinary()
- _ = yym2656
+ yym2661 := z.EncBinary()
+ _ = yym2661
if false {
} else {
r.EncodeInt(int64(x.Port))
@@ -34717,51 +34781,51 @@ func (x *ServicePort) CodecEncodeSelf(e *codec1978.Encoder) {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("port"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym2657 := z.EncBinary()
- _ = yym2657
+ yym2662 := z.EncBinary()
+ _ = yym2662
if false {
} else {
r.EncodeInt(int64(x.Port))
}
}
- if yyr2650 || yy2arr2650 {
+ if yyr2655 || yy2arr2655 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2650[3] {
- yy2659 := &x.TargetPort
- yym2660 := z.EncBinary()
- _ = yym2660
+ if yyq2655[3] {
+ yy2664 := &x.TargetPort
+ yym2665 := z.EncBinary()
+ _ = yym2665
if false {
- } else if z.HasExtensions() && z.EncExt(yy2659) {
- } else if !yym2660 && z.IsJSONHandle() {
- z.EncJSONMarshal(yy2659)
+ } else if z.HasExtensions() && z.EncExt(yy2664) {
+ } else if !yym2665 && z.IsJSONHandle() {
+ z.EncJSONMarshal(yy2664)
} else {
- z.EncFallback(yy2659)
+ z.EncFallback(yy2664)
}
} else {
r.EncodeNil()
}
} else {
- if yyq2650[3] {
+ if yyq2655[3] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("targetPort"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy2661 := &x.TargetPort
- yym2662 := z.EncBinary()
- _ = yym2662
+ yy2666 := &x.TargetPort
+ yym2667 := z.EncBinary()
+ _ = yym2667
if false {
- } else if z.HasExtensions() && z.EncExt(yy2661) {
- } else if !yym2662 && z.IsJSONHandle() {
- z.EncJSONMarshal(yy2661)
+ } else if z.HasExtensions() && z.EncExt(yy2666) {
+ } else if !yym2667 && z.IsJSONHandle() {
+ z.EncJSONMarshal(yy2666)
} else {
- z.EncFallback(yy2661)
+ z.EncFallback(yy2666)
}
}
}
- if yyr2650 || yy2arr2650 {
+ if yyr2655 || yy2arr2655 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2650[4] {
- yym2664 := z.EncBinary()
- _ = yym2664
+ if yyq2655[4] {
+ yym2669 := z.EncBinary()
+ _ = yym2669
if false {
} else {
r.EncodeInt(int64(x.NodePort))
@@ -34770,19 +34834,19 @@ func (x *ServicePort) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeInt(0)
}
} else {
- if yyq2650[4] {
+ if yyq2655[4] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("nodePort"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym2665 := z.EncBinary()
- _ = yym2665
+ yym2670 := z.EncBinary()
+ _ = yym2670
if false {
} else {
r.EncodeInt(int64(x.NodePort))
}
}
}
- if yyr2650 || yy2arr2650 {
+ if yyr2655 || yy2arr2655 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -34795,25 +34859,25 @@ func (x *ServicePort) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym2666 := z.DecBinary()
- _ = yym2666
+ yym2671 := z.DecBinary()
+ _ = yym2671
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct2667 := r.ContainerType()
- if yyct2667 == codecSelferValueTypeMap1234 {
- yyl2667 := r.ReadMapStart()
- if yyl2667 == 0 {
+ yyct2672 := r.ContainerType()
+ if yyct2672 == codecSelferValueTypeMap1234 {
+ yyl2672 := r.ReadMapStart()
+ if yyl2672 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl2667, d)
+ x.codecDecodeSelfFromMap(yyl2672, d)
}
- } else if yyct2667 == codecSelferValueTypeArray1234 {
- yyl2667 := r.ReadArrayStart()
- if yyl2667 == 0 {
+ } else if yyct2672 == codecSelferValueTypeArray1234 {
+ yyl2672 := r.ReadArrayStart()
+ if yyl2672 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl2667, d)
+ x.codecDecodeSelfFromArray(yyl2672, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -34825,12 +34889,12 @@ func (x *ServicePort) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys2668Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys2668Slc
- var yyhl2668 bool = l >= 0
- for yyj2668 := 0; ; yyj2668++ {
- if yyhl2668 {
- if yyj2668 >= l {
+ var yys2673Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys2673Slc
+ var yyhl2673 bool = l >= 0
+ for yyj2673 := 0; ; yyj2673++ {
+ if yyhl2673 {
+ if yyj2673 >= l {
break
}
} else {
@@ -34839,10 +34903,10 @@ func (x *ServicePort) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys2668Slc = r.DecodeBytes(yys2668Slc, true, true)
- yys2668 := string(yys2668Slc)
+ yys2673Slc = r.DecodeBytes(yys2673Slc, true, true)
+ yys2673 := string(yys2673Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys2668 {
+ switch yys2673 {
case "name":
if r.TryDecodeAsNil() {
x.Name = ""
@@ -34865,15 +34929,15 @@ func (x *ServicePort) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.TargetPort = pkg4_intstr.IntOrString{}
} else {
- yyv2672 := &x.TargetPort
- yym2673 := z.DecBinary()
- _ = yym2673
+ yyv2677 := &x.TargetPort
+ yym2678 := z.DecBinary()
+ _ = yym2678
if false {
- } else if z.HasExtensions() && z.DecExt(yyv2672) {
- } else if !yym2673 && z.IsJSONHandle() {
- z.DecJSONUnmarshal(yyv2672)
+ } else if z.HasExtensions() && z.DecExt(yyv2677) {
+ } else if !yym2678 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv2677)
} else {
- z.DecFallback(yyv2672, false)
+ z.DecFallback(yyv2677, false)
}
}
case "nodePort":
@@ -34883,9 +34947,9 @@ func (x *ServicePort) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
x.NodePort = int32(r.DecodeInt(32))
}
default:
- z.DecStructFieldNotFound(-1, yys2668)
- } // end switch yys2668
- } // end for yyj2668
+ z.DecStructFieldNotFound(-1, yys2673)
+ } // end switch yys2673
+ } // end for yyj2673
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -34893,16 +34957,16 @@ func (x *ServicePort) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj2675 int
- var yyb2675 bool
- var yyhl2675 bool = l >= 0
- yyj2675++
- if yyhl2675 {
- yyb2675 = yyj2675 > l
+ var yyj2680 int
+ var yyb2680 bool
+ var yyhl2680 bool = l >= 0
+ yyj2680++
+ if yyhl2680 {
+ yyb2680 = yyj2680 > l
} else {
- yyb2675 = r.CheckBreak()
+ yyb2680 = r.CheckBreak()
}
- if yyb2675 {
+ if yyb2680 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -34912,13 +34976,13 @@ func (x *ServicePort) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Name = string(r.DecodeString())
}
- yyj2675++
- if yyhl2675 {
- yyb2675 = yyj2675 > l
+ yyj2680++
+ if yyhl2680 {
+ yyb2680 = yyj2680 > l
} else {
- yyb2675 = r.CheckBreak()
+ yyb2680 = r.CheckBreak()
}
- if yyb2675 {
+ if yyb2680 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -34928,13 +34992,13 @@ func (x *ServicePort) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Protocol = Protocol(r.DecodeString())
}
- yyj2675++
- if yyhl2675 {
- yyb2675 = yyj2675 > l
+ yyj2680++
+ if yyhl2680 {
+ yyb2680 = yyj2680 > l
} else {
- yyb2675 = r.CheckBreak()
+ yyb2680 = r.CheckBreak()
}
- if yyb2675 {
+ if yyb2680 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -34944,13 +35008,13 @@ func (x *ServicePort) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Port = int32(r.DecodeInt(32))
}
- yyj2675++
- if yyhl2675 {
- yyb2675 = yyj2675 > l
+ yyj2680++
+ if yyhl2680 {
+ yyb2680 = yyj2680 > l
} else {
- yyb2675 = r.CheckBreak()
+ yyb2680 = r.CheckBreak()
}
- if yyb2675 {
+ if yyb2680 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -34958,24 +35022,24 @@ func (x *ServicePort) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.TargetPort = pkg4_intstr.IntOrString{}
} else {
- yyv2679 := &x.TargetPort
- yym2680 := z.DecBinary()
- _ = yym2680
+ yyv2684 := &x.TargetPort
+ yym2685 := z.DecBinary()
+ _ = yym2685
if false {
- } else if z.HasExtensions() && z.DecExt(yyv2679) {
- } else if !yym2680 && z.IsJSONHandle() {
- z.DecJSONUnmarshal(yyv2679)
+ } else if z.HasExtensions() && z.DecExt(yyv2684) {
+ } else if !yym2685 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv2684)
} else {
- z.DecFallback(yyv2679, false)
+ z.DecFallback(yyv2684, false)
}
}
- yyj2675++
- if yyhl2675 {
- yyb2675 = yyj2675 > l
+ yyj2680++
+ if yyhl2680 {
+ yyb2680 = yyj2680 > l
} else {
- yyb2675 = r.CheckBreak()
+ yyb2680 = r.CheckBreak()
}
- if yyb2675 {
+ if yyb2680 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -34986,17 +35050,17 @@ func (x *ServicePort) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
x.NodePort = int32(r.DecodeInt(32))
}
for {
- yyj2675++
- if yyhl2675 {
- yyb2675 = yyj2675 > l
+ yyj2680++
+ if yyhl2680 {
+ yyb2680 = yyj2680 > l
} else {
- yyb2675 = r.CheckBreak()
+ yyb2680 = r.CheckBreak()
}
- if yyb2675 {
+ if yyb2680 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj2675-1, "")
+ z.DecStructFieldNotFound(yyj2680-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -35008,39 +35072,39 @@ func (x *Service) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym2682 := z.EncBinary()
- _ = yym2682
+ yym2687 := z.EncBinary()
+ _ = yym2687
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep2683 := !z.EncBinary()
- yy2arr2683 := z.EncBasicHandle().StructToArray
- var yyq2683 [5]bool
- _, _, _ = yysep2683, yyq2683, yy2arr2683
- const yyr2683 bool = false
- yyq2683[0] = x.Kind != ""
- yyq2683[1] = x.APIVersion != ""
- yyq2683[2] = true
- yyq2683[3] = true
- yyq2683[4] = true
- var yynn2683 int
- if yyr2683 || yy2arr2683 {
+ yysep2688 := !z.EncBinary()
+ yy2arr2688 := z.EncBasicHandle().StructToArray
+ var yyq2688 [5]bool
+ _, _, _ = yysep2688, yyq2688, yy2arr2688
+ const yyr2688 bool = false
+ yyq2688[0] = x.Kind != ""
+ yyq2688[1] = x.APIVersion != ""
+ yyq2688[2] = true
+ yyq2688[3] = true
+ yyq2688[4] = true
+ var yynn2688 int
+ if yyr2688 || yy2arr2688 {
r.EncodeArrayStart(5)
} else {
- yynn2683 = 0
- for _, b := range yyq2683 {
+ yynn2688 = 0
+ for _, b := range yyq2688 {
if b {
- yynn2683++
+ yynn2688++
}
}
- r.EncodeMapStart(yynn2683)
- yynn2683 = 0
+ r.EncodeMapStart(yynn2688)
+ yynn2688 = 0
}
- if yyr2683 || yy2arr2683 {
+ if yyr2688 || yy2arr2688 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2683[0] {
- yym2685 := z.EncBinary()
- _ = yym2685
+ if yyq2688[0] {
+ yym2690 := z.EncBinary()
+ _ = yym2690
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
@@ -35049,23 +35113,23 @@ func (x *Service) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2683[0] {
+ if yyq2688[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("kind"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym2686 := z.EncBinary()
- _ = yym2686
+ yym2691 := z.EncBinary()
+ _ = yym2691
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
}
}
}
- if yyr2683 || yy2arr2683 {
+ if yyr2688 || yy2arr2688 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2683[1] {
- yym2688 := z.EncBinary()
- _ = yym2688
+ if yyq2688[1] {
+ yym2693 := z.EncBinary()
+ _ = yym2693
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
@@ -35074,70 +35138,70 @@ func (x *Service) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2683[1] {
+ if yyq2688[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym2689 := z.EncBinary()
- _ = yym2689
+ yym2694 := z.EncBinary()
+ _ = yym2694
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
}
}
}
- if yyr2683 || yy2arr2683 {
+ if yyr2688 || yy2arr2688 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2683[2] {
- yy2691 := &x.ObjectMeta
- yy2691.CodecEncodeSelf(e)
+ if yyq2688[2] {
+ yy2696 := &x.ObjectMeta
+ yy2696.CodecEncodeSelf(e)
} else {
r.EncodeNil()
}
} else {
- if yyq2683[2] {
+ if yyq2688[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("metadata"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy2692 := &x.ObjectMeta
- yy2692.CodecEncodeSelf(e)
+ yy2697 := &x.ObjectMeta
+ yy2697.CodecEncodeSelf(e)
}
}
- if yyr2683 || yy2arr2683 {
+ if yyr2688 || yy2arr2688 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2683[3] {
- yy2694 := &x.Spec
- yy2694.CodecEncodeSelf(e)
+ if yyq2688[3] {
+ yy2699 := &x.Spec
+ yy2699.CodecEncodeSelf(e)
} else {
r.EncodeNil()
}
} else {
- if yyq2683[3] {
+ if yyq2688[3] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("spec"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy2695 := &x.Spec
- yy2695.CodecEncodeSelf(e)
+ yy2700 := &x.Spec
+ yy2700.CodecEncodeSelf(e)
}
}
- if yyr2683 || yy2arr2683 {
+ if yyr2688 || yy2arr2688 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2683[4] {
- yy2697 := &x.Status
- yy2697.CodecEncodeSelf(e)
+ if yyq2688[4] {
+ yy2702 := &x.Status
+ yy2702.CodecEncodeSelf(e)
} else {
r.EncodeNil()
}
} else {
- if yyq2683[4] {
+ if yyq2688[4] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("status"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy2698 := &x.Status
- yy2698.CodecEncodeSelf(e)
+ yy2703 := &x.Status
+ yy2703.CodecEncodeSelf(e)
}
}
- if yyr2683 || yy2arr2683 {
+ if yyr2688 || yy2arr2688 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -35150,25 +35214,25 @@ func (x *Service) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym2699 := z.DecBinary()
- _ = yym2699
+ yym2704 := z.DecBinary()
+ _ = yym2704
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct2700 := r.ContainerType()
- if yyct2700 == codecSelferValueTypeMap1234 {
- yyl2700 := r.ReadMapStart()
- if yyl2700 == 0 {
+ yyct2705 := r.ContainerType()
+ if yyct2705 == codecSelferValueTypeMap1234 {
+ yyl2705 := r.ReadMapStart()
+ if yyl2705 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl2700, d)
+ x.codecDecodeSelfFromMap(yyl2705, d)
}
- } else if yyct2700 == codecSelferValueTypeArray1234 {
- yyl2700 := r.ReadArrayStart()
- if yyl2700 == 0 {
+ } else if yyct2705 == codecSelferValueTypeArray1234 {
+ yyl2705 := r.ReadArrayStart()
+ if yyl2705 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl2700, d)
+ x.codecDecodeSelfFromArray(yyl2705, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -35180,12 +35244,12 @@ func (x *Service) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys2701Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys2701Slc
- var yyhl2701 bool = l >= 0
- for yyj2701 := 0; ; yyj2701++ {
- if yyhl2701 {
- if yyj2701 >= l {
+ var yys2706Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys2706Slc
+ var yyhl2706 bool = l >= 0
+ for yyj2706 := 0; ; yyj2706++ {
+ if yyhl2706 {
+ if yyj2706 >= l {
break
}
} else {
@@ -35194,10 +35258,10 @@ func (x *Service) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys2701Slc = r.DecodeBytes(yys2701Slc, true, true)
- yys2701 := string(yys2701Slc)
+ yys2706Slc = r.DecodeBytes(yys2706Slc, true, true)
+ yys2706 := string(yys2706Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys2701 {
+ switch yys2706 {
case "kind":
if r.TryDecodeAsNil() {
x.Kind = ""
@@ -35214,27 +35278,27 @@ func (x *Service) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.ObjectMeta = ObjectMeta{}
} else {
- yyv2704 := &x.ObjectMeta
- yyv2704.CodecDecodeSelf(d)
+ yyv2709 := &x.ObjectMeta
+ yyv2709.CodecDecodeSelf(d)
}
case "spec":
if r.TryDecodeAsNil() {
x.Spec = ServiceSpec{}
} else {
- yyv2705 := &x.Spec
- yyv2705.CodecDecodeSelf(d)
+ yyv2710 := &x.Spec
+ yyv2710.CodecDecodeSelf(d)
}
case "status":
if r.TryDecodeAsNil() {
x.Status = ServiceStatus{}
} else {
- yyv2706 := &x.Status
- yyv2706.CodecDecodeSelf(d)
+ yyv2711 := &x.Status
+ yyv2711.CodecDecodeSelf(d)
}
default:
- z.DecStructFieldNotFound(-1, yys2701)
- } // end switch yys2701
- } // end for yyj2701
+ z.DecStructFieldNotFound(-1, yys2706)
+ } // end switch yys2706
+ } // end for yyj2706
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -35242,16 +35306,16 @@ func (x *Service) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj2707 int
- var yyb2707 bool
- var yyhl2707 bool = l >= 0
- yyj2707++
- if yyhl2707 {
- yyb2707 = yyj2707 > l
+ var yyj2712 int
+ var yyb2712 bool
+ var yyhl2712 bool = l >= 0
+ yyj2712++
+ if yyhl2712 {
+ yyb2712 = yyj2712 > l
} else {
- yyb2707 = r.CheckBreak()
+ yyb2712 = r.CheckBreak()
}
- if yyb2707 {
+ if yyb2712 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -35261,13 +35325,13 @@ func (x *Service) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Kind = string(r.DecodeString())
}
- yyj2707++
- if yyhl2707 {
- yyb2707 = yyj2707 > l
+ yyj2712++
+ if yyhl2712 {
+ yyb2712 = yyj2712 > l
} else {
- yyb2707 = r.CheckBreak()
+ yyb2712 = r.CheckBreak()
}
- if yyb2707 {
+ if yyb2712 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -35277,13 +35341,13 @@ func (x *Service) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.APIVersion = string(r.DecodeString())
}
- yyj2707++
- if yyhl2707 {
- yyb2707 = yyj2707 > l
+ yyj2712++
+ if yyhl2712 {
+ yyb2712 = yyj2712 > l
} else {
- yyb2707 = r.CheckBreak()
+ yyb2712 = r.CheckBreak()
}
- if yyb2707 {
+ if yyb2712 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -35291,16 +35355,16 @@ func (x *Service) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.ObjectMeta = ObjectMeta{}
} else {
- yyv2710 := &x.ObjectMeta
- yyv2710.CodecDecodeSelf(d)
+ yyv2715 := &x.ObjectMeta
+ yyv2715.CodecDecodeSelf(d)
}
- yyj2707++
- if yyhl2707 {
- yyb2707 = yyj2707 > l
+ yyj2712++
+ if yyhl2712 {
+ yyb2712 = yyj2712 > l
} else {
- yyb2707 = r.CheckBreak()
+ yyb2712 = r.CheckBreak()
}
- if yyb2707 {
+ if yyb2712 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -35308,16 +35372,16 @@ func (x *Service) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Spec = ServiceSpec{}
} else {
- yyv2711 := &x.Spec
- yyv2711.CodecDecodeSelf(d)
+ yyv2716 := &x.Spec
+ yyv2716.CodecDecodeSelf(d)
}
- yyj2707++
- if yyhl2707 {
- yyb2707 = yyj2707 > l
+ yyj2712++
+ if yyhl2712 {
+ yyb2712 = yyj2712 > l
} else {
- yyb2707 = r.CheckBreak()
+ yyb2712 = r.CheckBreak()
}
- if yyb2707 {
+ if yyb2712 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -35325,21 +35389,21 @@ func (x *Service) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Status = ServiceStatus{}
} else {
- yyv2712 := &x.Status
- yyv2712.CodecDecodeSelf(d)
+ yyv2717 := &x.Status
+ yyv2717.CodecDecodeSelf(d)
}
for {
- yyj2707++
- if yyhl2707 {
- yyb2707 = yyj2707 > l
+ yyj2712++
+ if yyhl2712 {
+ yyb2712 = yyj2712 > l
} else {
- yyb2707 = r.CheckBreak()
+ yyb2712 = r.CheckBreak()
}
- if yyb2707 {
+ if yyb2712 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj2707-1, "")
+ z.DecStructFieldNotFound(yyj2712-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -35351,37 +35415,37 @@ func (x *ServiceList) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym2713 := z.EncBinary()
- _ = yym2713
+ yym2718 := z.EncBinary()
+ _ = yym2718
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep2714 := !z.EncBinary()
- yy2arr2714 := z.EncBasicHandle().StructToArray
- var yyq2714 [4]bool
- _, _, _ = yysep2714, yyq2714, yy2arr2714
- const yyr2714 bool = false
- yyq2714[0] = x.Kind != ""
- yyq2714[1] = x.APIVersion != ""
- yyq2714[2] = true
- var yynn2714 int
- if yyr2714 || yy2arr2714 {
+ yysep2719 := !z.EncBinary()
+ yy2arr2719 := z.EncBasicHandle().StructToArray
+ var yyq2719 [4]bool
+ _, _, _ = yysep2719, yyq2719, yy2arr2719
+ const yyr2719 bool = false
+ yyq2719[0] = x.Kind != ""
+ yyq2719[1] = x.APIVersion != ""
+ yyq2719[2] = true
+ var yynn2719 int
+ if yyr2719 || yy2arr2719 {
r.EncodeArrayStart(4)
} else {
- yynn2714 = 1
- for _, b := range yyq2714 {
+ yynn2719 = 1
+ for _, b := range yyq2719 {
if b {
- yynn2714++
+ yynn2719++
}
}
- r.EncodeMapStart(yynn2714)
- yynn2714 = 0
+ r.EncodeMapStart(yynn2719)
+ yynn2719 = 0
}
- if yyr2714 || yy2arr2714 {
+ if yyr2719 || yy2arr2719 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2714[0] {
- yym2716 := z.EncBinary()
- _ = yym2716
+ if yyq2719[0] {
+ yym2721 := z.EncBinary()
+ _ = yym2721
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
@@ -35390,23 +35454,23 @@ func (x *ServiceList) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2714[0] {
+ if yyq2719[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("kind"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym2717 := z.EncBinary()
- _ = yym2717
+ yym2722 := z.EncBinary()
+ _ = yym2722
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
}
}
}
- if yyr2714 || yy2arr2714 {
+ if yyr2719 || yy2arr2719 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2714[1] {
- yym2719 := z.EncBinary()
- _ = yym2719
+ if yyq2719[1] {
+ yym2724 := z.EncBinary()
+ _ = yym2724
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
@@ -35415,54 +35479,54 @@ func (x *ServiceList) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2714[1] {
+ if yyq2719[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym2720 := z.EncBinary()
- _ = yym2720
+ yym2725 := z.EncBinary()
+ _ = yym2725
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
}
}
}
- if yyr2714 || yy2arr2714 {
+ if yyr2719 || yy2arr2719 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2714[2] {
- yy2722 := &x.ListMeta
- yym2723 := z.EncBinary()
- _ = yym2723
+ if yyq2719[2] {
+ yy2727 := &x.ListMeta
+ yym2728 := z.EncBinary()
+ _ = yym2728
if false {
- } else if z.HasExtensions() && z.EncExt(yy2722) {
+ } else if z.HasExtensions() && z.EncExt(yy2727) {
} else {
- z.EncFallback(yy2722)
+ z.EncFallback(yy2727)
}
} else {
r.EncodeNil()
}
} else {
- if yyq2714[2] {
+ if yyq2719[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("metadata"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy2724 := &x.ListMeta
- yym2725 := z.EncBinary()
- _ = yym2725
+ yy2729 := &x.ListMeta
+ yym2730 := z.EncBinary()
+ _ = yym2730
if false {
- } else if z.HasExtensions() && z.EncExt(yy2724) {
+ } else if z.HasExtensions() && z.EncExt(yy2729) {
} else {
- z.EncFallback(yy2724)
+ z.EncFallback(yy2729)
}
}
}
- if yyr2714 || yy2arr2714 {
+ if yyr2719 || yy2arr2719 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if x.Items == nil {
r.EncodeNil()
} else {
- yym2727 := z.EncBinary()
- _ = yym2727
+ yym2732 := z.EncBinary()
+ _ = yym2732
if false {
} else {
h.encSliceService(([]Service)(x.Items), e)
@@ -35475,15 +35539,15 @@ func (x *ServiceList) CodecEncodeSelf(e *codec1978.Encoder) {
if x.Items == nil {
r.EncodeNil()
} else {
- yym2728 := z.EncBinary()
- _ = yym2728
+ yym2733 := z.EncBinary()
+ _ = yym2733
if false {
} else {
h.encSliceService(([]Service)(x.Items), e)
}
}
}
- if yyr2714 || yy2arr2714 {
+ if yyr2719 || yy2arr2719 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -35496,25 +35560,25 @@ func (x *ServiceList) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym2729 := z.DecBinary()
- _ = yym2729
+ yym2734 := z.DecBinary()
+ _ = yym2734
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct2730 := r.ContainerType()
- if yyct2730 == codecSelferValueTypeMap1234 {
- yyl2730 := r.ReadMapStart()
- if yyl2730 == 0 {
+ yyct2735 := r.ContainerType()
+ if yyct2735 == codecSelferValueTypeMap1234 {
+ yyl2735 := r.ReadMapStart()
+ if yyl2735 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl2730, d)
+ x.codecDecodeSelfFromMap(yyl2735, d)
}
- } else if yyct2730 == codecSelferValueTypeArray1234 {
- yyl2730 := r.ReadArrayStart()
- if yyl2730 == 0 {
+ } else if yyct2735 == codecSelferValueTypeArray1234 {
+ yyl2735 := r.ReadArrayStart()
+ if yyl2735 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl2730, d)
+ x.codecDecodeSelfFromArray(yyl2735, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -35526,12 +35590,12 @@ func (x *ServiceList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys2731Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys2731Slc
- var yyhl2731 bool = l >= 0
- for yyj2731 := 0; ; yyj2731++ {
- if yyhl2731 {
- if yyj2731 >= l {
+ var yys2736Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys2736Slc
+ var yyhl2736 bool = l >= 0
+ for yyj2736 := 0; ; yyj2736++ {
+ if yyhl2736 {
+ if yyj2736 >= l {
break
}
} else {
@@ -35540,10 +35604,10 @@ func (x *ServiceList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys2731Slc = r.DecodeBytes(yys2731Slc, true, true)
- yys2731 := string(yys2731Slc)
+ yys2736Slc = r.DecodeBytes(yys2736Slc, true, true)
+ yys2736 := string(yys2736Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys2731 {
+ switch yys2736 {
case "kind":
if r.TryDecodeAsNil() {
x.Kind = ""
@@ -35560,31 +35624,31 @@ func (x *ServiceList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.ListMeta = pkg2_v1.ListMeta{}
} else {
- yyv2734 := &x.ListMeta
- yym2735 := z.DecBinary()
- _ = yym2735
+ yyv2739 := &x.ListMeta
+ yym2740 := z.DecBinary()
+ _ = yym2740
if false {
- } else if z.HasExtensions() && z.DecExt(yyv2734) {
+ } else if z.HasExtensions() && z.DecExt(yyv2739) {
} else {
- z.DecFallback(yyv2734, false)
+ z.DecFallback(yyv2739, false)
}
}
case "items":
if r.TryDecodeAsNil() {
x.Items = nil
} else {
- yyv2736 := &x.Items
- yym2737 := z.DecBinary()
- _ = yym2737
+ yyv2741 := &x.Items
+ yym2742 := z.DecBinary()
+ _ = yym2742
if false {
} else {
- h.decSliceService((*[]Service)(yyv2736), d)
+ h.decSliceService((*[]Service)(yyv2741), d)
}
}
default:
- z.DecStructFieldNotFound(-1, yys2731)
- } // end switch yys2731
- } // end for yyj2731
+ z.DecStructFieldNotFound(-1, yys2736)
+ } // end switch yys2736
+ } // end for yyj2736
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -35592,16 +35656,16 @@ func (x *ServiceList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj2738 int
- var yyb2738 bool
- var yyhl2738 bool = l >= 0
- yyj2738++
- if yyhl2738 {
- yyb2738 = yyj2738 > l
+ var yyj2743 int
+ var yyb2743 bool
+ var yyhl2743 bool = l >= 0
+ yyj2743++
+ if yyhl2743 {
+ yyb2743 = yyj2743 > l
} else {
- yyb2738 = r.CheckBreak()
+ yyb2743 = r.CheckBreak()
}
- if yyb2738 {
+ if yyb2743 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -35611,13 +35675,13 @@ func (x *ServiceList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Kind = string(r.DecodeString())
}
- yyj2738++
- if yyhl2738 {
- yyb2738 = yyj2738 > l
+ yyj2743++
+ if yyhl2743 {
+ yyb2743 = yyj2743 > l
} else {
- yyb2738 = r.CheckBreak()
+ yyb2743 = r.CheckBreak()
}
- if yyb2738 {
+ if yyb2743 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -35627,13 +35691,13 @@ func (x *ServiceList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.APIVersion = string(r.DecodeString())
}
- yyj2738++
- if yyhl2738 {
- yyb2738 = yyj2738 > l
+ yyj2743++
+ if yyhl2743 {
+ yyb2743 = yyj2743 > l
} else {
- yyb2738 = r.CheckBreak()
+ yyb2743 = r.CheckBreak()
}
- if yyb2738 {
+ if yyb2743 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -35641,22 +35705,22 @@ func (x *ServiceList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.ListMeta = pkg2_v1.ListMeta{}
} else {
- yyv2741 := &x.ListMeta
- yym2742 := z.DecBinary()
- _ = yym2742
+ yyv2746 := &x.ListMeta
+ yym2747 := z.DecBinary()
+ _ = yym2747
if false {
- } else if z.HasExtensions() && z.DecExt(yyv2741) {
+ } else if z.HasExtensions() && z.DecExt(yyv2746) {
} else {
- z.DecFallback(yyv2741, false)
+ z.DecFallback(yyv2746, false)
}
}
- yyj2738++
- if yyhl2738 {
- yyb2738 = yyj2738 > l
+ yyj2743++
+ if yyhl2743 {
+ yyb2743 = yyj2743 > l
} else {
- yyb2738 = r.CheckBreak()
+ yyb2743 = r.CheckBreak()
}
- if yyb2738 {
+ if yyb2743 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -35664,26 +35728,26 @@ func (x *ServiceList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Items = nil
} else {
- yyv2743 := &x.Items
- yym2744 := z.DecBinary()
- _ = yym2744
+ yyv2748 := &x.Items
+ yym2749 := z.DecBinary()
+ _ = yym2749
if false {
} else {
- h.decSliceService((*[]Service)(yyv2743), d)
+ h.decSliceService((*[]Service)(yyv2748), d)
}
}
for {
- yyj2738++
- if yyhl2738 {
- yyb2738 = yyj2738 > l
+ yyj2743++
+ if yyhl2743 {
+ yyb2743 = yyj2743 > l
} else {
- yyb2738 = r.CheckBreak()
+ yyb2743 = r.CheckBreak()
}
- if yyb2738 {
+ if yyb2743 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj2738-1, "")
+ z.DecStructFieldNotFound(yyj2743-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -35695,39 +35759,39 @@ func (x *ServiceAccount) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym2745 := z.EncBinary()
- _ = yym2745
+ yym2750 := z.EncBinary()
+ _ = yym2750
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep2746 := !z.EncBinary()
- yy2arr2746 := z.EncBasicHandle().StructToArray
- var yyq2746 [5]bool
- _, _, _ = yysep2746, yyq2746, yy2arr2746
- const yyr2746 bool = false
- yyq2746[0] = x.Kind != ""
- yyq2746[1] = x.APIVersion != ""
- yyq2746[2] = true
- yyq2746[3] = len(x.Secrets) != 0
- yyq2746[4] = len(x.ImagePullSecrets) != 0
- var yynn2746 int
- if yyr2746 || yy2arr2746 {
+ yysep2751 := !z.EncBinary()
+ yy2arr2751 := z.EncBasicHandle().StructToArray
+ var yyq2751 [5]bool
+ _, _, _ = yysep2751, yyq2751, yy2arr2751
+ const yyr2751 bool = false
+ yyq2751[0] = x.Kind != ""
+ yyq2751[1] = x.APIVersion != ""
+ yyq2751[2] = true
+ yyq2751[3] = len(x.Secrets) != 0
+ yyq2751[4] = len(x.ImagePullSecrets) != 0
+ var yynn2751 int
+ if yyr2751 || yy2arr2751 {
r.EncodeArrayStart(5)
} else {
- yynn2746 = 0
- for _, b := range yyq2746 {
+ yynn2751 = 0
+ for _, b := range yyq2751 {
if b {
- yynn2746++
+ yynn2751++
}
}
- r.EncodeMapStart(yynn2746)
- yynn2746 = 0
+ r.EncodeMapStart(yynn2751)
+ yynn2751 = 0
}
- if yyr2746 || yy2arr2746 {
+ if yyr2751 || yy2arr2751 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2746[0] {
- yym2748 := z.EncBinary()
- _ = yym2748
+ if yyq2751[0] {
+ yym2753 := z.EncBinary()
+ _ = yym2753
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
@@ -35736,23 +35800,23 @@ func (x *ServiceAccount) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2746[0] {
+ if yyq2751[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("kind"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym2749 := z.EncBinary()
- _ = yym2749
+ yym2754 := z.EncBinary()
+ _ = yym2754
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
}
}
}
- if yyr2746 || yy2arr2746 {
+ if yyr2751 || yy2arr2751 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2746[1] {
- yym2751 := z.EncBinary()
- _ = yym2751
+ if yyq2751[1] {
+ yym2756 := z.EncBinary()
+ _ = yym2756
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
@@ -35761,43 +35825,43 @@ func (x *ServiceAccount) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2746[1] {
+ if yyq2751[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym2752 := z.EncBinary()
- _ = yym2752
+ yym2757 := z.EncBinary()
+ _ = yym2757
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
}
}
}
- if yyr2746 || yy2arr2746 {
+ if yyr2751 || yy2arr2751 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2746[2] {
- yy2754 := &x.ObjectMeta
- yy2754.CodecEncodeSelf(e)
+ if yyq2751[2] {
+ yy2759 := &x.ObjectMeta
+ yy2759.CodecEncodeSelf(e)
} else {
r.EncodeNil()
}
} else {
- if yyq2746[2] {
+ if yyq2751[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("metadata"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy2755 := &x.ObjectMeta
- yy2755.CodecEncodeSelf(e)
+ yy2760 := &x.ObjectMeta
+ yy2760.CodecEncodeSelf(e)
}
}
- if yyr2746 || yy2arr2746 {
+ if yyr2751 || yy2arr2751 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2746[3] {
+ if yyq2751[3] {
if x.Secrets == nil {
r.EncodeNil()
} else {
- yym2757 := z.EncBinary()
- _ = yym2757
+ yym2762 := z.EncBinary()
+ _ = yym2762
if false {
} else {
h.encSliceObjectReference(([]ObjectReference)(x.Secrets), e)
@@ -35807,15 +35871,15 @@ func (x *ServiceAccount) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeNil()
}
} else {
- if yyq2746[3] {
+ if yyq2751[3] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("secrets"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
if x.Secrets == nil {
r.EncodeNil()
} else {
- yym2758 := z.EncBinary()
- _ = yym2758
+ yym2763 := z.EncBinary()
+ _ = yym2763
if false {
} else {
h.encSliceObjectReference(([]ObjectReference)(x.Secrets), e)
@@ -35823,14 +35887,14 @@ func (x *ServiceAccount) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
- if yyr2746 || yy2arr2746 {
+ if yyr2751 || yy2arr2751 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2746[4] {
+ if yyq2751[4] {
if x.ImagePullSecrets == nil {
r.EncodeNil()
} else {
- yym2760 := z.EncBinary()
- _ = yym2760
+ yym2765 := z.EncBinary()
+ _ = yym2765
if false {
} else {
h.encSliceLocalObjectReference(([]LocalObjectReference)(x.ImagePullSecrets), e)
@@ -35840,15 +35904,15 @@ func (x *ServiceAccount) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeNil()
}
} else {
- if yyq2746[4] {
+ if yyq2751[4] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("imagePullSecrets"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
if x.ImagePullSecrets == nil {
r.EncodeNil()
} else {
- yym2761 := z.EncBinary()
- _ = yym2761
+ yym2766 := z.EncBinary()
+ _ = yym2766
if false {
} else {
h.encSliceLocalObjectReference(([]LocalObjectReference)(x.ImagePullSecrets), e)
@@ -35856,7 +35920,7 @@ func (x *ServiceAccount) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
- if yyr2746 || yy2arr2746 {
+ if yyr2751 || yy2arr2751 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -35869,25 +35933,25 @@ func (x *ServiceAccount) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym2762 := z.DecBinary()
- _ = yym2762
+ yym2767 := z.DecBinary()
+ _ = yym2767
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct2763 := r.ContainerType()
- if yyct2763 == codecSelferValueTypeMap1234 {
- yyl2763 := r.ReadMapStart()
- if yyl2763 == 0 {
+ yyct2768 := r.ContainerType()
+ if yyct2768 == codecSelferValueTypeMap1234 {
+ yyl2768 := r.ReadMapStart()
+ if yyl2768 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl2763, d)
+ x.codecDecodeSelfFromMap(yyl2768, d)
}
- } else if yyct2763 == codecSelferValueTypeArray1234 {
- yyl2763 := r.ReadArrayStart()
- if yyl2763 == 0 {
+ } else if yyct2768 == codecSelferValueTypeArray1234 {
+ yyl2768 := r.ReadArrayStart()
+ if yyl2768 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl2763, d)
+ x.codecDecodeSelfFromArray(yyl2768, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -35899,12 +35963,12 @@ func (x *ServiceAccount) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys2764Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys2764Slc
- var yyhl2764 bool = l >= 0
- for yyj2764 := 0; ; yyj2764++ {
- if yyhl2764 {
- if yyj2764 >= l {
+ var yys2769Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys2769Slc
+ var yyhl2769 bool = l >= 0
+ for yyj2769 := 0; ; yyj2769++ {
+ if yyhl2769 {
+ if yyj2769 >= l {
break
}
} else {
@@ -35913,10 +35977,10 @@ func (x *ServiceAccount) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys2764Slc = r.DecodeBytes(yys2764Slc, true, true)
- yys2764 := string(yys2764Slc)
+ yys2769Slc = r.DecodeBytes(yys2769Slc, true, true)
+ yys2769 := string(yys2769Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys2764 {
+ switch yys2769 {
case "kind":
if r.TryDecodeAsNil() {
x.Kind = ""
@@ -35933,37 +35997,37 @@ func (x *ServiceAccount) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.ObjectMeta = ObjectMeta{}
} else {
- yyv2767 := &x.ObjectMeta
- yyv2767.CodecDecodeSelf(d)
+ yyv2772 := &x.ObjectMeta
+ yyv2772.CodecDecodeSelf(d)
}
case "secrets":
if r.TryDecodeAsNil() {
x.Secrets = nil
} else {
- yyv2768 := &x.Secrets
- yym2769 := z.DecBinary()
- _ = yym2769
+ yyv2773 := &x.Secrets
+ yym2774 := z.DecBinary()
+ _ = yym2774
if false {
} else {
- h.decSliceObjectReference((*[]ObjectReference)(yyv2768), d)
+ h.decSliceObjectReference((*[]ObjectReference)(yyv2773), d)
}
}
case "imagePullSecrets":
if r.TryDecodeAsNil() {
x.ImagePullSecrets = nil
} else {
- yyv2770 := &x.ImagePullSecrets
- yym2771 := z.DecBinary()
- _ = yym2771
+ yyv2775 := &x.ImagePullSecrets
+ yym2776 := z.DecBinary()
+ _ = yym2776
if false {
} else {
- h.decSliceLocalObjectReference((*[]LocalObjectReference)(yyv2770), d)
+ h.decSliceLocalObjectReference((*[]LocalObjectReference)(yyv2775), d)
}
}
default:
- z.DecStructFieldNotFound(-1, yys2764)
- } // end switch yys2764
- } // end for yyj2764
+ z.DecStructFieldNotFound(-1, yys2769)
+ } // end switch yys2769
+ } // end for yyj2769
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -35971,16 +36035,16 @@ func (x *ServiceAccount) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj2772 int
- var yyb2772 bool
- var yyhl2772 bool = l >= 0
- yyj2772++
- if yyhl2772 {
- yyb2772 = yyj2772 > l
+ var yyj2777 int
+ var yyb2777 bool
+ var yyhl2777 bool = l >= 0
+ yyj2777++
+ if yyhl2777 {
+ yyb2777 = yyj2777 > l
} else {
- yyb2772 = r.CheckBreak()
+ yyb2777 = r.CheckBreak()
}
- if yyb2772 {
+ if yyb2777 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -35990,13 +36054,13 @@ func (x *ServiceAccount) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Kind = string(r.DecodeString())
}
- yyj2772++
- if yyhl2772 {
- yyb2772 = yyj2772 > l
+ yyj2777++
+ if yyhl2777 {
+ yyb2777 = yyj2777 > l
} else {
- yyb2772 = r.CheckBreak()
+ yyb2777 = r.CheckBreak()
}
- if yyb2772 {
+ if yyb2777 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -36006,13 +36070,13 @@ func (x *ServiceAccount) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.APIVersion = string(r.DecodeString())
}
- yyj2772++
- if yyhl2772 {
- yyb2772 = yyj2772 > l
+ yyj2777++
+ if yyhl2777 {
+ yyb2777 = yyj2777 > l
} else {
- yyb2772 = r.CheckBreak()
+ yyb2777 = r.CheckBreak()
}
- if yyb2772 {
+ if yyb2777 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -36020,16 +36084,16 @@ func (x *ServiceAccount) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.ObjectMeta = ObjectMeta{}
} else {
- yyv2775 := &x.ObjectMeta
- yyv2775.CodecDecodeSelf(d)
+ yyv2780 := &x.ObjectMeta
+ yyv2780.CodecDecodeSelf(d)
}
- yyj2772++
- if yyhl2772 {
- yyb2772 = yyj2772 > l
+ yyj2777++
+ if yyhl2777 {
+ yyb2777 = yyj2777 > l
} else {
- yyb2772 = r.CheckBreak()
+ yyb2777 = r.CheckBreak()
}
- if yyb2772 {
+ if yyb2777 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -36037,21 +36101,21 @@ func (x *ServiceAccount) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Secrets = nil
} else {
- yyv2776 := &x.Secrets
- yym2777 := z.DecBinary()
- _ = yym2777
+ yyv2781 := &x.Secrets
+ yym2782 := z.DecBinary()
+ _ = yym2782
if false {
} else {
- h.decSliceObjectReference((*[]ObjectReference)(yyv2776), d)
+ h.decSliceObjectReference((*[]ObjectReference)(yyv2781), d)
}
}
- yyj2772++
- if yyhl2772 {
- yyb2772 = yyj2772 > l
+ yyj2777++
+ if yyhl2777 {
+ yyb2777 = yyj2777 > l
} else {
- yyb2772 = r.CheckBreak()
+ yyb2777 = r.CheckBreak()
}
- if yyb2772 {
+ if yyb2777 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -36059,26 +36123,26 @@ func (x *ServiceAccount) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.ImagePullSecrets = nil
} else {
- yyv2778 := &x.ImagePullSecrets
- yym2779 := z.DecBinary()
- _ = yym2779
+ yyv2783 := &x.ImagePullSecrets
+ yym2784 := z.DecBinary()
+ _ = yym2784
if false {
} else {
- h.decSliceLocalObjectReference((*[]LocalObjectReference)(yyv2778), d)
+ h.decSliceLocalObjectReference((*[]LocalObjectReference)(yyv2783), d)
}
}
for {
- yyj2772++
- if yyhl2772 {
- yyb2772 = yyj2772 > l
+ yyj2777++
+ if yyhl2777 {
+ yyb2777 = yyj2777 > l
} else {
- yyb2772 = r.CheckBreak()
+ yyb2777 = r.CheckBreak()
}
- if yyb2772 {
+ if yyb2777 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj2772-1, "")
+ z.DecStructFieldNotFound(yyj2777-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -36090,37 +36154,37 @@ func (x *ServiceAccountList) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym2780 := z.EncBinary()
- _ = yym2780
+ yym2785 := z.EncBinary()
+ _ = yym2785
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep2781 := !z.EncBinary()
- yy2arr2781 := z.EncBasicHandle().StructToArray
- var yyq2781 [4]bool
- _, _, _ = yysep2781, yyq2781, yy2arr2781
- const yyr2781 bool = false
- yyq2781[0] = x.Kind != ""
- yyq2781[1] = x.APIVersion != ""
- yyq2781[2] = true
- var yynn2781 int
- if yyr2781 || yy2arr2781 {
+ yysep2786 := !z.EncBinary()
+ yy2arr2786 := z.EncBasicHandle().StructToArray
+ var yyq2786 [4]bool
+ _, _, _ = yysep2786, yyq2786, yy2arr2786
+ const yyr2786 bool = false
+ yyq2786[0] = x.Kind != ""
+ yyq2786[1] = x.APIVersion != ""
+ yyq2786[2] = true
+ var yynn2786 int
+ if yyr2786 || yy2arr2786 {
r.EncodeArrayStart(4)
} else {
- yynn2781 = 1
- for _, b := range yyq2781 {
+ yynn2786 = 1
+ for _, b := range yyq2786 {
if b {
- yynn2781++
+ yynn2786++
}
}
- r.EncodeMapStart(yynn2781)
- yynn2781 = 0
+ r.EncodeMapStart(yynn2786)
+ yynn2786 = 0
}
- if yyr2781 || yy2arr2781 {
+ if yyr2786 || yy2arr2786 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2781[0] {
- yym2783 := z.EncBinary()
- _ = yym2783
+ if yyq2786[0] {
+ yym2788 := z.EncBinary()
+ _ = yym2788
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
@@ -36129,23 +36193,23 @@ func (x *ServiceAccountList) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2781[0] {
+ if yyq2786[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("kind"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym2784 := z.EncBinary()
- _ = yym2784
+ yym2789 := z.EncBinary()
+ _ = yym2789
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
}
}
}
- if yyr2781 || yy2arr2781 {
+ if yyr2786 || yy2arr2786 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2781[1] {
- yym2786 := z.EncBinary()
- _ = yym2786
+ if yyq2786[1] {
+ yym2791 := z.EncBinary()
+ _ = yym2791
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
@@ -36154,54 +36218,54 @@ func (x *ServiceAccountList) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2781[1] {
+ if yyq2786[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym2787 := z.EncBinary()
- _ = yym2787
+ yym2792 := z.EncBinary()
+ _ = yym2792
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
}
}
}
- if yyr2781 || yy2arr2781 {
+ if yyr2786 || yy2arr2786 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2781[2] {
- yy2789 := &x.ListMeta
- yym2790 := z.EncBinary()
- _ = yym2790
+ if yyq2786[2] {
+ yy2794 := &x.ListMeta
+ yym2795 := z.EncBinary()
+ _ = yym2795
if false {
- } else if z.HasExtensions() && z.EncExt(yy2789) {
+ } else if z.HasExtensions() && z.EncExt(yy2794) {
} else {
- z.EncFallback(yy2789)
+ z.EncFallback(yy2794)
}
} else {
r.EncodeNil()
}
} else {
- if yyq2781[2] {
+ if yyq2786[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("metadata"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy2791 := &x.ListMeta
- yym2792 := z.EncBinary()
- _ = yym2792
+ yy2796 := &x.ListMeta
+ yym2797 := z.EncBinary()
+ _ = yym2797
if false {
- } else if z.HasExtensions() && z.EncExt(yy2791) {
+ } else if z.HasExtensions() && z.EncExt(yy2796) {
} else {
- z.EncFallback(yy2791)
+ z.EncFallback(yy2796)
}
}
}
- if yyr2781 || yy2arr2781 {
+ if yyr2786 || yy2arr2786 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if x.Items == nil {
r.EncodeNil()
} else {
- yym2794 := z.EncBinary()
- _ = yym2794
+ yym2799 := z.EncBinary()
+ _ = yym2799
if false {
} else {
h.encSliceServiceAccount(([]ServiceAccount)(x.Items), e)
@@ -36214,15 +36278,15 @@ func (x *ServiceAccountList) CodecEncodeSelf(e *codec1978.Encoder) {
if x.Items == nil {
r.EncodeNil()
} else {
- yym2795 := z.EncBinary()
- _ = yym2795
+ yym2800 := z.EncBinary()
+ _ = yym2800
if false {
} else {
h.encSliceServiceAccount(([]ServiceAccount)(x.Items), e)
}
}
}
- if yyr2781 || yy2arr2781 {
+ if yyr2786 || yy2arr2786 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -36235,25 +36299,25 @@ func (x *ServiceAccountList) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym2796 := z.DecBinary()
- _ = yym2796
+ yym2801 := z.DecBinary()
+ _ = yym2801
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct2797 := r.ContainerType()
- if yyct2797 == codecSelferValueTypeMap1234 {
- yyl2797 := r.ReadMapStart()
- if yyl2797 == 0 {
+ yyct2802 := r.ContainerType()
+ if yyct2802 == codecSelferValueTypeMap1234 {
+ yyl2802 := r.ReadMapStart()
+ if yyl2802 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl2797, d)
+ x.codecDecodeSelfFromMap(yyl2802, d)
}
- } else if yyct2797 == codecSelferValueTypeArray1234 {
- yyl2797 := r.ReadArrayStart()
- if yyl2797 == 0 {
+ } else if yyct2802 == codecSelferValueTypeArray1234 {
+ yyl2802 := r.ReadArrayStart()
+ if yyl2802 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl2797, d)
+ x.codecDecodeSelfFromArray(yyl2802, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -36265,12 +36329,12 @@ func (x *ServiceAccountList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder)
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys2798Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys2798Slc
- var yyhl2798 bool = l >= 0
- for yyj2798 := 0; ; yyj2798++ {
- if yyhl2798 {
- if yyj2798 >= l {
+ var yys2803Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys2803Slc
+ var yyhl2803 bool = l >= 0
+ for yyj2803 := 0; ; yyj2803++ {
+ if yyhl2803 {
+ if yyj2803 >= l {
break
}
} else {
@@ -36279,10 +36343,10 @@ func (x *ServiceAccountList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder)
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys2798Slc = r.DecodeBytes(yys2798Slc, true, true)
- yys2798 := string(yys2798Slc)
+ yys2803Slc = r.DecodeBytes(yys2803Slc, true, true)
+ yys2803 := string(yys2803Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys2798 {
+ switch yys2803 {
case "kind":
if r.TryDecodeAsNil() {
x.Kind = ""
@@ -36299,31 +36363,31 @@ func (x *ServiceAccountList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder)
if r.TryDecodeAsNil() {
x.ListMeta = pkg2_v1.ListMeta{}
} else {
- yyv2801 := &x.ListMeta
- yym2802 := z.DecBinary()
- _ = yym2802
+ yyv2806 := &x.ListMeta
+ yym2807 := z.DecBinary()
+ _ = yym2807
if false {
- } else if z.HasExtensions() && z.DecExt(yyv2801) {
+ } else if z.HasExtensions() && z.DecExt(yyv2806) {
} else {
- z.DecFallback(yyv2801, false)
+ z.DecFallback(yyv2806, false)
}
}
case "items":
if r.TryDecodeAsNil() {
x.Items = nil
} else {
- yyv2803 := &x.Items
- yym2804 := z.DecBinary()
- _ = yym2804
+ yyv2808 := &x.Items
+ yym2809 := z.DecBinary()
+ _ = yym2809
if false {
} else {
- h.decSliceServiceAccount((*[]ServiceAccount)(yyv2803), d)
+ h.decSliceServiceAccount((*[]ServiceAccount)(yyv2808), d)
}
}
default:
- z.DecStructFieldNotFound(-1, yys2798)
- } // end switch yys2798
- } // end for yyj2798
+ z.DecStructFieldNotFound(-1, yys2803)
+ } // end switch yys2803
+ } // end for yyj2803
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -36331,16 +36395,16 @@ func (x *ServiceAccountList) codecDecodeSelfFromArray(l int, d *codec1978.Decode
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj2805 int
- var yyb2805 bool
- var yyhl2805 bool = l >= 0
- yyj2805++
- if yyhl2805 {
- yyb2805 = yyj2805 > l
+ var yyj2810 int
+ var yyb2810 bool
+ var yyhl2810 bool = l >= 0
+ yyj2810++
+ if yyhl2810 {
+ yyb2810 = yyj2810 > l
} else {
- yyb2805 = r.CheckBreak()
+ yyb2810 = r.CheckBreak()
}
- if yyb2805 {
+ if yyb2810 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -36350,13 +36414,13 @@ func (x *ServiceAccountList) codecDecodeSelfFromArray(l int, d *codec1978.Decode
} else {
x.Kind = string(r.DecodeString())
}
- yyj2805++
- if yyhl2805 {
- yyb2805 = yyj2805 > l
+ yyj2810++
+ if yyhl2810 {
+ yyb2810 = yyj2810 > l
} else {
- yyb2805 = r.CheckBreak()
+ yyb2810 = r.CheckBreak()
}
- if yyb2805 {
+ if yyb2810 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -36366,13 +36430,13 @@ func (x *ServiceAccountList) codecDecodeSelfFromArray(l int, d *codec1978.Decode
} else {
x.APIVersion = string(r.DecodeString())
}
- yyj2805++
- if yyhl2805 {
- yyb2805 = yyj2805 > l
+ yyj2810++
+ if yyhl2810 {
+ yyb2810 = yyj2810 > l
} else {
- yyb2805 = r.CheckBreak()
+ yyb2810 = r.CheckBreak()
}
- if yyb2805 {
+ if yyb2810 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -36380,22 +36444,22 @@ func (x *ServiceAccountList) codecDecodeSelfFromArray(l int, d *codec1978.Decode
if r.TryDecodeAsNil() {
x.ListMeta = pkg2_v1.ListMeta{}
} else {
- yyv2808 := &x.ListMeta
- yym2809 := z.DecBinary()
- _ = yym2809
+ yyv2813 := &x.ListMeta
+ yym2814 := z.DecBinary()
+ _ = yym2814
if false {
- } else if z.HasExtensions() && z.DecExt(yyv2808) {
+ } else if z.HasExtensions() && z.DecExt(yyv2813) {
} else {
- z.DecFallback(yyv2808, false)
+ z.DecFallback(yyv2813, false)
}
}
- yyj2805++
- if yyhl2805 {
- yyb2805 = yyj2805 > l
+ yyj2810++
+ if yyhl2810 {
+ yyb2810 = yyj2810 > l
} else {
- yyb2805 = r.CheckBreak()
+ yyb2810 = r.CheckBreak()
}
- if yyb2805 {
+ if yyb2810 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -36403,26 +36467,26 @@ func (x *ServiceAccountList) codecDecodeSelfFromArray(l int, d *codec1978.Decode
if r.TryDecodeAsNil() {
x.Items = nil
} else {
- yyv2810 := &x.Items
- yym2811 := z.DecBinary()
- _ = yym2811
+ yyv2815 := &x.Items
+ yym2816 := z.DecBinary()
+ _ = yym2816
if false {
} else {
- h.decSliceServiceAccount((*[]ServiceAccount)(yyv2810), d)
+ h.decSliceServiceAccount((*[]ServiceAccount)(yyv2815), d)
}
}
for {
- yyj2805++
- if yyhl2805 {
- yyb2805 = yyj2805 > l
+ yyj2810++
+ if yyhl2810 {
+ yyb2810 = yyj2810 > l
} else {
- yyb2805 = r.CheckBreak()
+ yyb2810 = r.CheckBreak()
}
- if yyb2805 {
+ if yyb2810 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj2805-1, "")
+ z.DecStructFieldNotFound(yyj2810-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -36434,37 +36498,37 @@ func (x *Endpoints) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym2812 := z.EncBinary()
- _ = yym2812
+ yym2817 := z.EncBinary()
+ _ = yym2817
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep2813 := !z.EncBinary()
- yy2arr2813 := z.EncBasicHandle().StructToArray
- var yyq2813 [4]bool
- _, _, _ = yysep2813, yyq2813, yy2arr2813
- const yyr2813 bool = false
- yyq2813[0] = x.Kind != ""
- yyq2813[1] = x.APIVersion != ""
- yyq2813[2] = true
- var yynn2813 int
- if yyr2813 || yy2arr2813 {
+ yysep2818 := !z.EncBinary()
+ yy2arr2818 := z.EncBasicHandle().StructToArray
+ var yyq2818 [4]bool
+ _, _, _ = yysep2818, yyq2818, yy2arr2818
+ const yyr2818 bool = false
+ yyq2818[0] = x.Kind != ""
+ yyq2818[1] = x.APIVersion != ""
+ yyq2818[2] = true
+ var yynn2818 int
+ if yyr2818 || yy2arr2818 {
r.EncodeArrayStart(4)
} else {
- yynn2813 = 1
- for _, b := range yyq2813 {
+ yynn2818 = 1
+ for _, b := range yyq2818 {
if b {
- yynn2813++
+ yynn2818++
}
}
- r.EncodeMapStart(yynn2813)
- yynn2813 = 0
+ r.EncodeMapStart(yynn2818)
+ yynn2818 = 0
}
- if yyr2813 || yy2arr2813 {
+ if yyr2818 || yy2arr2818 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2813[0] {
- yym2815 := z.EncBinary()
- _ = yym2815
+ if yyq2818[0] {
+ yym2820 := z.EncBinary()
+ _ = yym2820
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
@@ -36473,23 +36537,23 @@ func (x *Endpoints) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2813[0] {
+ if yyq2818[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("kind"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym2816 := z.EncBinary()
- _ = yym2816
+ yym2821 := z.EncBinary()
+ _ = yym2821
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
}
}
}
- if yyr2813 || yy2arr2813 {
+ if yyr2818 || yy2arr2818 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2813[1] {
- yym2818 := z.EncBinary()
- _ = yym2818
+ if yyq2818[1] {
+ yym2823 := z.EncBinary()
+ _ = yym2823
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
@@ -36498,42 +36562,42 @@ func (x *Endpoints) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2813[1] {
+ if yyq2818[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym2819 := z.EncBinary()
- _ = yym2819
+ yym2824 := z.EncBinary()
+ _ = yym2824
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
}
}
}
- if yyr2813 || yy2arr2813 {
+ if yyr2818 || yy2arr2818 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2813[2] {
- yy2821 := &x.ObjectMeta
- yy2821.CodecEncodeSelf(e)
+ if yyq2818[2] {
+ yy2826 := &x.ObjectMeta
+ yy2826.CodecEncodeSelf(e)
} else {
r.EncodeNil()
}
} else {
- if yyq2813[2] {
+ if yyq2818[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("metadata"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy2822 := &x.ObjectMeta
- yy2822.CodecEncodeSelf(e)
+ yy2827 := &x.ObjectMeta
+ yy2827.CodecEncodeSelf(e)
}
}
- if yyr2813 || yy2arr2813 {
+ if yyr2818 || yy2arr2818 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if x.Subsets == nil {
r.EncodeNil()
} else {
- yym2824 := z.EncBinary()
- _ = yym2824
+ yym2829 := z.EncBinary()
+ _ = yym2829
if false {
} else {
h.encSliceEndpointSubset(([]EndpointSubset)(x.Subsets), e)
@@ -36546,15 +36610,15 @@ func (x *Endpoints) CodecEncodeSelf(e *codec1978.Encoder) {
if x.Subsets == nil {
r.EncodeNil()
} else {
- yym2825 := z.EncBinary()
- _ = yym2825
+ yym2830 := z.EncBinary()
+ _ = yym2830
if false {
} else {
h.encSliceEndpointSubset(([]EndpointSubset)(x.Subsets), e)
}
}
}
- if yyr2813 || yy2arr2813 {
+ if yyr2818 || yy2arr2818 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -36567,25 +36631,25 @@ func (x *Endpoints) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym2826 := z.DecBinary()
- _ = yym2826
+ yym2831 := z.DecBinary()
+ _ = yym2831
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct2827 := r.ContainerType()
- if yyct2827 == codecSelferValueTypeMap1234 {
- yyl2827 := r.ReadMapStart()
- if yyl2827 == 0 {
+ yyct2832 := r.ContainerType()
+ if yyct2832 == codecSelferValueTypeMap1234 {
+ yyl2832 := r.ReadMapStart()
+ if yyl2832 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl2827, d)
+ x.codecDecodeSelfFromMap(yyl2832, d)
}
- } else if yyct2827 == codecSelferValueTypeArray1234 {
- yyl2827 := r.ReadArrayStart()
- if yyl2827 == 0 {
+ } else if yyct2832 == codecSelferValueTypeArray1234 {
+ yyl2832 := r.ReadArrayStart()
+ if yyl2832 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl2827, d)
+ x.codecDecodeSelfFromArray(yyl2832, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -36597,12 +36661,12 @@ func (x *Endpoints) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys2828Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys2828Slc
- var yyhl2828 bool = l >= 0
- for yyj2828 := 0; ; yyj2828++ {
- if yyhl2828 {
- if yyj2828 >= l {
+ var yys2833Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys2833Slc
+ var yyhl2833 bool = l >= 0
+ for yyj2833 := 0; ; yyj2833++ {
+ if yyhl2833 {
+ if yyj2833 >= l {
break
}
} else {
@@ -36611,10 +36675,10 @@ func (x *Endpoints) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys2828Slc = r.DecodeBytes(yys2828Slc, true, true)
- yys2828 := string(yys2828Slc)
+ yys2833Slc = r.DecodeBytes(yys2833Slc, true, true)
+ yys2833 := string(yys2833Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys2828 {
+ switch yys2833 {
case "kind":
if r.TryDecodeAsNil() {
x.Kind = ""
@@ -36631,25 +36695,25 @@ func (x *Endpoints) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.ObjectMeta = ObjectMeta{}
} else {
- yyv2831 := &x.ObjectMeta
- yyv2831.CodecDecodeSelf(d)
+ yyv2836 := &x.ObjectMeta
+ yyv2836.CodecDecodeSelf(d)
}
case "subsets":
if r.TryDecodeAsNil() {
x.Subsets = nil
} else {
- yyv2832 := &x.Subsets
- yym2833 := z.DecBinary()
- _ = yym2833
+ yyv2837 := &x.Subsets
+ yym2838 := z.DecBinary()
+ _ = yym2838
if false {
} else {
- h.decSliceEndpointSubset((*[]EndpointSubset)(yyv2832), d)
+ h.decSliceEndpointSubset((*[]EndpointSubset)(yyv2837), d)
}
}
default:
- z.DecStructFieldNotFound(-1, yys2828)
- } // end switch yys2828
- } // end for yyj2828
+ z.DecStructFieldNotFound(-1, yys2833)
+ } // end switch yys2833
+ } // end for yyj2833
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -36657,16 +36721,16 @@ func (x *Endpoints) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj2834 int
- var yyb2834 bool
- var yyhl2834 bool = l >= 0
- yyj2834++
- if yyhl2834 {
- yyb2834 = yyj2834 > l
+ var yyj2839 int
+ var yyb2839 bool
+ var yyhl2839 bool = l >= 0
+ yyj2839++
+ if yyhl2839 {
+ yyb2839 = yyj2839 > l
} else {
- yyb2834 = r.CheckBreak()
+ yyb2839 = r.CheckBreak()
}
- if yyb2834 {
+ if yyb2839 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -36676,13 +36740,13 @@ func (x *Endpoints) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Kind = string(r.DecodeString())
}
- yyj2834++
- if yyhl2834 {
- yyb2834 = yyj2834 > l
+ yyj2839++
+ if yyhl2839 {
+ yyb2839 = yyj2839 > l
} else {
- yyb2834 = r.CheckBreak()
+ yyb2839 = r.CheckBreak()
}
- if yyb2834 {
+ if yyb2839 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -36692,13 +36756,13 @@ func (x *Endpoints) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.APIVersion = string(r.DecodeString())
}
- yyj2834++
- if yyhl2834 {
- yyb2834 = yyj2834 > l
+ yyj2839++
+ if yyhl2839 {
+ yyb2839 = yyj2839 > l
} else {
- yyb2834 = r.CheckBreak()
+ yyb2839 = r.CheckBreak()
}
- if yyb2834 {
+ if yyb2839 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -36706,16 +36770,16 @@ func (x *Endpoints) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.ObjectMeta = ObjectMeta{}
} else {
- yyv2837 := &x.ObjectMeta
- yyv2837.CodecDecodeSelf(d)
+ yyv2842 := &x.ObjectMeta
+ yyv2842.CodecDecodeSelf(d)
}
- yyj2834++
- if yyhl2834 {
- yyb2834 = yyj2834 > l
+ yyj2839++
+ if yyhl2839 {
+ yyb2839 = yyj2839 > l
} else {
- yyb2834 = r.CheckBreak()
+ yyb2839 = r.CheckBreak()
}
- if yyb2834 {
+ if yyb2839 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -36723,26 +36787,26 @@ func (x *Endpoints) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Subsets = nil
} else {
- yyv2838 := &x.Subsets
- yym2839 := z.DecBinary()
- _ = yym2839
+ yyv2843 := &x.Subsets
+ yym2844 := z.DecBinary()
+ _ = yym2844
if false {
} else {
- h.decSliceEndpointSubset((*[]EndpointSubset)(yyv2838), d)
+ h.decSliceEndpointSubset((*[]EndpointSubset)(yyv2843), d)
}
}
for {
- yyj2834++
- if yyhl2834 {
- yyb2834 = yyj2834 > l
+ yyj2839++
+ if yyhl2839 {
+ yyb2839 = yyj2839 > l
} else {
- yyb2834 = r.CheckBreak()
+ yyb2839 = r.CheckBreak()
}
- if yyb2834 {
+ if yyb2839 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj2834-1, "")
+ z.DecStructFieldNotFound(yyj2839-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -36754,40 +36818,40 @@ func (x *EndpointSubset) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym2840 := z.EncBinary()
- _ = yym2840
+ yym2845 := z.EncBinary()
+ _ = yym2845
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep2841 := !z.EncBinary()
- yy2arr2841 := z.EncBasicHandle().StructToArray
- var yyq2841 [3]bool
- _, _, _ = yysep2841, yyq2841, yy2arr2841
- const yyr2841 bool = false
- yyq2841[0] = len(x.Addresses) != 0
- yyq2841[1] = len(x.NotReadyAddresses) != 0
- yyq2841[2] = len(x.Ports) != 0
- var yynn2841 int
- if yyr2841 || yy2arr2841 {
+ yysep2846 := !z.EncBinary()
+ yy2arr2846 := z.EncBasicHandle().StructToArray
+ var yyq2846 [3]bool
+ _, _, _ = yysep2846, yyq2846, yy2arr2846
+ const yyr2846 bool = false
+ yyq2846[0] = len(x.Addresses) != 0
+ yyq2846[1] = len(x.NotReadyAddresses) != 0
+ yyq2846[2] = len(x.Ports) != 0
+ var yynn2846 int
+ if yyr2846 || yy2arr2846 {
r.EncodeArrayStart(3)
} else {
- yynn2841 = 0
- for _, b := range yyq2841 {
+ yynn2846 = 0
+ for _, b := range yyq2846 {
if b {
- yynn2841++
+ yynn2846++
}
}
- r.EncodeMapStart(yynn2841)
- yynn2841 = 0
+ r.EncodeMapStart(yynn2846)
+ yynn2846 = 0
}
- if yyr2841 || yy2arr2841 {
+ if yyr2846 || yy2arr2846 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2841[0] {
+ if yyq2846[0] {
if x.Addresses == nil {
r.EncodeNil()
} else {
- yym2843 := z.EncBinary()
- _ = yym2843
+ yym2848 := z.EncBinary()
+ _ = yym2848
if false {
} else {
h.encSliceEndpointAddress(([]EndpointAddress)(x.Addresses), e)
@@ -36797,15 +36861,15 @@ func (x *EndpointSubset) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeNil()
}
} else {
- if yyq2841[0] {
+ if yyq2846[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("addresses"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
if x.Addresses == nil {
r.EncodeNil()
} else {
- yym2844 := z.EncBinary()
- _ = yym2844
+ yym2849 := z.EncBinary()
+ _ = yym2849
if false {
} else {
h.encSliceEndpointAddress(([]EndpointAddress)(x.Addresses), e)
@@ -36813,14 +36877,14 @@ func (x *EndpointSubset) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
- if yyr2841 || yy2arr2841 {
+ if yyr2846 || yy2arr2846 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2841[1] {
+ if yyq2846[1] {
if x.NotReadyAddresses == nil {
r.EncodeNil()
} else {
- yym2846 := z.EncBinary()
- _ = yym2846
+ yym2851 := z.EncBinary()
+ _ = yym2851
if false {
} else {
h.encSliceEndpointAddress(([]EndpointAddress)(x.NotReadyAddresses), e)
@@ -36830,15 +36894,15 @@ func (x *EndpointSubset) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeNil()
}
} else {
- if yyq2841[1] {
+ if yyq2846[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("notReadyAddresses"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
if x.NotReadyAddresses == nil {
r.EncodeNil()
} else {
- yym2847 := z.EncBinary()
- _ = yym2847
+ yym2852 := z.EncBinary()
+ _ = yym2852
if false {
} else {
h.encSliceEndpointAddress(([]EndpointAddress)(x.NotReadyAddresses), e)
@@ -36846,14 +36910,14 @@ func (x *EndpointSubset) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
- if yyr2841 || yy2arr2841 {
+ if yyr2846 || yy2arr2846 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2841[2] {
+ if yyq2846[2] {
if x.Ports == nil {
r.EncodeNil()
} else {
- yym2849 := z.EncBinary()
- _ = yym2849
+ yym2854 := z.EncBinary()
+ _ = yym2854
if false {
} else {
h.encSliceEndpointPort(([]EndpointPort)(x.Ports), e)
@@ -36863,15 +36927,15 @@ func (x *EndpointSubset) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeNil()
}
} else {
- if yyq2841[2] {
+ if yyq2846[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("ports"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
if x.Ports == nil {
r.EncodeNil()
} else {
- yym2850 := z.EncBinary()
- _ = yym2850
+ yym2855 := z.EncBinary()
+ _ = yym2855
if false {
} else {
h.encSliceEndpointPort(([]EndpointPort)(x.Ports), e)
@@ -36879,7 +36943,7 @@ func (x *EndpointSubset) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
- if yyr2841 || yy2arr2841 {
+ if yyr2846 || yy2arr2846 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -36892,25 +36956,25 @@ func (x *EndpointSubset) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym2851 := z.DecBinary()
- _ = yym2851
+ yym2856 := z.DecBinary()
+ _ = yym2856
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct2852 := r.ContainerType()
- if yyct2852 == codecSelferValueTypeMap1234 {
- yyl2852 := r.ReadMapStart()
- if yyl2852 == 0 {
+ yyct2857 := r.ContainerType()
+ if yyct2857 == codecSelferValueTypeMap1234 {
+ yyl2857 := r.ReadMapStart()
+ if yyl2857 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl2852, d)
+ x.codecDecodeSelfFromMap(yyl2857, d)
}
- } else if yyct2852 == codecSelferValueTypeArray1234 {
- yyl2852 := r.ReadArrayStart()
- if yyl2852 == 0 {
+ } else if yyct2857 == codecSelferValueTypeArray1234 {
+ yyl2857 := r.ReadArrayStart()
+ if yyl2857 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl2852, d)
+ x.codecDecodeSelfFromArray(yyl2857, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -36922,12 +36986,12 @@ func (x *EndpointSubset) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys2853Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys2853Slc
- var yyhl2853 bool = l >= 0
- for yyj2853 := 0; ; yyj2853++ {
- if yyhl2853 {
- if yyj2853 >= l {
+ var yys2858Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys2858Slc
+ var yyhl2858 bool = l >= 0
+ for yyj2858 := 0; ; yyj2858++ {
+ if yyhl2858 {
+ if yyj2858 >= l {
break
}
} else {
@@ -36936,50 +37000,50 @@ func (x *EndpointSubset) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys2853Slc = r.DecodeBytes(yys2853Slc, true, true)
- yys2853 := string(yys2853Slc)
+ yys2858Slc = r.DecodeBytes(yys2858Slc, true, true)
+ yys2858 := string(yys2858Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys2853 {
+ switch yys2858 {
case "addresses":
if r.TryDecodeAsNil() {
x.Addresses = nil
} else {
- yyv2854 := &x.Addresses
- yym2855 := z.DecBinary()
- _ = yym2855
+ yyv2859 := &x.Addresses
+ yym2860 := z.DecBinary()
+ _ = yym2860
if false {
} else {
- h.decSliceEndpointAddress((*[]EndpointAddress)(yyv2854), d)
+ h.decSliceEndpointAddress((*[]EndpointAddress)(yyv2859), d)
}
}
case "notReadyAddresses":
if r.TryDecodeAsNil() {
x.NotReadyAddresses = nil
} else {
- yyv2856 := &x.NotReadyAddresses
- yym2857 := z.DecBinary()
- _ = yym2857
+ yyv2861 := &x.NotReadyAddresses
+ yym2862 := z.DecBinary()
+ _ = yym2862
if false {
} else {
- h.decSliceEndpointAddress((*[]EndpointAddress)(yyv2856), d)
+ h.decSliceEndpointAddress((*[]EndpointAddress)(yyv2861), d)
}
}
case "ports":
if r.TryDecodeAsNil() {
x.Ports = nil
} else {
- yyv2858 := &x.Ports
- yym2859 := z.DecBinary()
- _ = yym2859
+ yyv2863 := &x.Ports
+ yym2864 := z.DecBinary()
+ _ = yym2864
if false {
} else {
- h.decSliceEndpointPort((*[]EndpointPort)(yyv2858), d)
+ h.decSliceEndpointPort((*[]EndpointPort)(yyv2863), d)
}
}
default:
- z.DecStructFieldNotFound(-1, yys2853)
- } // end switch yys2853
- } // end for yyj2853
+ z.DecStructFieldNotFound(-1, yys2858)
+ } // end switch yys2858
+ } // end for yyj2858
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -36987,16 +37051,16 @@ func (x *EndpointSubset) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj2860 int
- var yyb2860 bool
- var yyhl2860 bool = l >= 0
- yyj2860++
- if yyhl2860 {
- yyb2860 = yyj2860 > l
+ var yyj2865 int
+ var yyb2865 bool
+ var yyhl2865 bool = l >= 0
+ yyj2865++
+ if yyhl2865 {
+ yyb2865 = yyj2865 > l
} else {
- yyb2860 = r.CheckBreak()
+ yyb2865 = r.CheckBreak()
}
- if yyb2860 {
+ if yyb2865 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -37004,21 +37068,21 @@ func (x *EndpointSubset) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Addresses = nil
} else {
- yyv2861 := &x.Addresses
- yym2862 := z.DecBinary()
- _ = yym2862
+ yyv2866 := &x.Addresses
+ yym2867 := z.DecBinary()
+ _ = yym2867
if false {
} else {
- h.decSliceEndpointAddress((*[]EndpointAddress)(yyv2861), d)
+ h.decSliceEndpointAddress((*[]EndpointAddress)(yyv2866), d)
}
}
- yyj2860++
- if yyhl2860 {
- yyb2860 = yyj2860 > l
+ yyj2865++
+ if yyhl2865 {
+ yyb2865 = yyj2865 > l
} else {
- yyb2860 = r.CheckBreak()
+ yyb2865 = r.CheckBreak()
}
- if yyb2860 {
+ if yyb2865 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -37026,21 +37090,21 @@ func (x *EndpointSubset) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.NotReadyAddresses = nil
} else {
- yyv2863 := &x.NotReadyAddresses
- yym2864 := z.DecBinary()
- _ = yym2864
+ yyv2868 := &x.NotReadyAddresses
+ yym2869 := z.DecBinary()
+ _ = yym2869
if false {
} else {
- h.decSliceEndpointAddress((*[]EndpointAddress)(yyv2863), d)
+ h.decSliceEndpointAddress((*[]EndpointAddress)(yyv2868), d)
}
}
- yyj2860++
- if yyhl2860 {
- yyb2860 = yyj2860 > l
+ yyj2865++
+ if yyhl2865 {
+ yyb2865 = yyj2865 > l
} else {
- yyb2860 = r.CheckBreak()
+ yyb2865 = r.CheckBreak()
}
- if yyb2860 {
+ if yyb2865 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -37048,26 +37112,26 @@ func (x *EndpointSubset) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Ports = nil
} else {
- yyv2865 := &x.Ports
- yym2866 := z.DecBinary()
- _ = yym2866
+ yyv2870 := &x.Ports
+ yym2871 := z.DecBinary()
+ _ = yym2871
if false {
} else {
- h.decSliceEndpointPort((*[]EndpointPort)(yyv2865), d)
+ h.decSliceEndpointPort((*[]EndpointPort)(yyv2870), d)
}
}
for {
- yyj2860++
- if yyhl2860 {
- yyb2860 = yyj2860 > l
+ yyj2865++
+ if yyhl2865 {
+ yyb2865 = yyj2865 > l
} else {
- yyb2860 = r.CheckBreak()
+ yyb2865 = r.CheckBreak()
}
- if yyb2860 {
+ if yyb2865 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj2860-1, "")
+ z.DecStructFieldNotFound(yyj2865-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -37079,36 +37143,36 @@ func (x *EndpointAddress) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym2867 := z.EncBinary()
- _ = yym2867
+ yym2872 := z.EncBinary()
+ _ = yym2872
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep2868 := !z.EncBinary()
- yy2arr2868 := z.EncBasicHandle().StructToArray
- var yyq2868 [4]bool
- _, _, _ = yysep2868, yyq2868, yy2arr2868
- const yyr2868 bool = false
- yyq2868[1] = x.Hostname != ""
- yyq2868[2] = x.NodeName != nil
- yyq2868[3] = x.TargetRef != nil
- var yynn2868 int
- if yyr2868 || yy2arr2868 {
+ yysep2873 := !z.EncBinary()
+ yy2arr2873 := z.EncBasicHandle().StructToArray
+ var yyq2873 [4]bool
+ _, _, _ = yysep2873, yyq2873, yy2arr2873
+ const yyr2873 bool = false
+ yyq2873[1] = x.Hostname != ""
+ yyq2873[2] = x.NodeName != nil
+ yyq2873[3] = x.TargetRef != nil
+ var yynn2873 int
+ if yyr2873 || yy2arr2873 {
r.EncodeArrayStart(4)
} else {
- yynn2868 = 1
- for _, b := range yyq2868 {
+ yynn2873 = 1
+ for _, b := range yyq2873 {
if b {
- yynn2868++
+ yynn2873++
}
}
- r.EncodeMapStart(yynn2868)
- yynn2868 = 0
+ r.EncodeMapStart(yynn2873)
+ yynn2873 = 0
}
- if yyr2868 || yy2arr2868 {
+ if yyr2873 || yy2arr2873 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym2870 := z.EncBinary()
- _ = yym2870
+ yym2875 := z.EncBinary()
+ _ = yym2875
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.IP))
@@ -37117,18 +37181,18 @@ func (x *EndpointAddress) CodecEncodeSelf(e *codec1978.Encoder) {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("ip"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym2871 := z.EncBinary()
- _ = yym2871
+ yym2876 := z.EncBinary()
+ _ = yym2876
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.IP))
}
}
- if yyr2868 || yy2arr2868 {
+ if yyr2873 || yy2arr2873 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2868[1] {
- yym2873 := z.EncBinary()
- _ = yym2873
+ if yyq2873[1] {
+ yym2878 := z.EncBinary()
+ _ = yym2878
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Hostname))
@@ -37137,56 +37201,56 @@ func (x *EndpointAddress) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2868[1] {
+ if yyq2873[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("hostname"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym2874 := z.EncBinary()
- _ = yym2874
+ yym2879 := z.EncBinary()
+ _ = yym2879
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Hostname))
}
}
}
- if yyr2868 || yy2arr2868 {
+ if yyr2873 || yy2arr2873 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2868[2] {
+ if yyq2873[2] {
if x.NodeName == nil {
r.EncodeNil()
} else {
- yy2876 := *x.NodeName
- yym2877 := z.EncBinary()
- _ = yym2877
+ yy2881 := *x.NodeName
+ yym2882 := z.EncBinary()
+ _ = yym2882
if false {
} else {
- r.EncodeString(codecSelferC_UTF81234, string(yy2876))
+ r.EncodeString(codecSelferC_UTF81234, string(yy2881))
}
}
} else {
r.EncodeNil()
}
} else {
- if yyq2868[2] {
+ if yyq2873[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("nodeName"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
if x.NodeName == nil {
r.EncodeNil()
} else {
- yy2878 := *x.NodeName
- yym2879 := z.EncBinary()
- _ = yym2879
+ yy2883 := *x.NodeName
+ yym2884 := z.EncBinary()
+ _ = yym2884
if false {
} else {
- r.EncodeString(codecSelferC_UTF81234, string(yy2878))
+ r.EncodeString(codecSelferC_UTF81234, string(yy2883))
}
}
}
}
- if yyr2868 || yy2arr2868 {
+ if yyr2873 || yy2arr2873 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2868[3] {
+ if yyq2873[3] {
if x.TargetRef == nil {
r.EncodeNil()
} else {
@@ -37196,7 +37260,7 @@ func (x *EndpointAddress) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeNil()
}
} else {
- if yyq2868[3] {
+ if yyq2873[3] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("targetRef"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
@@ -37207,7 +37271,7 @@ func (x *EndpointAddress) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
- if yyr2868 || yy2arr2868 {
+ if yyr2873 || yy2arr2873 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -37220,25 +37284,25 @@ func (x *EndpointAddress) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym2881 := z.DecBinary()
- _ = yym2881
+ yym2886 := z.DecBinary()
+ _ = yym2886
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct2882 := r.ContainerType()
- if yyct2882 == codecSelferValueTypeMap1234 {
- yyl2882 := r.ReadMapStart()
- if yyl2882 == 0 {
+ yyct2887 := r.ContainerType()
+ if yyct2887 == codecSelferValueTypeMap1234 {
+ yyl2887 := r.ReadMapStart()
+ if yyl2887 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl2882, d)
+ x.codecDecodeSelfFromMap(yyl2887, d)
}
- } else if yyct2882 == codecSelferValueTypeArray1234 {
- yyl2882 := r.ReadArrayStart()
- if yyl2882 == 0 {
+ } else if yyct2887 == codecSelferValueTypeArray1234 {
+ yyl2887 := r.ReadArrayStart()
+ if yyl2887 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl2882, d)
+ x.codecDecodeSelfFromArray(yyl2887, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -37250,12 +37314,12 @@ func (x *EndpointAddress) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys2883Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys2883Slc
- var yyhl2883 bool = l >= 0
- for yyj2883 := 0; ; yyj2883++ {
- if yyhl2883 {
- if yyj2883 >= l {
+ var yys2888Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys2888Slc
+ var yyhl2888 bool = l >= 0
+ for yyj2888 := 0; ; yyj2888++ {
+ if yyhl2888 {
+ if yyj2888 >= l {
break
}
} else {
@@ -37264,10 +37328,10 @@ func (x *EndpointAddress) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys2883Slc = r.DecodeBytes(yys2883Slc, true, true)
- yys2883 := string(yys2883Slc)
+ yys2888Slc = r.DecodeBytes(yys2888Slc, true, true)
+ yys2888 := string(yys2888Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys2883 {
+ switch yys2888 {
case "ip":
if r.TryDecodeAsNil() {
x.IP = ""
@@ -37289,8 +37353,8 @@ func (x *EndpointAddress) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
if x.NodeName == nil {
x.NodeName = new(string)
}
- yym2887 := z.DecBinary()
- _ = yym2887
+ yym2892 := z.DecBinary()
+ _ = yym2892
if false {
} else {
*((*string)(x.NodeName)) = r.DecodeString()
@@ -37308,9 +37372,9 @@ func (x *EndpointAddress) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
x.TargetRef.CodecDecodeSelf(d)
}
default:
- z.DecStructFieldNotFound(-1, yys2883)
- } // end switch yys2883
- } // end for yyj2883
+ z.DecStructFieldNotFound(-1, yys2888)
+ } // end switch yys2888
+ } // end for yyj2888
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -37318,16 +37382,16 @@ func (x *EndpointAddress) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj2889 int
- var yyb2889 bool
- var yyhl2889 bool = l >= 0
- yyj2889++
- if yyhl2889 {
- yyb2889 = yyj2889 > l
+ var yyj2894 int
+ var yyb2894 bool
+ var yyhl2894 bool = l >= 0
+ yyj2894++
+ if yyhl2894 {
+ yyb2894 = yyj2894 > l
} else {
- yyb2889 = r.CheckBreak()
+ yyb2894 = r.CheckBreak()
}
- if yyb2889 {
+ if yyb2894 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -37337,13 +37401,13 @@ func (x *EndpointAddress) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
} else {
x.IP = string(r.DecodeString())
}
- yyj2889++
- if yyhl2889 {
- yyb2889 = yyj2889 > l
+ yyj2894++
+ if yyhl2894 {
+ yyb2894 = yyj2894 > l
} else {
- yyb2889 = r.CheckBreak()
+ yyb2894 = r.CheckBreak()
}
- if yyb2889 {
+ if yyb2894 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -37353,13 +37417,13 @@ func (x *EndpointAddress) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
} else {
x.Hostname = string(r.DecodeString())
}
- yyj2889++
- if yyhl2889 {
- yyb2889 = yyj2889 > l
+ yyj2894++
+ if yyhl2894 {
+ yyb2894 = yyj2894 > l
} else {
- yyb2889 = r.CheckBreak()
+ yyb2894 = r.CheckBreak()
}
- if yyb2889 {
+ if yyb2894 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -37372,20 +37436,20 @@ func (x *EndpointAddress) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
if x.NodeName == nil {
x.NodeName = new(string)
}
- yym2893 := z.DecBinary()
- _ = yym2893
+ yym2898 := z.DecBinary()
+ _ = yym2898
if false {
} else {
*((*string)(x.NodeName)) = r.DecodeString()
}
}
- yyj2889++
- if yyhl2889 {
- yyb2889 = yyj2889 > l
+ yyj2894++
+ if yyhl2894 {
+ yyb2894 = yyj2894 > l
} else {
- yyb2889 = r.CheckBreak()
+ yyb2894 = r.CheckBreak()
}
- if yyb2889 {
+ if yyb2894 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -37401,17 +37465,17 @@ func (x *EndpointAddress) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
x.TargetRef.CodecDecodeSelf(d)
}
for {
- yyj2889++
- if yyhl2889 {
- yyb2889 = yyj2889 > l
+ yyj2894++
+ if yyhl2894 {
+ yyb2894 = yyj2894 > l
} else {
- yyb2889 = r.CheckBreak()
+ yyb2894 = r.CheckBreak()
}
- if yyb2889 {
+ if yyb2894 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj2889-1, "")
+ z.DecStructFieldNotFound(yyj2894-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -37423,36 +37487,36 @@ func (x *EndpointPort) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym2895 := z.EncBinary()
- _ = yym2895
+ yym2900 := z.EncBinary()
+ _ = yym2900
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep2896 := !z.EncBinary()
- yy2arr2896 := z.EncBasicHandle().StructToArray
- var yyq2896 [3]bool
- _, _, _ = yysep2896, yyq2896, yy2arr2896
- const yyr2896 bool = false
- yyq2896[0] = x.Name != ""
- yyq2896[2] = x.Protocol != ""
- var yynn2896 int
- if yyr2896 || yy2arr2896 {
+ yysep2901 := !z.EncBinary()
+ yy2arr2901 := z.EncBasicHandle().StructToArray
+ var yyq2901 [3]bool
+ _, _, _ = yysep2901, yyq2901, yy2arr2901
+ const yyr2901 bool = false
+ yyq2901[0] = x.Name != ""
+ yyq2901[2] = x.Protocol != ""
+ var yynn2901 int
+ if yyr2901 || yy2arr2901 {
r.EncodeArrayStart(3)
} else {
- yynn2896 = 1
- for _, b := range yyq2896 {
+ yynn2901 = 1
+ for _, b := range yyq2901 {
if b {
- yynn2896++
+ yynn2901++
}
}
- r.EncodeMapStart(yynn2896)
- yynn2896 = 0
+ r.EncodeMapStart(yynn2901)
+ yynn2901 = 0
}
- if yyr2896 || yy2arr2896 {
+ if yyr2901 || yy2arr2901 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2896[0] {
- yym2898 := z.EncBinary()
- _ = yym2898
+ if yyq2901[0] {
+ yym2903 := z.EncBinary()
+ _ = yym2903
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Name))
@@ -37461,22 +37525,22 @@ func (x *EndpointPort) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2896[0] {
+ if yyq2901[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("name"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym2899 := z.EncBinary()
- _ = yym2899
+ yym2904 := z.EncBinary()
+ _ = yym2904
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Name))
}
}
}
- if yyr2896 || yy2arr2896 {
+ if yyr2901 || yy2arr2901 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym2901 := z.EncBinary()
- _ = yym2901
+ yym2906 := z.EncBinary()
+ _ = yym2906
if false {
} else {
r.EncodeInt(int64(x.Port))
@@ -37485,29 +37549,29 @@ func (x *EndpointPort) CodecEncodeSelf(e *codec1978.Encoder) {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("port"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym2902 := z.EncBinary()
- _ = yym2902
+ yym2907 := z.EncBinary()
+ _ = yym2907
if false {
} else {
r.EncodeInt(int64(x.Port))
}
}
- if yyr2896 || yy2arr2896 {
+ if yyr2901 || yy2arr2901 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2896[2] {
+ if yyq2901[2] {
x.Protocol.CodecEncodeSelf(e)
} else {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2896[2] {
+ if yyq2901[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("protocol"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
x.Protocol.CodecEncodeSelf(e)
}
}
- if yyr2896 || yy2arr2896 {
+ if yyr2901 || yy2arr2901 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -37520,25 +37584,25 @@ func (x *EndpointPort) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym2904 := z.DecBinary()
- _ = yym2904
+ yym2909 := z.DecBinary()
+ _ = yym2909
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct2905 := r.ContainerType()
- if yyct2905 == codecSelferValueTypeMap1234 {
- yyl2905 := r.ReadMapStart()
- if yyl2905 == 0 {
+ yyct2910 := r.ContainerType()
+ if yyct2910 == codecSelferValueTypeMap1234 {
+ yyl2910 := r.ReadMapStart()
+ if yyl2910 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl2905, d)
+ x.codecDecodeSelfFromMap(yyl2910, d)
}
- } else if yyct2905 == codecSelferValueTypeArray1234 {
- yyl2905 := r.ReadArrayStart()
- if yyl2905 == 0 {
+ } else if yyct2910 == codecSelferValueTypeArray1234 {
+ yyl2910 := r.ReadArrayStart()
+ if yyl2910 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl2905, d)
+ x.codecDecodeSelfFromArray(yyl2910, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -37550,12 +37614,12 @@ func (x *EndpointPort) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys2906Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys2906Slc
- var yyhl2906 bool = l >= 0
- for yyj2906 := 0; ; yyj2906++ {
- if yyhl2906 {
- if yyj2906 >= l {
+ var yys2911Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys2911Slc
+ var yyhl2911 bool = l >= 0
+ for yyj2911 := 0; ; yyj2911++ {
+ if yyhl2911 {
+ if yyj2911 >= l {
break
}
} else {
@@ -37564,10 +37628,10 @@ func (x *EndpointPort) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys2906Slc = r.DecodeBytes(yys2906Slc, true, true)
- yys2906 := string(yys2906Slc)
+ yys2911Slc = r.DecodeBytes(yys2911Slc, true, true)
+ yys2911 := string(yys2911Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys2906 {
+ switch yys2911 {
case "name":
if r.TryDecodeAsNil() {
x.Name = ""
@@ -37587,9 +37651,9 @@ func (x *EndpointPort) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
x.Protocol = Protocol(r.DecodeString())
}
default:
- z.DecStructFieldNotFound(-1, yys2906)
- } // end switch yys2906
- } // end for yyj2906
+ z.DecStructFieldNotFound(-1, yys2911)
+ } // end switch yys2911
+ } // end for yyj2911
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -37597,16 +37661,16 @@ func (x *EndpointPort) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj2910 int
- var yyb2910 bool
- var yyhl2910 bool = l >= 0
- yyj2910++
- if yyhl2910 {
- yyb2910 = yyj2910 > l
+ var yyj2915 int
+ var yyb2915 bool
+ var yyhl2915 bool = l >= 0
+ yyj2915++
+ if yyhl2915 {
+ yyb2915 = yyj2915 > l
} else {
- yyb2910 = r.CheckBreak()
+ yyb2915 = r.CheckBreak()
}
- if yyb2910 {
+ if yyb2915 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -37616,13 +37680,13 @@ func (x *EndpointPort) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Name = string(r.DecodeString())
}
- yyj2910++
- if yyhl2910 {
- yyb2910 = yyj2910 > l
+ yyj2915++
+ if yyhl2915 {
+ yyb2915 = yyj2915 > l
} else {
- yyb2910 = r.CheckBreak()
+ yyb2915 = r.CheckBreak()
}
- if yyb2910 {
+ if yyb2915 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -37632,13 +37696,13 @@ func (x *EndpointPort) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Port = int32(r.DecodeInt(32))
}
- yyj2910++
- if yyhl2910 {
- yyb2910 = yyj2910 > l
+ yyj2915++
+ if yyhl2915 {
+ yyb2915 = yyj2915 > l
} else {
- yyb2910 = r.CheckBreak()
+ yyb2915 = r.CheckBreak()
}
- if yyb2910 {
+ if yyb2915 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -37649,17 +37713,17 @@ func (x *EndpointPort) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
x.Protocol = Protocol(r.DecodeString())
}
for {
- yyj2910++
- if yyhl2910 {
- yyb2910 = yyj2910 > l
+ yyj2915++
+ if yyhl2915 {
+ yyb2915 = yyj2915 > l
} else {
- yyb2910 = r.CheckBreak()
+ yyb2915 = r.CheckBreak()
}
- if yyb2910 {
+ if yyb2915 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj2910-1, "")
+ z.DecStructFieldNotFound(yyj2915-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -37671,37 +37735,37 @@ func (x *EndpointsList) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym2914 := z.EncBinary()
- _ = yym2914
+ yym2919 := z.EncBinary()
+ _ = yym2919
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep2915 := !z.EncBinary()
- yy2arr2915 := z.EncBasicHandle().StructToArray
- var yyq2915 [4]bool
- _, _, _ = yysep2915, yyq2915, yy2arr2915
- const yyr2915 bool = false
- yyq2915[0] = x.Kind != ""
- yyq2915[1] = x.APIVersion != ""
- yyq2915[2] = true
- var yynn2915 int
- if yyr2915 || yy2arr2915 {
+ yysep2920 := !z.EncBinary()
+ yy2arr2920 := z.EncBasicHandle().StructToArray
+ var yyq2920 [4]bool
+ _, _, _ = yysep2920, yyq2920, yy2arr2920
+ const yyr2920 bool = false
+ yyq2920[0] = x.Kind != ""
+ yyq2920[1] = x.APIVersion != ""
+ yyq2920[2] = true
+ var yynn2920 int
+ if yyr2920 || yy2arr2920 {
r.EncodeArrayStart(4)
} else {
- yynn2915 = 1
- for _, b := range yyq2915 {
+ yynn2920 = 1
+ for _, b := range yyq2920 {
if b {
- yynn2915++
+ yynn2920++
}
}
- r.EncodeMapStart(yynn2915)
- yynn2915 = 0
+ r.EncodeMapStart(yynn2920)
+ yynn2920 = 0
}
- if yyr2915 || yy2arr2915 {
+ if yyr2920 || yy2arr2920 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2915[0] {
- yym2917 := z.EncBinary()
- _ = yym2917
+ if yyq2920[0] {
+ yym2922 := z.EncBinary()
+ _ = yym2922
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
@@ -37710,23 +37774,23 @@ func (x *EndpointsList) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2915[0] {
+ if yyq2920[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("kind"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym2918 := z.EncBinary()
- _ = yym2918
+ yym2923 := z.EncBinary()
+ _ = yym2923
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
}
}
}
- if yyr2915 || yy2arr2915 {
+ if yyr2920 || yy2arr2920 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2915[1] {
- yym2920 := z.EncBinary()
- _ = yym2920
+ if yyq2920[1] {
+ yym2925 := z.EncBinary()
+ _ = yym2925
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
@@ -37735,54 +37799,54 @@ func (x *EndpointsList) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2915[1] {
+ if yyq2920[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym2921 := z.EncBinary()
- _ = yym2921
+ yym2926 := z.EncBinary()
+ _ = yym2926
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
}
}
}
- if yyr2915 || yy2arr2915 {
+ if yyr2920 || yy2arr2920 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2915[2] {
- yy2923 := &x.ListMeta
- yym2924 := z.EncBinary()
- _ = yym2924
+ if yyq2920[2] {
+ yy2928 := &x.ListMeta
+ yym2929 := z.EncBinary()
+ _ = yym2929
if false {
- } else if z.HasExtensions() && z.EncExt(yy2923) {
+ } else if z.HasExtensions() && z.EncExt(yy2928) {
} else {
- z.EncFallback(yy2923)
+ z.EncFallback(yy2928)
}
} else {
r.EncodeNil()
}
} else {
- if yyq2915[2] {
+ if yyq2920[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("metadata"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy2925 := &x.ListMeta
- yym2926 := z.EncBinary()
- _ = yym2926
+ yy2930 := &x.ListMeta
+ yym2931 := z.EncBinary()
+ _ = yym2931
if false {
- } else if z.HasExtensions() && z.EncExt(yy2925) {
+ } else if z.HasExtensions() && z.EncExt(yy2930) {
} else {
- z.EncFallback(yy2925)
+ z.EncFallback(yy2930)
}
}
}
- if yyr2915 || yy2arr2915 {
+ if yyr2920 || yy2arr2920 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if x.Items == nil {
r.EncodeNil()
} else {
- yym2928 := z.EncBinary()
- _ = yym2928
+ yym2933 := z.EncBinary()
+ _ = yym2933
if false {
} else {
h.encSliceEndpoints(([]Endpoints)(x.Items), e)
@@ -37795,15 +37859,15 @@ func (x *EndpointsList) CodecEncodeSelf(e *codec1978.Encoder) {
if x.Items == nil {
r.EncodeNil()
} else {
- yym2929 := z.EncBinary()
- _ = yym2929
+ yym2934 := z.EncBinary()
+ _ = yym2934
if false {
} else {
h.encSliceEndpoints(([]Endpoints)(x.Items), e)
}
}
}
- if yyr2915 || yy2arr2915 {
+ if yyr2920 || yy2arr2920 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -37816,25 +37880,25 @@ func (x *EndpointsList) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym2930 := z.DecBinary()
- _ = yym2930
+ yym2935 := z.DecBinary()
+ _ = yym2935
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct2931 := r.ContainerType()
- if yyct2931 == codecSelferValueTypeMap1234 {
- yyl2931 := r.ReadMapStart()
- if yyl2931 == 0 {
+ yyct2936 := r.ContainerType()
+ if yyct2936 == codecSelferValueTypeMap1234 {
+ yyl2936 := r.ReadMapStart()
+ if yyl2936 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl2931, d)
+ x.codecDecodeSelfFromMap(yyl2936, d)
}
- } else if yyct2931 == codecSelferValueTypeArray1234 {
- yyl2931 := r.ReadArrayStart()
- if yyl2931 == 0 {
+ } else if yyct2936 == codecSelferValueTypeArray1234 {
+ yyl2936 := r.ReadArrayStart()
+ if yyl2936 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl2931, d)
+ x.codecDecodeSelfFromArray(yyl2936, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -37846,12 +37910,12 @@ func (x *EndpointsList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys2932Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys2932Slc
- var yyhl2932 bool = l >= 0
- for yyj2932 := 0; ; yyj2932++ {
- if yyhl2932 {
- if yyj2932 >= l {
+ var yys2937Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys2937Slc
+ var yyhl2937 bool = l >= 0
+ for yyj2937 := 0; ; yyj2937++ {
+ if yyhl2937 {
+ if yyj2937 >= l {
break
}
} else {
@@ -37860,10 +37924,10 @@ func (x *EndpointsList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys2932Slc = r.DecodeBytes(yys2932Slc, true, true)
- yys2932 := string(yys2932Slc)
+ yys2937Slc = r.DecodeBytes(yys2937Slc, true, true)
+ yys2937 := string(yys2937Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys2932 {
+ switch yys2937 {
case "kind":
if r.TryDecodeAsNil() {
x.Kind = ""
@@ -37880,31 +37944,31 @@ func (x *EndpointsList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.ListMeta = pkg2_v1.ListMeta{}
} else {
- yyv2935 := &x.ListMeta
- yym2936 := z.DecBinary()
- _ = yym2936
+ yyv2940 := &x.ListMeta
+ yym2941 := z.DecBinary()
+ _ = yym2941
if false {
- } else if z.HasExtensions() && z.DecExt(yyv2935) {
+ } else if z.HasExtensions() && z.DecExt(yyv2940) {
} else {
- z.DecFallback(yyv2935, false)
+ z.DecFallback(yyv2940, false)
}
}
case "items":
if r.TryDecodeAsNil() {
x.Items = nil
} else {
- yyv2937 := &x.Items
- yym2938 := z.DecBinary()
- _ = yym2938
+ yyv2942 := &x.Items
+ yym2943 := z.DecBinary()
+ _ = yym2943
if false {
} else {
- h.decSliceEndpoints((*[]Endpoints)(yyv2937), d)
+ h.decSliceEndpoints((*[]Endpoints)(yyv2942), d)
}
}
default:
- z.DecStructFieldNotFound(-1, yys2932)
- } // end switch yys2932
- } // end for yyj2932
+ z.DecStructFieldNotFound(-1, yys2937)
+ } // end switch yys2937
+ } // end for yyj2937
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -37912,16 +37976,16 @@ func (x *EndpointsList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj2939 int
- var yyb2939 bool
- var yyhl2939 bool = l >= 0
- yyj2939++
- if yyhl2939 {
- yyb2939 = yyj2939 > l
+ var yyj2944 int
+ var yyb2944 bool
+ var yyhl2944 bool = l >= 0
+ yyj2944++
+ if yyhl2944 {
+ yyb2944 = yyj2944 > l
} else {
- yyb2939 = r.CheckBreak()
+ yyb2944 = r.CheckBreak()
}
- if yyb2939 {
+ if yyb2944 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -37931,13 +37995,13 @@ func (x *EndpointsList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Kind = string(r.DecodeString())
}
- yyj2939++
- if yyhl2939 {
- yyb2939 = yyj2939 > l
+ yyj2944++
+ if yyhl2944 {
+ yyb2944 = yyj2944 > l
} else {
- yyb2939 = r.CheckBreak()
+ yyb2944 = r.CheckBreak()
}
- if yyb2939 {
+ if yyb2944 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -37947,13 +38011,13 @@ func (x *EndpointsList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.APIVersion = string(r.DecodeString())
}
- yyj2939++
- if yyhl2939 {
- yyb2939 = yyj2939 > l
+ yyj2944++
+ if yyhl2944 {
+ yyb2944 = yyj2944 > l
} else {
- yyb2939 = r.CheckBreak()
+ yyb2944 = r.CheckBreak()
}
- if yyb2939 {
+ if yyb2944 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -37961,22 +38025,22 @@ func (x *EndpointsList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.ListMeta = pkg2_v1.ListMeta{}
} else {
- yyv2942 := &x.ListMeta
- yym2943 := z.DecBinary()
- _ = yym2943
+ yyv2947 := &x.ListMeta
+ yym2948 := z.DecBinary()
+ _ = yym2948
if false {
- } else if z.HasExtensions() && z.DecExt(yyv2942) {
+ } else if z.HasExtensions() && z.DecExt(yyv2947) {
} else {
- z.DecFallback(yyv2942, false)
+ z.DecFallback(yyv2947, false)
}
}
- yyj2939++
- if yyhl2939 {
- yyb2939 = yyj2939 > l
+ yyj2944++
+ if yyhl2944 {
+ yyb2944 = yyj2944 > l
} else {
- yyb2939 = r.CheckBreak()
+ yyb2944 = r.CheckBreak()
}
- if yyb2939 {
+ if yyb2944 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -37984,26 +38048,26 @@ func (x *EndpointsList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Items = nil
} else {
- yyv2944 := &x.Items
- yym2945 := z.DecBinary()
- _ = yym2945
+ yyv2949 := &x.Items
+ yym2950 := z.DecBinary()
+ _ = yym2950
if false {
} else {
- h.decSliceEndpoints((*[]Endpoints)(yyv2944), d)
+ h.decSliceEndpoints((*[]Endpoints)(yyv2949), d)
}
}
for {
- yyj2939++
- if yyhl2939 {
- yyb2939 = yyj2939 > l
+ yyj2944++
+ if yyhl2944 {
+ yyb2944 = yyj2944 > l
} else {
- yyb2939 = r.CheckBreak()
+ yyb2944 = r.CheckBreak()
}
- if yyb2939 {
+ if yyb2944 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj2939-1, "")
+ z.DecStructFieldNotFound(yyj2944-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -38015,38 +38079,38 @@ func (x *NodeSpec) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym2946 := z.EncBinary()
- _ = yym2946
+ yym2951 := z.EncBinary()
+ _ = yym2951
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep2947 := !z.EncBinary()
- yy2arr2947 := z.EncBasicHandle().StructToArray
- var yyq2947 [4]bool
- _, _, _ = yysep2947, yyq2947, yy2arr2947
- const yyr2947 bool = false
- yyq2947[0] = x.PodCIDR != ""
- yyq2947[1] = x.ExternalID != ""
- yyq2947[2] = x.ProviderID != ""
- yyq2947[3] = x.Unschedulable != false
- var yynn2947 int
- if yyr2947 || yy2arr2947 {
+ yysep2952 := !z.EncBinary()
+ yy2arr2952 := z.EncBasicHandle().StructToArray
+ var yyq2952 [4]bool
+ _, _, _ = yysep2952, yyq2952, yy2arr2952
+ const yyr2952 bool = false
+ yyq2952[0] = x.PodCIDR != ""
+ yyq2952[1] = x.ExternalID != ""
+ yyq2952[2] = x.ProviderID != ""
+ yyq2952[3] = x.Unschedulable != false
+ var yynn2952 int
+ if yyr2952 || yy2arr2952 {
r.EncodeArrayStart(4)
} else {
- yynn2947 = 0
- for _, b := range yyq2947 {
+ yynn2952 = 0
+ for _, b := range yyq2952 {
if b {
- yynn2947++
+ yynn2952++
}
}
- r.EncodeMapStart(yynn2947)
- yynn2947 = 0
+ r.EncodeMapStart(yynn2952)
+ yynn2952 = 0
}
- if yyr2947 || yy2arr2947 {
+ if yyr2952 || yy2arr2952 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2947[0] {
- yym2949 := z.EncBinary()
- _ = yym2949
+ if yyq2952[0] {
+ yym2954 := z.EncBinary()
+ _ = yym2954
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.PodCIDR))
@@ -38055,49 +38119,49 @@ func (x *NodeSpec) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2947[0] {
+ if yyq2952[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("podCIDR"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym2950 := z.EncBinary()
- _ = yym2950
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.PodCIDR))
- }
- }
- }
- if yyr2947 || yy2arr2947 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2947[1] {
- yym2952 := z.EncBinary()
- _ = yym2952
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.ExternalID))
- }
- } else {
- r.EncodeString(codecSelferC_UTF81234, "")
- }
- } else {
- if yyq2947[1] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("externalID"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym2953 := z.EncBinary()
- _ = yym2953
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.ExternalID))
- }
- }
- }
- if yyr2947 || yy2arr2947 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2947[2] {
yym2955 := z.EncBinary()
_ = yym2955
if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.PodCIDR))
+ }
+ }
+ }
+ if yyr2952 || yy2arr2952 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2952[1] {
+ yym2957 := z.EncBinary()
+ _ = yym2957
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.ExternalID))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq2952[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("externalID"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym2958 := z.EncBinary()
+ _ = yym2958
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.ExternalID))
+ }
+ }
+ }
+ if yyr2952 || yy2arr2952 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq2952[2] {
+ yym2960 := z.EncBinary()
+ _ = yym2960
+ if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.ProviderID))
}
@@ -38105,23 +38169,23 @@ func (x *NodeSpec) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq2947[2] {
+ if yyq2952[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("providerID"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym2956 := z.EncBinary()
- _ = yym2956
+ yym2961 := z.EncBinary()
+ _ = yym2961
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.ProviderID))
}
}
}
- if yyr2947 || yy2arr2947 {
+ if yyr2952 || yy2arr2952 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2947[3] {
- yym2958 := z.EncBinary()
- _ = yym2958
+ if yyq2952[3] {
+ yym2963 := z.EncBinary()
+ _ = yym2963
if false {
} else {
r.EncodeBool(bool(x.Unschedulable))
@@ -38130,19 +38194,19 @@ func (x *NodeSpec) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeBool(false)
}
} else {
- if yyq2947[3] {
+ if yyq2952[3] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("unschedulable"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym2959 := z.EncBinary()
- _ = yym2959
+ yym2964 := z.EncBinary()
+ _ = yym2964
if false {
} else {
r.EncodeBool(bool(x.Unschedulable))
}
}
}
- if yyr2947 || yy2arr2947 {
+ if yyr2952 || yy2arr2952 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -38155,25 +38219,25 @@ func (x *NodeSpec) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym2960 := z.DecBinary()
- _ = yym2960
+ yym2965 := z.DecBinary()
+ _ = yym2965
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct2961 := r.ContainerType()
- if yyct2961 == codecSelferValueTypeMap1234 {
- yyl2961 := r.ReadMapStart()
- if yyl2961 == 0 {
+ yyct2966 := r.ContainerType()
+ if yyct2966 == codecSelferValueTypeMap1234 {
+ yyl2966 := r.ReadMapStart()
+ if yyl2966 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl2961, d)
+ x.codecDecodeSelfFromMap(yyl2966, d)
}
- } else if yyct2961 == codecSelferValueTypeArray1234 {
- yyl2961 := r.ReadArrayStart()
- if yyl2961 == 0 {
+ } else if yyct2966 == codecSelferValueTypeArray1234 {
+ yyl2966 := r.ReadArrayStart()
+ if yyl2966 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl2961, d)
+ x.codecDecodeSelfFromArray(yyl2966, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -38185,12 +38249,12 @@ func (x *NodeSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys2962Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys2962Slc
- var yyhl2962 bool = l >= 0
- for yyj2962 := 0; ; yyj2962++ {
- if yyhl2962 {
- if yyj2962 >= l {
+ var yys2967Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys2967Slc
+ var yyhl2967 bool = l >= 0
+ for yyj2967 := 0; ; yyj2967++ {
+ if yyhl2967 {
+ if yyj2967 >= l {
break
}
} else {
@@ -38199,10 +38263,10 @@ func (x *NodeSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys2962Slc = r.DecodeBytes(yys2962Slc, true, true)
- yys2962 := string(yys2962Slc)
+ yys2967Slc = r.DecodeBytes(yys2967Slc, true, true)
+ yys2967 := string(yys2967Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys2962 {
+ switch yys2967 {
case "podCIDR":
if r.TryDecodeAsNil() {
x.PodCIDR = ""
@@ -38228,9 +38292,9 @@ func (x *NodeSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
x.Unschedulable = bool(r.DecodeBool())
}
default:
- z.DecStructFieldNotFound(-1, yys2962)
- } // end switch yys2962
- } // end for yyj2962
+ z.DecStructFieldNotFound(-1, yys2967)
+ } // end switch yys2967
+ } // end for yyj2967
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -38238,16 +38302,16 @@ func (x *NodeSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj2967 int
- var yyb2967 bool
- var yyhl2967 bool = l >= 0
- yyj2967++
- if yyhl2967 {
- yyb2967 = yyj2967 > l
+ var yyj2972 int
+ var yyb2972 bool
+ var yyhl2972 bool = l >= 0
+ yyj2972++
+ if yyhl2972 {
+ yyb2972 = yyj2972 > l
} else {
- yyb2967 = r.CheckBreak()
+ yyb2972 = r.CheckBreak()
}
- if yyb2967 {
+ if yyb2972 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -38257,13 +38321,13 @@ func (x *NodeSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.PodCIDR = string(r.DecodeString())
}
- yyj2967++
- if yyhl2967 {
- yyb2967 = yyj2967 > l
+ yyj2972++
+ if yyhl2972 {
+ yyb2972 = yyj2972 > l
} else {
- yyb2967 = r.CheckBreak()
+ yyb2972 = r.CheckBreak()
}
- if yyb2967 {
+ if yyb2972 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -38273,13 +38337,13 @@ func (x *NodeSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.ExternalID = string(r.DecodeString())
}
- yyj2967++
- if yyhl2967 {
- yyb2967 = yyj2967 > l
+ yyj2972++
+ if yyhl2972 {
+ yyb2972 = yyj2972 > l
} else {
- yyb2967 = r.CheckBreak()
+ yyb2972 = r.CheckBreak()
}
- if yyb2967 {
+ if yyb2972 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -38289,13 +38353,13 @@ func (x *NodeSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.ProviderID = string(r.DecodeString())
}
- yyj2967++
- if yyhl2967 {
- yyb2967 = yyj2967 > l
+ yyj2972++
+ if yyhl2972 {
+ yyb2972 = yyj2972 > l
} else {
- yyb2967 = r.CheckBreak()
+ yyb2972 = r.CheckBreak()
}
- if yyb2967 {
+ if yyb2972 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -38306,17 +38370,17 @@ func (x *NodeSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
x.Unschedulable = bool(r.DecodeBool())
}
for {
- yyj2967++
- if yyhl2967 {
- yyb2967 = yyj2967 > l
+ yyj2972++
+ if yyhl2972 {
+ yyb2972 = yyj2972 > l
} else {
- yyb2967 = r.CheckBreak()
+ yyb2972 = r.CheckBreak()
}
- if yyb2967 {
+ if yyb2972 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj2967-1, "")
+ z.DecStructFieldNotFound(yyj2972-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -38328,33 +38392,33 @@ func (x *DaemonEndpoint) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym2972 := z.EncBinary()
- _ = yym2972
+ yym2977 := z.EncBinary()
+ _ = yym2977
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep2973 := !z.EncBinary()
- yy2arr2973 := z.EncBasicHandle().StructToArray
- var yyq2973 [1]bool
- _, _, _ = yysep2973, yyq2973, yy2arr2973
- const yyr2973 bool = false
- var yynn2973 int
- if yyr2973 || yy2arr2973 {
+ yysep2978 := !z.EncBinary()
+ yy2arr2978 := z.EncBasicHandle().StructToArray
+ var yyq2978 [1]bool
+ _, _, _ = yysep2978, yyq2978, yy2arr2978
+ const yyr2978 bool = false
+ var yynn2978 int
+ if yyr2978 || yy2arr2978 {
r.EncodeArrayStart(1)
} else {
- yynn2973 = 1
- for _, b := range yyq2973 {
+ yynn2978 = 1
+ for _, b := range yyq2978 {
if b {
- yynn2973++
+ yynn2978++
}
}
- r.EncodeMapStart(yynn2973)
- yynn2973 = 0
+ r.EncodeMapStart(yynn2978)
+ yynn2978 = 0
}
- if yyr2973 || yy2arr2973 {
+ if yyr2978 || yy2arr2978 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym2975 := z.EncBinary()
- _ = yym2975
+ yym2980 := z.EncBinary()
+ _ = yym2980
if false {
} else {
r.EncodeInt(int64(x.Port))
@@ -38363,14 +38427,14 @@ func (x *DaemonEndpoint) CodecEncodeSelf(e *codec1978.Encoder) {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("Port"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym2976 := z.EncBinary()
- _ = yym2976
+ yym2981 := z.EncBinary()
+ _ = yym2981
if false {
} else {
r.EncodeInt(int64(x.Port))
}
}
- if yyr2973 || yy2arr2973 {
+ if yyr2978 || yy2arr2978 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -38383,25 +38447,25 @@ func (x *DaemonEndpoint) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym2977 := z.DecBinary()
- _ = yym2977
+ yym2982 := z.DecBinary()
+ _ = yym2982
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct2978 := r.ContainerType()
- if yyct2978 == codecSelferValueTypeMap1234 {
- yyl2978 := r.ReadMapStart()
- if yyl2978 == 0 {
+ yyct2983 := r.ContainerType()
+ if yyct2983 == codecSelferValueTypeMap1234 {
+ yyl2983 := r.ReadMapStart()
+ if yyl2983 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl2978, d)
+ x.codecDecodeSelfFromMap(yyl2983, d)
}
- } else if yyct2978 == codecSelferValueTypeArray1234 {
- yyl2978 := r.ReadArrayStart()
- if yyl2978 == 0 {
+ } else if yyct2983 == codecSelferValueTypeArray1234 {
+ yyl2983 := r.ReadArrayStart()
+ if yyl2983 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl2978, d)
+ x.codecDecodeSelfFromArray(yyl2983, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -38413,12 +38477,12 @@ func (x *DaemonEndpoint) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys2979Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys2979Slc
- var yyhl2979 bool = l >= 0
- for yyj2979 := 0; ; yyj2979++ {
- if yyhl2979 {
- if yyj2979 >= l {
+ var yys2984Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys2984Slc
+ var yyhl2984 bool = l >= 0
+ for yyj2984 := 0; ; yyj2984++ {
+ if yyhl2984 {
+ if yyj2984 >= l {
break
}
} else {
@@ -38427,10 +38491,10 @@ func (x *DaemonEndpoint) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys2979Slc = r.DecodeBytes(yys2979Slc, true, true)
- yys2979 := string(yys2979Slc)
+ yys2984Slc = r.DecodeBytes(yys2984Slc, true, true)
+ yys2984 := string(yys2984Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys2979 {
+ switch yys2984 {
case "Port":
if r.TryDecodeAsNil() {
x.Port = 0
@@ -38438,9 +38502,9 @@ func (x *DaemonEndpoint) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
x.Port = int32(r.DecodeInt(32))
}
default:
- z.DecStructFieldNotFound(-1, yys2979)
- } // end switch yys2979
- } // end for yyj2979
+ z.DecStructFieldNotFound(-1, yys2984)
+ } // end switch yys2984
+ } // end for yyj2984
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -38448,16 +38512,16 @@ func (x *DaemonEndpoint) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj2981 int
- var yyb2981 bool
- var yyhl2981 bool = l >= 0
- yyj2981++
- if yyhl2981 {
- yyb2981 = yyj2981 > l
+ var yyj2986 int
+ var yyb2986 bool
+ var yyhl2986 bool = l >= 0
+ yyj2986++
+ if yyhl2986 {
+ yyb2986 = yyj2986 > l
} else {
- yyb2981 = r.CheckBreak()
+ yyb2986 = r.CheckBreak()
}
- if yyb2981 {
+ if yyb2986 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -38468,17 +38532,17 @@ func (x *DaemonEndpoint) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
x.Port = int32(r.DecodeInt(32))
}
for {
- yyj2981++
- if yyhl2981 {
- yyb2981 = yyj2981 > l
+ yyj2986++
+ if yyhl2986 {
+ yyb2986 = yyj2986 > l
} else {
- yyb2981 = r.CheckBreak()
+ yyb2986 = r.CheckBreak()
}
- if yyb2981 {
+ if yyb2986 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj2981-1, "")
+ z.DecStructFieldNotFound(yyj2986-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -38490,48 +38554,48 @@ func (x *NodeDaemonEndpoints) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym2983 := z.EncBinary()
- _ = yym2983
+ yym2988 := z.EncBinary()
+ _ = yym2988
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep2984 := !z.EncBinary()
- yy2arr2984 := z.EncBasicHandle().StructToArray
- var yyq2984 [1]bool
- _, _, _ = yysep2984, yyq2984, yy2arr2984
- const yyr2984 bool = false
- yyq2984[0] = true
- var yynn2984 int
- if yyr2984 || yy2arr2984 {
+ yysep2989 := !z.EncBinary()
+ yy2arr2989 := z.EncBasicHandle().StructToArray
+ var yyq2989 [1]bool
+ _, _, _ = yysep2989, yyq2989, yy2arr2989
+ const yyr2989 bool = false
+ yyq2989[0] = true
+ var yynn2989 int
+ if yyr2989 || yy2arr2989 {
r.EncodeArrayStart(1)
} else {
- yynn2984 = 0
- for _, b := range yyq2984 {
+ yynn2989 = 0
+ for _, b := range yyq2989 {
if b {
- yynn2984++
+ yynn2989++
}
}
- r.EncodeMapStart(yynn2984)
- yynn2984 = 0
+ r.EncodeMapStart(yynn2989)
+ yynn2989 = 0
}
- if yyr2984 || yy2arr2984 {
+ if yyr2989 || yy2arr2989 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq2984[0] {
- yy2986 := &x.KubeletEndpoint
- yy2986.CodecEncodeSelf(e)
+ if yyq2989[0] {
+ yy2991 := &x.KubeletEndpoint
+ yy2991.CodecEncodeSelf(e)
} else {
r.EncodeNil()
}
} else {
- if yyq2984[0] {
+ if yyq2989[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("kubeletEndpoint"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy2987 := &x.KubeletEndpoint
- yy2987.CodecEncodeSelf(e)
+ yy2992 := &x.KubeletEndpoint
+ yy2992.CodecEncodeSelf(e)
}
}
- if yyr2984 || yy2arr2984 {
+ if yyr2989 || yy2arr2989 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -38544,25 +38608,25 @@ func (x *NodeDaemonEndpoints) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym2988 := z.DecBinary()
- _ = yym2988
+ yym2993 := z.DecBinary()
+ _ = yym2993
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct2989 := r.ContainerType()
- if yyct2989 == codecSelferValueTypeMap1234 {
- yyl2989 := r.ReadMapStart()
- if yyl2989 == 0 {
+ yyct2994 := r.ContainerType()
+ if yyct2994 == codecSelferValueTypeMap1234 {
+ yyl2994 := r.ReadMapStart()
+ if yyl2994 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl2989, d)
+ x.codecDecodeSelfFromMap(yyl2994, d)
}
- } else if yyct2989 == codecSelferValueTypeArray1234 {
- yyl2989 := r.ReadArrayStart()
- if yyl2989 == 0 {
+ } else if yyct2994 == codecSelferValueTypeArray1234 {
+ yyl2994 := r.ReadArrayStart()
+ if yyl2994 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl2989, d)
+ x.codecDecodeSelfFromArray(yyl2994, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -38574,12 +38638,12 @@ func (x *NodeDaemonEndpoints) codecDecodeSelfFromMap(l int, d *codec1978.Decoder
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys2990Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys2990Slc
- var yyhl2990 bool = l >= 0
- for yyj2990 := 0; ; yyj2990++ {
- if yyhl2990 {
- if yyj2990 >= l {
+ var yys2995Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys2995Slc
+ var yyhl2995 bool = l >= 0
+ for yyj2995 := 0; ; yyj2995++ {
+ if yyhl2995 {
+ if yyj2995 >= l {
break
}
} else {
@@ -38588,21 +38652,21 @@ func (x *NodeDaemonEndpoints) codecDecodeSelfFromMap(l int, d *codec1978.Decoder
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys2990Slc = r.DecodeBytes(yys2990Slc, true, true)
- yys2990 := string(yys2990Slc)
+ yys2995Slc = r.DecodeBytes(yys2995Slc, true, true)
+ yys2995 := string(yys2995Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys2990 {
+ switch yys2995 {
case "kubeletEndpoint":
if r.TryDecodeAsNil() {
x.KubeletEndpoint = DaemonEndpoint{}
} else {
- yyv2991 := &x.KubeletEndpoint
- yyv2991.CodecDecodeSelf(d)
+ yyv2996 := &x.KubeletEndpoint
+ yyv2996.CodecDecodeSelf(d)
}
default:
- z.DecStructFieldNotFound(-1, yys2990)
- } // end switch yys2990
- } // end for yyj2990
+ z.DecStructFieldNotFound(-1, yys2995)
+ } // end switch yys2995
+ } // end for yyj2995
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -38610,16 +38674,16 @@ func (x *NodeDaemonEndpoints) codecDecodeSelfFromArray(l int, d *codec1978.Decod
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj2992 int
- var yyb2992 bool
- var yyhl2992 bool = l >= 0
- yyj2992++
- if yyhl2992 {
- yyb2992 = yyj2992 > l
+ var yyj2997 int
+ var yyb2997 bool
+ var yyhl2997 bool = l >= 0
+ yyj2997++
+ if yyhl2997 {
+ yyb2997 = yyj2997 > l
} else {
- yyb2992 = r.CheckBreak()
+ yyb2997 = r.CheckBreak()
}
- if yyb2992 {
+ if yyb2997 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -38627,21 +38691,21 @@ func (x *NodeDaemonEndpoints) codecDecodeSelfFromArray(l int, d *codec1978.Decod
if r.TryDecodeAsNil() {
x.KubeletEndpoint = DaemonEndpoint{}
} else {
- yyv2993 := &x.KubeletEndpoint
- yyv2993.CodecDecodeSelf(d)
+ yyv2998 := &x.KubeletEndpoint
+ yyv2998.CodecDecodeSelf(d)
}
for {
- yyj2992++
- if yyhl2992 {
- yyb2992 = yyj2992 > l
+ yyj2997++
+ if yyhl2997 {
+ yyb2997 = yyj2997 > l
} else {
- yyb2992 = r.CheckBreak()
+ yyb2997 = r.CheckBreak()
}
- if yyb2992 {
+ if yyb2997 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj2992-1, "")
+ z.DecStructFieldNotFound(yyj2997-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -38653,33 +38717,33 @@ func (x *NodeSystemInfo) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym2994 := z.EncBinary()
- _ = yym2994
+ yym2999 := z.EncBinary()
+ _ = yym2999
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep2995 := !z.EncBinary()
- yy2arr2995 := z.EncBasicHandle().StructToArray
- var yyq2995 [10]bool
- _, _, _ = yysep2995, yyq2995, yy2arr2995
- const yyr2995 bool = false
- var yynn2995 int
- if yyr2995 || yy2arr2995 {
+ yysep3000 := !z.EncBinary()
+ yy2arr3000 := z.EncBasicHandle().StructToArray
+ var yyq3000 [10]bool
+ _, _, _ = yysep3000, yyq3000, yy2arr3000
+ const yyr3000 bool = false
+ var yynn3000 int
+ if yyr3000 || yy2arr3000 {
r.EncodeArrayStart(10)
} else {
- yynn2995 = 10
- for _, b := range yyq2995 {
+ yynn3000 = 10
+ for _, b := range yyq3000 {
if b {
- yynn2995++
+ yynn3000++
}
}
- r.EncodeMapStart(yynn2995)
- yynn2995 = 0
+ r.EncodeMapStart(yynn3000)
+ yynn3000 = 0
}
- if yyr2995 || yy2arr2995 {
+ if yyr3000 || yy2arr3000 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym2997 := z.EncBinary()
- _ = yym2997
+ yym3002 := z.EncBinary()
+ _ = yym3002
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.MachineID))
@@ -38688,17 +38752,17 @@ func (x *NodeSystemInfo) CodecEncodeSelf(e *codec1978.Encoder) {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("machineID"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym2998 := z.EncBinary()
- _ = yym2998
+ yym3003 := z.EncBinary()
+ _ = yym3003
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.MachineID))
}
}
- if yyr2995 || yy2arr2995 {
+ if yyr3000 || yy2arr3000 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym3000 := z.EncBinary()
- _ = yym3000
+ yym3005 := z.EncBinary()
+ _ = yym3005
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.SystemUUID))
@@ -38707,17 +38771,17 @@ func (x *NodeSystemInfo) CodecEncodeSelf(e *codec1978.Encoder) {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("systemUUID"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3001 := z.EncBinary()
- _ = yym3001
+ yym3006 := z.EncBinary()
+ _ = yym3006
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.SystemUUID))
}
}
- if yyr2995 || yy2arr2995 {
+ if yyr3000 || yy2arr3000 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym3003 := z.EncBinary()
- _ = yym3003
+ yym3008 := z.EncBinary()
+ _ = yym3008
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.BootID))
@@ -38726,17 +38790,17 @@ func (x *NodeSystemInfo) CodecEncodeSelf(e *codec1978.Encoder) {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("bootID"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3004 := z.EncBinary()
- _ = yym3004
+ yym3009 := z.EncBinary()
+ _ = yym3009
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.BootID))
}
}
- if yyr2995 || yy2arr2995 {
+ if yyr3000 || yy2arr3000 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym3006 := z.EncBinary()
- _ = yym3006
+ yym3011 := z.EncBinary()
+ _ = yym3011
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.KernelVersion))
@@ -38745,17 +38809,17 @@ func (x *NodeSystemInfo) CodecEncodeSelf(e *codec1978.Encoder) {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("kernelVersion"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3007 := z.EncBinary()
- _ = yym3007
+ yym3012 := z.EncBinary()
+ _ = yym3012
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.KernelVersion))
}
}
- if yyr2995 || yy2arr2995 {
+ if yyr3000 || yy2arr3000 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym3009 := z.EncBinary()
- _ = yym3009
+ yym3014 := z.EncBinary()
+ _ = yym3014
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.OSImage))
@@ -38764,17 +38828,17 @@ func (x *NodeSystemInfo) CodecEncodeSelf(e *codec1978.Encoder) {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("osImage"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3010 := z.EncBinary()
- _ = yym3010
+ yym3015 := z.EncBinary()
+ _ = yym3015
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.OSImage))
}
}
- if yyr2995 || yy2arr2995 {
+ if yyr3000 || yy2arr3000 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym3012 := z.EncBinary()
- _ = yym3012
+ yym3017 := z.EncBinary()
+ _ = yym3017
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.ContainerRuntimeVersion))
@@ -38783,17 +38847,17 @@ func (x *NodeSystemInfo) CodecEncodeSelf(e *codec1978.Encoder) {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("containerRuntimeVersion"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3013 := z.EncBinary()
- _ = yym3013
+ yym3018 := z.EncBinary()
+ _ = yym3018
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.ContainerRuntimeVersion))
}
}
- if yyr2995 || yy2arr2995 {
+ if yyr3000 || yy2arr3000 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym3015 := z.EncBinary()
- _ = yym3015
+ yym3020 := z.EncBinary()
+ _ = yym3020
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.KubeletVersion))
@@ -38802,17 +38866,17 @@ func (x *NodeSystemInfo) CodecEncodeSelf(e *codec1978.Encoder) {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("kubeletVersion"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3016 := z.EncBinary()
- _ = yym3016
+ yym3021 := z.EncBinary()
+ _ = yym3021
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.KubeletVersion))
}
}
- if yyr2995 || yy2arr2995 {
+ if yyr3000 || yy2arr3000 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym3018 := z.EncBinary()
- _ = yym3018
+ yym3023 := z.EncBinary()
+ _ = yym3023
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.KubeProxyVersion))
@@ -38821,17 +38885,17 @@ func (x *NodeSystemInfo) CodecEncodeSelf(e *codec1978.Encoder) {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("kubeProxyVersion"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3019 := z.EncBinary()
- _ = yym3019
+ yym3024 := z.EncBinary()
+ _ = yym3024
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.KubeProxyVersion))
}
}
- if yyr2995 || yy2arr2995 {
+ if yyr3000 || yy2arr3000 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym3021 := z.EncBinary()
- _ = yym3021
+ yym3026 := z.EncBinary()
+ _ = yym3026
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.OperatingSystem))
@@ -38840,17 +38904,17 @@ func (x *NodeSystemInfo) CodecEncodeSelf(e *codec1978.Encoder) {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("operatingSystem"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3022 := z.EncBinary()
- _ = yym3022
+ yym3027 := z.EncBinary()
+ _ = yym3027
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.OperatingSystem))
}
}
- if yyr2995 || yy2arr2995 {
+ if yyr3000 || yy2arr3000 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym3024 := z.EncBinary()
- _ = yym3024
+ yym3029 := z.EncBinary()
+ _ = yym3029
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Architecture))
@@ -38859,14 +38923,14 @@ func (x *NodeSystemInfo) CodecEncodeSelf(e *codec1978.Encoder) {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("architecture"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3025 := z.EncBinary()
- _ = yym3025
+ yym3030 := z.EncBinary()
+ _ = yym3030
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Architecture))
}
}
- if yyr2995 || yy2arr2995 {
+ if yyr3000 || yy2arr3000 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -38879,25 +38943,25 @@ func (x *NodeSystemInfo) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym3026 := z.DecBinary()
- _ = yym3026
+ yym3031 := z.DecBinary()
+ _ = yym3031
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct3027 := r.ContainerType()
- if yyct3027 == codecSelferValueTypeMap1234 {
- yyl3027 := r.ReadMapStart()
- if yyl3027 == 0 {
+ yyct3032 := r.ContainerType()
+ if yyct3032 == codecSelferValueTypeMap1234 {
+ yyl3032 := r.ReadMapStart()
+ if yyl3032 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl3027, d)
+ x.codecDecodeSelfFromMap(yyl3032, d)
}
- } else if yyct3027 == codecSelferValueTypeArray1234 {
- yyl3027 := r.ReadArrayStart()
- if yyl3027 == 0 {
+ } else if yyct3032 == codecSelferValueTypeArray1234 {
+ yyl3032 := r.ReadArrayStart()
+ if yyl3032 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl3027, d)
+ x.codecDecodeSelfFromArray(yyl3032, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -38909,12 +38973,12 @@ func (x *NodeSystemInfo) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys3028Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys3028Slc
- var yyhl3028 bool = l >= 0
- for yyj3028 := 0; ; yyj3028++ {
- if yyhl3028 {
- if yyj3028 >= l {
+ var yys3033Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3033Slc
+ var yyhl3033 bool = l >= 0
+ for yyj3033 := 0; ; yyj3033++ {
+ if yyhl3033 {
+ if yyj3033 >= l {
break
}
} else {
@@ -38923,10 +38987,10 @@ func (x *NodeSystemInfo) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys3028Slc = r.DecodeBytes(yys3028Slc, true, true)
- yys3028 := string(yys3028Slc)
+ yys3033Slc = r.DecodeBytes(yys3033Slc, true, true)
+ yys3033 := string(yys3033Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys3028 {
+ switch yys3033 {
case "machineID":
if r.TryDecodeAsNil() {
x.MachineID = ""
@@ -38988,9 +39052,9 @@ func (x *NodeSystemInfo) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
x.Architecture = string(r.DecodeString())
}
default:
- z.DecStructFieldNotFound(-1, yys3028)
- } // end switch yys3028
- } // end for yyj3028
+ z.DecStructFieldNotFound(-1, yys3033)
+ } // end switch yys3033
+ } // end for yyj3033
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -38998,16 +39062,16 @@ func (x *NodeSystemInfo) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj3039 int
- var yyb3039 bool
- var yyhl3039 bool = l >= 0
- yyj3039++
- if yyhl3039 {
- yyb3039 = yyj3039 > l
+ var yyj3044 int
+ var yyb3044 bool
+ var yyhl3044 bool = l >= 0
+ yyj3044++
+ if yyhl3044 {
+ yyb3044 = yyj3044 > l
} else {
- yyb3039 = r.CheckBreak()
+ yyb3044 = r.CheckBreak()
}
- if yyb3039 {
+ if yyb3044 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -39017,13 +39081,13 @@ func (x *NodeSystemInfo) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.MachineID = string(r.DecodeString())
}
- yyj3039++
- if yyhl3039 {
- yyb3039 = yyj3039 > l
+ yyj3044++
+ if yyhl3044 {
+ yyb3044 = yyj3044 > l
} else {
- yyb3039 = r.CheckBreak()
+ yyb3044 = r.CheckBreak()
}
- if yyb3039 {
+ if yyb3044 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -39033,13 +39097,13 @@ func (x *NodeSystemInfo) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.SystemUUID = string(r.DecodeString())
}
- yyj3039++
- if yyhl3039 {
- yyb3039 = yyj3039 > l
+ yyj3044++
+ if yyhl3044 {
+ yyb3044 = yyj3044 > l
} else {
- yyb3039 = r.CheckBreak()
+ yyb3044 = r.CheckBreak()
}
- if yyb3039 {
+ if yyb3044 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -39049,13 +39113,13 @@ func (x *NodeSystemInfo) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.BootID = string(r.DecodeString())
}
- yyj3039++
- if yyhl3039 {
- yyb3039 = yyj3039 > l
+ yyj3044++
+ if yyhl3044 {
+ yyb3044 = yyj3044 > l
} else {
- yyb3039 = r.CheckBreak()
+ yyb3044 = r.CheckBreak()
}
- if yyb3039 {
+ if yyb3044 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -39065,13 +39129,13 @@ func (x *NodeSystemInfo) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.KernelVersion = string(r.DecodeString())
}
- yyj3039++
- if yyhl3039 {
- yyb3039 = yyj3039 > l
+ yyj3044++
+ if yyhl3044 {
+ yyb3044 = yyj3044 > l
} else {
- yyb3039 = r.CheckBreak()
+ yyb3044 = r.CheckBreak()
}
- if yyb3039 {
+ if yyb3044 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -39081,13 +39145,13 @@ func (x *NodeSystemInfo) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.OSImage = string(r.DecodeString())
}
- yyj3039++
- if yyhl3039 {
- yyb3039 = yyj3039 > l
+ yyj3044++
+ if yyhl3044 {
+ yyb3044 = yyj3044 > l
} else {
- yyb3039 = r.CheckBreak()
+ yyb3044 = r.CheckBreak()
}
- if yyb3039 {
+ if yyb3044 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -39097,13 +39161,13 @@ func (x *NodeSystemInfo) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.ContainerRuntimeVersion = string(r.DecodeString())
}
- yyj3039++
- if yyhl3039 {
- yyb3039 = yyj3039 > l
+ yyj3044++
+ if yyhl3044 {
+ yyb3044 = yyj3044 > l
} else {
- yyb3039 = r.CheckBreak()
+ yyb3044 = r.CheckBreak()
}
- if yyb3039 {
+ if yyb3044 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -39113,13 +39177,13 @@ func (x *NodeSystemInfo) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.KubeletVersion = string(r.DecodeString())
}
- yyj3039++
- if yyhl3039 {
- yyb3039 = yyj3039 > l
+ yyj3044++
+ if yyhl3044 {
+ yyb3044 = yyj3044 > l
} else {
- yyb3039 = r.CheckBreak()
+ yyb3044 = r.CheckBreak()
}
- if yyb3039 {
+ if yyb3044 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -39129,13 +39193,13 @@ func (x *NodeSystemInfo) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.KubeProxyVersion = string(r.DecodeString())
}
- yyj3039++
- if yyhl3039 {
- yyb3039 = yyj3039 > l
+ yyj3044++
+ if yyhl3044 {
+ yyb3044 = yyj3044 > l
} else {
- yyb3039 = r.CheckBreak()
+ yyb3044 = r.CheckBreak()
}
- if yyb3039 {
+ if yyb3044 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -39145,13 +39209,13 @@ func (x *NodeSystemInfo) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.OperatingSystem = string(r.DecodeString())
}
- yyj3039++
- if yyhl3039 {
- yyb3039 = yyj3039 > l
+ yyj3044++
+ if yyhl3044 {
+ yyb3044 = yyj3044 > l
} else {
- yyb3039 = r.CheckBreak()
+ yyb3044 = r.CheckBreak()
}
- if yyb3039 {
+ if yyb3044 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -39162,17 +39226,17 @@ func (x *NodeSystemInfo) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
x.Architecture = string(r.DecodeString())
}
for {
- yyj3039++
- if yyhl3039 {
- yyb3039 = yyj3039 > l
+ yyj3044++
+ if yyhl3044 {
+ yyb3044 = yyj3044 > l
} else {
- yyb3039 = r.CheckBreak()
+ yyb3044 = r.CheckBreak()
}
- if yyb3039 {
+ if yyb3044 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj3039-1, "")
+ z.DecStructFieldNotFound(yyj3044-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -39184,42 +39248,42 @@ func (x *NodeStatus) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym3050 := z.EncBinary()
- _ = yym3050
+ yym3055 := z.EncBinary()
+ _ = yym3055
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep3051 := !z.EncBinary()
- yy2arr3051 := z.EncBasicHandle().StructToArray
- var yyq3051 [10]bool
- _, _, _ = yysep3051, yyq3051, yy2arr3051
- const yyr3051 bool = false
- yyq3051[0] = len(x.Capacity) != 0
- yyq3051[1] = len(x.Allocatable) != 0
- yyq3051[2] = x.Phase != ""
- yyq3051[3] = len(x.Conditions) != 0
- yyq3051[4] = len(x.Addresses) != 0
- yyq3051[5] = true
- yyq3051[6] = true
- yyq3051[7] = len(x.Images) != 0
- yyq3051[8] = len(x.VolumesInUse) != 0
- yyq3051[9] = len(x.VolumesAttached) != 0
- var yynn3051 int
- if yyr3051 || yy2arr3051 {
+ yysep3056 := !z.EncBinary()
+ yy2arr3056 := z.EncBasicHandle().StructToArray
+ var yyq3056 [10]bool
+ _, _, _ = yysep3056, yyq3056, yy2arr3056
+ const yyr3056 bool = false
+ yyq3056[0] = len(x.Capacity) != 0
+ yyq3056[1] = len(x.Allocatable) != 0
+ yyq3056[2] = x.Phase != ""
+ yyq3056[3] = len(x.Conditions) != 0
+ yyq3056[4] = len(x.Addresses) != 0
+ yyq3056[5] = true
+ yyq3056[6] = true
+ yyq3056[7] = len(x.Images) != 0
+ yyq3056[8] = len(x.VolumesInUse) != 0
+ yyq3056[9] = len(x.VolumesAttached) != 0
+ var yynn3056 int
+ if yyr3056 || yy2arr3056 {
r.EncodeArrayStart(10)
} else {
- yynn3051 = 0
- for _, b := range yyq3051 {
+ yynn3056 = 0
+ for _, b := range yyq3056 {
if b {
- yynn3051++
+ yynn3056++
}
}
- r.EncodeMapStart(yynn3051)
- yynn3051 = 0
+ r.EncodeMapStart(yynn3056)
+ yynn3056 = 0
}
- if yyr3051 || yy2arr3051 {
+ if yyr3056 || yy2arr3056 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3051[0] {
+ if yyq3056[0] {
if x.Capacity == nil {
r.EncodeNil()
} else {
@@ -39229,7 +39293,7 @@ func (x *NodeStatus) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeNil()
}
} else {
- if yyq3051[0] {
+ if yyq3056[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("capacity"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
@@ -39240,9 +39304,9 @@ func (x *NodeStatus) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
- if yyr3051 || yy2arr3051 {
+ if yyr3056 || yy2arr3056 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3051[1] {
+ if yyq3056[1] {
if x.Allocatable == nil {
r.EncodeNil()
} else {
@@ -39252,7 +39316,7 @@ func (x *NodeStatus) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeNil()
}
} else {
- if yyq3051[1] {
+ if yyq3056[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("allocatable"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
@@ -39263,29 +39327,29 @@ func (x *NodeStatus) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
- if yyr3051 || yy2arr3051 {
+ if yyr3056 || yy2arr3056 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3051[2] {
+ if yyq3056[2] {
x.Phase.CodecEncodeSelf(e)
} else {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq3051[2] {
+ if yyq3056[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("phase"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
x.Phase.CodecEncodeSelf(e)
}
}
- if yyr3051 || yy2arr3051 {
+ if yyr3056 || yy2arr3056 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3051[3] {
+ if yyq3056[3] {
if x.Conditions == nil {
r.EncodeNil()
} else {
- yym3056 := z.EncBinary()
- _ = yym3056
+ yym3061 := z.EncBinary()
+ _ = yym3061
if false {
} else {
h.encSliceNodeCondition(([]NodeCondition)(x.Conditions), e)
@@ -39295,15 +39359,15 @@ func (x *NodeStatus) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeNil()
}
} else {
- if yyq3051[3] {
+ if yyq3056[3] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("conditions"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
if x.Conditions == nil {
r.EncodeNil()
} else {
- yym3057 := z.EncBinary()
- _ = yym3057
+ yym3062 := z.EncBinary()
+ _ = yym3062
if false {
} else {
h.encSliceNodeCondition(([]NodeCondition)(x.Conditions), e)
@@ -39311,14 +39375,14 @@ func (x *NodeStatus) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
- if yyr3051 || yy2arr3051 {
+ if yyr3056 || yy2arr3056 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3051[4] {
+ if yyq3056[4] {
if x.Addresses == nil {
r.EncodeNil()
} else {
- yym3059 := z.EncBinary()
- _ = yym3059
+ yym3064 := z.EncBinary()
+ _ = yym3064
if false {
} else {
h.encSliceNodeAddress(([]NodeAddress)(x.Addresses), e)
@@ -39328,15 +39392,15 @@ func (x *NodeStatus) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeNil()
}
} else {
- if yyq3051[4] {
+ if yyq3056[4] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("addresses"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
if x.Addresses == nil {
r.EncodeNil()
} else {
- yym3060 := z.EncBinary()
- _ = yym3060
+ yym3065 := z.EncBinary()
+ _ = yym3065
if false {
} else {
h.encSliceNodeAddress(([]NodeAddress)(x.Addresses), e)
@@ -39344,48 +39408,48 @@ func (x *NodeStatus) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
- if yyr3051 || yy2arr3051 {
+ if yyr3056 || yy2arr3056 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3051[5] {
- yy3062 := &x.DaemonEndpoints
- yy3062.CodecEncodeSelf(e)
+ if yyq3056[5] {
+ yy3067 := &x.DaemonEndpoints
+ yy3067.CodecEncodeSelf(e)
} else {
r.EncodeNil()
}
} else {
- if yyq3051[5] {
+ if yyq3056[5] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("daemonEndpoints"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy3063 := &x.DaemonEndpoints
- yy3063.CodecEncodeSelf(e)
+ yy3068 := &x.DaemonEndpoints
+ yy3068.CodecEncodeSelf(e)
}
}
- if yyr3051 || yy2arr3051 {
+ if yyr3056 || yy2arr3056 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3051[6] {
- yy3065 := &x.NodeInfo
- yy3065.CodecEncodeSelf(e)
+ if yyq3056[6] {
+ yy3070 := &x.NodeInfo
+ yy3070.CodecEncodeSelf(e)
} else {
r.EncodeNil()
}
} else {
- if yyq3051[6] {
+ if yyq3056[6] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("nodeInfo"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy3066 := &x.NodeInfo
- yy3066.CodecEncodeSelf(e)
+ yy3071 := &x.NodeInfo
+ yy3071.CodecEncodeSelf(e)
}
}
- if yyr3051 || yy2arr3051 {
+ if yyr3056 || yy2arr3056 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3051[7] {
+ if yyq3056[7] {
if x.Images == nil {
r.EncodeNil()
} else {
- yym3068 := z.EncBinary()
- _ = yym3068
+ yym3073 := z.EncBinary()
+ _ = yym3073
if false {
} else {
h.encSliceContainerImage(([]ContainerImage)(x.Images), e)
@@ -39395,15 +39459,15 @@ func (x *NodeStatus) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeNil()
}
} else {
- if yyq3051[7] {
+ if yyq3056[7] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("images"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
if x.Images == nil {
r.EncodeNil()
} else {
- yym3069 := z.EncBinary()
- _ = yym3069
+ yym3074 := z.EncBinary()
+ _ = yym3074
if false {
} else {
h.encSliceContainerImage(([]ContainerImage)(x.Images), e)
@@ -39411,14 +39475,14 @@ func (x *NodeStatus) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
- if yyr3051 || yy2arr3051 {
+ if yyr3056 || yy2arr3056 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3051[8] {
+ if yyq3056[8] {
if x.VolumesInUse == nil {
r.EncodeNil()
} else {
- yym3071 := z.EncBinary()
- _ = yym3071
+ yym3076 := z.EncBinary()
+ _ = yym3076
if false {
} else {
h.encSliceUniqueVolumeName(([]UniqueVolumeName)(x.VolumesInUse), e)
@@ -39428,15 +39492,15 @@ func (x *NodeStatus) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeNil()
}
} else {
- if yyq3051[8] {
+ if yyq3056[8] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("volumesInUse"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
if x.VolumesInUse == nil {
r.EncodeNil()
} else {
- yym3072 := z.EncBinary()
- _ = yym3072
+ yym3077 := z.EncBinary()
+ _ = yym3077
if false {
} else {
h.encSliceUniqueVolumeName(([]UniqueVolumeName)(x.VolumesInUse), e)
@@ -39444,14 +39508,14 @@ func (x *NodeStatus) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
- if yyr3051 || yy2arr3051 {
+ if yyr3056 || yy2arr3056 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3051[9] {
+ if yyq3056[9] {
if x.VolumesAttached == nil {
r.EncodeNil()
} else {
- yym3074 := z.EncBinary()
- _ = yym3074
+ yym3079 := z.EncBinary()
+ _ = yym3079
if false {
} else {
h.encSliceAttachedVolume(([]AttachedVolume)(x.VolumesAttached), e)
@@ -39461,15 +39525,15 @@ func (x *NodeStatus) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeNil()
}
} else {
- if yyq3051[9] {
+ if yyq3056[9] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("volumesAttached"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
if x.VolumesAttached == nil {
r.EncodeNil()
} else {
- yym3075 := z.EncBinary()
- _ = yym3075
+ yym3080 := z.EncBinary()
+ _ = yym3080
if false {
} else {
h.encSliceAttachedVolume(([]AttachedVolume)(x.VolumesAttached), e)
@@ -39477,7 +39541,7 @@ func (x *NodeStatus) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
- if yyr3051 || yy2arr3051 {
+ if yyr3056 || yy2arr3056 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -39490,25 +39554,25 @@ func (x *NodeStatus) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym3076 := z.DecBinary()
- _ = yym3076
+ yym3081 := z.DecBinary()
+ _ = yym3081
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct3077 := r.ContainerType()
- if yyct3077 == codecSelferValueTypeMap1234 {
- yyl3077 := r.ReadMapStart()
- if yyl3077 == 0 {
+ yyct3082 := r.ContainerType()
+ if yyct3082 == codecSelferValueTypeMap1234 {
+ yyl3082 := r.ReadMapStart()
+ if yyl3082 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl3077, d)
+ x.codecDecodeSelfFromMap(yyl3082, d)
}
- } else if yyct3077 == codecSelferValueTypeArray1234 {
- yyl3077 := r.ReadArrayStart()
- if yyl3077 == 0 {
+ } else if yyct3082 == codecSelferValueTypeArray1234 {
+ yyl3082 := r.ReadArrayStart()
+ if yyl3082 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl3077, d)
+ x.codecDecodeSelfFromArray(yyl3082, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -39520,12 +39584,12 @@ func (x *NodeStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys3078Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys3078Slc
- var yyhl3078 bool = l >= 0
- for yyj3078 := 0; ; yyj3078++ {
- if yyhl3078 {
- if yyj3078 >= l {
+ var yys3083Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3083Slc
+ var yyhl3083 bool = l >= 0
+ for yyj3083 := 0; ; yyj3083++ {
+ if yyhl3083 {
+ if yyj3083 >= l {
break
}
} else {
@@ -39534,23 +39598,23 @@ func (x *NodeStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys3078Slc = r.DecodeBytes(yys3078Slc, true, true)
- yys3078 := string(yys3078Slc)
+ yys3083Slc = r.DecodeBytes(yys3083Slc, true, true)
+ yys3083 := string(yys3083Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys3078 {
+ switch yys3083 {
case "capacity":
if r.TryDecodeAsNil() {
x.Capacity = nil
} else {
- yyv3079 := &x.Capacity
- yyv3079.CodecDecodeSelf(d)
+ yyv3084 := &x.Capacity
+ yyv3084.CodecDecodeSelf(d)
}
case "allocatable":
if r.TryDecodeAsNil() {
x.Allocatable = nil
} else {
- yyv3080 := &x.Allocatable
- yyv3080.CodecDecodeSelf(d)
+ yyv3085 := &x.Allocatable
+ yyv3085.CodecDecodeSelf(d)
}
case "phase":
if r.TryDecodeAsNil() {
@@ -39562,80 +39626,80 @@ func (x *NodeStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Conditions = nil
} else {
- yyv3082 := &x.Conditions
- yym3083 := z.DecBinary()
- _ = yym3083
+ yyv3087 := &x.Conditions
+ yym3088 := z.DecBinary()
+ _ = yym3088
if false {
} else {
- h.decSliceNodeCondition((*[]NodeCondition)(yyv3082), d)
+ h.decSliceNodeCondition((*[]NodeCondition)(yyv3087), d)
}
}
case "addresses":
if r.TryDecodeAsNil() {
x.Addresses = nil
} else {
- yyv3084 := &x.Addresses
- yym3085 := z.DecBinary()
- _ = yym3085
+ yyv3089 := &x.Addresses
+ yym3090 := z.DecBinary()
+ _ = yym3090
if false {
} else {
- h.decSliceNodeAddress((*[]NodeAddress)(yyv3084), d)
+ h.decSliceNodeAddress((*[]NodeAddress)(yyv3089), d)
}
}
case "daemonEndpoints":
if r.TryDecodeAsNil() {
x.DaemonEndpoints = NodeDaemonEndpoints{}
} else {
- yyv3086 := &x.DaemonEndpoints
- yyv3086.CodecDecodeSelf(d)
+ yyv3091 := &x.DaemonEndpoints
+ yyv3091.CodecDecodeSelf(d)
}
case "nodeInfo":
if r.TryDecodeAsNil() {
x.NodeInfo = NodeSystemInfo{}
} else {
- yyv3087 := &x.NodeInfo
- yyv3087.CodecDecodeSelf(d)
+ yyv3092 := &x.NodeInfo
+ yyv3092.CodecDecodeSelf(d)
}
case "images":
if r.TryDecodeAsNil() {
x.Images = nil
} else {
- yyv3088 := &x.Images
- yym3089 := z.DecBinary()
- _ = yym3089
+ yyv3093 := &x.Images
+ yym3094 := z.DecBinary()
+ _ = yym3094
if false {
} else {
- h.decSliceContainerImage((*[]ContainerImage)(yyv3088), d)
+ h.decSliceContainerImage((*[]ContainerImage)(yyv3093), d)
}
}
case "volumesInUse":
if r.TryDecodeAsNil() {
x.VolumesInUse = nil
} else {
- yyv3090 := &x.VolumesInUse
- yym3091 := z.DecBinary()
- _ = yym3091
+ yyv3095 := &x.VolumesInUse
+ yym3096 := z.DecBinary()
+ _ = yym3096
if false {
} else {
- h.decSliceUniqueVolumeName((*[]UniqueVolumeName)(yyv3090), d)
+ h.decSliceUniqueVolumeName((*[]UniqueVolumeName)(yyv3095), d)
}
}
case "volumesAttached":
if r.TryDecodeAsNil() {
x.VolumesAttached = nil
} else {
- yyv3092 := &x.VolumesAttached
- yym3093 := z.DecBinary()
- _ = yym3093
+ yyv3097 := &x.VolumesAttached
+ yym3098 := z.DecBinary()
+ _ = yym3098
if false {
} else {
- h.decSliceAttachedVolume((*[]AttachedVolume)(yyv3092), d)
+ h.decSliceAttachedVolume((*[]AttachedVolume)(yyv3097), d)
}
}
default:
- z.DecStructFieldNotFound(-1, yys3078)
- } // end switch yys3078
- } // end for yyj3078
+ z.DecStructFieldNotFound(-1, yys3083)
+ } // end switch yys3083
+ } // end for yyj3083
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -39643,16 +39707,16 @@ func (x *NodeStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj3094 int
- var yyb3094 bool
- var yyhl3094 bool = l >= 0
- yyj3094++
- if yyhl3094 {
- yyb3094 = yyj3094 > l
+ var yyj3099 int
+ var yyb3099 bool
+ var yyhl3099 bool = l >= 0
+ yyj3099++
+ if yyhl3099 {
+ yyb3099 = yyj3099 > l
} else {
- yyb3094 = r.CheckBreak()
+ yyb3099 = r.CheckBreak()
}
- if yyb3094 {
+ if yyb3099 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -39660,16 +39724,16 @@ func (x *NodeStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Capacity = nil
} else {
- yyv3095 := &x.Capacity
- yyv3095.CodecDecodeSelf(d)
+ yyv3100 := &x.Capacity
+ yyv3100.CodecDecodeSelf(d)
}
- yyj3094++
- if yyhl3094 {
- yyb3094 = yyj3094 > l
+ yyj3099++
+ if yyhl3099 {
+ yyb3099 = yyj3099 > l
} else {
- yyb3094 = r.CheckBreak()
+ yyb3099 = r.CheckBreak()
}
- if yyb3094 {
+ if yyb3099 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -39677,16 +39741,16 @@ func (x *NodeStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Allocatable = nil
} else {
- yyv3096 := &x.Allocatable
- yyv3096.CodecDecodeSelf(d)
+ yyv3101 := &x.Allocatable
+ yyv3101.CodecDecodeSelf(d)
}
- yyj3094++
- if yyhl3094 {
- yyb3094 = yyj3094 > l
+ yyj3099++
+ if yyhl3099 {
+ yyb3099 = yyj3099 > l
} else {
- yyb3094 = r.CheckBreak()
+ yyb3099 = r.CheckBreak()
}
- if yyb3094 {
+ if yyb3099 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -39696,13 +39760,13 @@ func (x *NodeStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Phase = NodePhase(r.DecodeString())
}
- yyj3094++
- if yyhl3094 {
- yyb3094 = yyj3094 > l
+ yyj3099++
+ if yyhl3099 {
+ yyb3099 = yyj3099 > l
} else {
- yyb3094 = r.CheckBreak()
+ yyb3099 = r.CheckBreak()
}
- if yyb3094 {
+ if yyb3099 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -39710,21 +39774,21 @@ func (x *NodeStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Conditions = nil
} else {
- yyv3098 := &x.Conditions
- yym3099 := z.DecBinary()
- _ = yym3099
+ yyv3103 := &x.Conditions
+ yym3104 := z.DecBinary()
+ _ = yym3104
if false {
} else {
- h.decSliceNodeCondition((*[]NodeCondition)(yyv3098), d)
+ h.decSliceNodeCondition((*[]NodeCondition)(yyv3103), d)
}
}
- yyj3094++
- if yyhl3094 {
- yyb3094 = yyj3094 > l
+ yyj3099++
+ if yyhl3099 {
+ yyb3099 = yyj3099 > l
} else {
- yyb3094 = r.CheckBreak()
+ yyb3099 = r.CheckBreak()
}
- if yyb3094 {
+ if yyb3099 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -39732,21 +39796,21 @@ func (x *NodeStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Addresses = nil
} else {
- yyv3100 := &x.Addresses
- yym3101 := z.DecBinary()
- _ = yym3101
+ yyv3105 := &x.Addresses
+ yym3106 := z.DecBinary()
+ _ = yym3106
if false {
} else {
- h.decSliceNodeAddress((*[]NodeAddress)(yyv3100), d)
+ h.decSliceNodeAddress((*[]NodeAddress)(yyv3105), d)
}
}
- yyj3094++
- if yyhl3094 {
- yyb3094 = yyj3094 > l
+ yyj3099++
+ if yyhl3099 {
+ yyb3099 = yyj3099 > l
} else {
- yyb3094 = r.CheckBreak()
+ yyb3099 = r.CheckBreak()
}
- if yyb3094 {
+ if yyb3099 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -39754,16 +39818,16 @@ func (x *NodeStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.DaemonEndpoints = NodeDaemonEndpoints{}
} else {
- yyv3102 := &x.DaemonEndpoints
- yyv3102.CodecDecodeSelf(d)
+ yyv3107 := &x.DaemonEndpoints
+ yyv3107.CodecDecodeSelf(d)
}
- yyj3094++
- if yyhl3094 {
- yyb3094 = yyj3094 > l
+ yyj3099++
+ if yyhl3099 {
+ yyb3099 = yyj3099 > l
} else {
- yyb3094 = r.CheckBreak()
+ yyb3099 = r.CheckBreak()
}
- if yyb3094 {
+ if yyb3099 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -39771,16 +39835,16 @@ func (x *NodeStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.NodeInfo = NodeSystemInfo{}
} else {
- yyv3103 := &x.NodeInfo
- yyv3103.CodecDecodeSelf(d)
+ yyv3108 := &x.NodeInfo
+ yyv3108.CodecDecodeSelf(d)
}
- yyj3094++
- if yyhl3094 {
- yyb3094 = yyj3094 > l
+ yyj3099++
+ if yyhl3099 {
+ yyb3099 = yyj3099 > l
} else {
- yyb3094 = r.CheckBreak()
+ yyb3099 = r.CheckBreak()
}
- if yyb3094 {
+ if yyb3099 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -39788,21 +39852,21 @@ func (x *NodeStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Images = nil
} else {
- yyv3104 := &x.Images
- yym3105 := z.DecBinary()
- _ = yym3105
+ yyv3109 := &x.Images
+ yym3110 := z.DecBinary()
+ _ = yym3110
if false {
} else {
- h.decSliceContainerImage((*[]ContainerImage)(yyv3104), d)
+ h.decSliceContainerImage((*[]ContainerImage)(yyv3109), d)
}
}
- yyj3094++
- if yyhl3094 {
- yyb3094 = yyj3094 > l
+ yyj3099++
+ if yyhl3099 {
+ yyb3099 = yyj3099 > l
} else {
- yyb3094 = r.CheckBreak()
+ yyb3099 = r.CheckBreak()
}
- if yyb3094 {
+ if yyb3099 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -39810,21 +39874,21 @@ func (x *NodeStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.VolumesInUse = nil
} else {
- yyv3106 := &x.VolumesInUse
- yym3107 := z.DecBinary()
- _ = yym3107
+ yyv3111 := &x.VolumesInUse
+ yym3112 := z.DecBinary()
+ _ = yym3112
if false {
} else {
- h.decSliceUniqueVolumeName((*[]UniqueVolumeName)(yyv3106), d)
+ h.decSliceUniqueVolumeName((*[]UniqueVolumeName)(yyv3111), d)
}
}
- yyj3094++
- if yyhl3094 {
- yyb3094 = yyj3094 > l
+ yyj3099++
+ if yyhl3099 {
+ yyb3099 = yyj3099 > l
} else {
- yyb3094 = r.CheckBreak()
+ yyb3099 = r.CheckBreak()
}
- if yyb3094 {
+ if yyb3099 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -39832,26 +39896,26 @@ func (x *NodeStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.VolumesAttached = nil
} else {
- yyv3108 := &x.VolumesAttached
- yym3109 := z.DecBinary()
- _ = yym3109
+ yyv3113 := &x.VolumesAttached
+ yym3114 := z.DecBinary()
+ _ = yym3114
if false {
} else {
- h.decSliceAttachedVolume((*[]AttachedVolume)(yyv3108), d)
+ h.decSliceAttachedVolume((*[]AttachedVolume)(yyv3113), d)
}
}
for {
- yyj3094++
- if yyhl3094 {
- yyb3094 = yyj3094 > l
+ yyj3099++
+ if yyhl3099 {
+ yyb3099 = yyj3099 > l
} else {
- yyb3094 = r.CheckBreak()
+ yyb3099 = r.CheckBreak()
}
- if yyb3094 {
+ if yyb3099 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj3094-1, "")
+ z.DecStructFieldNotFound(yyj3099-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -39860,8 +39924,8 @@ func (x UniqueVolumeName) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
- yym3110 := z.EncBinary()
- _ = yym3110
+ yym3115 := z.EncBinary()
+ _ = yym3115
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
@@ -39873,8 +39937,8 @@ func (x *UniqueVolumeName) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym3111 := z.DecBinary()
- _ = yym3111
+ yym3116 := z.DecBinary()
+ _ = yym3116
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
@@ -39889,30 +39953,30 @@ func (x *AttachedVolume) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym3112 := z.EncBinary()
- _ = yym3112
+ yym3117 := z.EncBinary()
+ _ = yym3117
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep3113 := !z.EncBinary()
- yy2arr3113 := z.EncBasicHandle().StructToArray
- var yyq3113 [2]bool
- _, _, _ = yysep3113, yyq3113, yy2arr3113
- const yyr3113 bool = false
- var yynn3113 int
- if yyr3113 || yy2arr3113 {
+ yysep3118 := !z.EncBinary()
+ yy2arr3118 := z.EncBasicHandle().StructToArray
+ var yyq3118 [2]bool
+ _, _, _ = yysep3118, yyq3118, yy2arr3118
+ const yyr3118 bool = false
+ var yynn3118 int
+ if yyr3118 || yy2arr3118 {
r.EncodeArrayStart(2)
} else {
- yynn3113 = 2
- for _, b := range yyq3113 {
+ yynn3118 = 2
+ for _, b := range yyq3118 {
if b {
- yynn3113++
+ yynn3118++
}
}
- r.EncodeMapStart(yynn3113)
- yynn3113 = 0
+ r.EncodeMapStart(yynn3118)
+ yynn3118 = 0
}
- if yyr3113 || yy2arr3113 {
+ if yyr3118 || yy2arr3118 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
x.Name.CodecEncodeSelf(e)
} else {
@@ -39921,10 +39985,10 @@ func (x *AttachedVolume) CodecEncodeSelf(e *codec1978.Encoder) {
z.EncSendContainerState(codecSelfer_containerMapValue1234)
x.Name.CodecEncodeSelf(e)
}
- if yyr3113 || yy2arr3113 {
+ if yyr3118 || yy2arr3118 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym3116 := z.EncBinary()
- _ = yym3116
+ yym3121 := z.EncBinary()
+ _ = yym3121
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.DevicePath))
@@ -39933,14 +39997,14 @@ func (x *AttachedVolume) CodecEncodeSelf(e *codec1978.Encoder) {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("devicePath"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3117 := z.EncBinary()
- _ = yym3117
+ yym3122 := z.EncBinary()
+ _ = yym3122
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.DevicePath))
}
}
- if yyr3113 || yy2arr3113 {
+ if yyr3118 || yy2arr3118 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -39953,25 +40017,25 @@ func (x *AttachedVolume) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym3118 := z.DecBinary()
- _ = yym3118
+ yym3123 := z.DecBinary()
+ _ = yym3123
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct3119 := r.ContainerType()
- if yyct3119 == codecSelferValueTypeMap1234 {
- yyl3119 := r.ReadMapStart()
- if yyl3119 == 0 {
+ yyct3124 := r.ContainerType()
+ if yyct3124 == codecSelferValueTypeMap1234 {
+ yyl3124 := r.ReadMapStart()
+ if yyl3124 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl3119, d)
+ x.codecDecodeSelfFromMap(yyl3124, d)
}
- } else if yyct3119 == codecSelferValueTypeArray1234 {
- yyl3119 := r.ReadArrayStart()
- if yyl3119 == 0 {
+ } else if yyct3124 == codecSelferValueTypeArray1234 {
+ yyl3124 := r.ReadArrayStart()
+ if yyl3124 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl3119, d)
+ x.codecDecodeSelfFromArray(yyl3124, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -39983,12 +40047,12 @@ func (x *AttachedVolume) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys3120Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys3120Slc
- var yyhl3120 bool = l >= 0
- for yyj3120 := 0; ; yyj3120++ {
- if yyhl3120 {
- if yyj3120 >= l {
+ var yys3125Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3125Slc
+ var yyhl3125 bool = l >= 0
+ for yyj3125 := 0; ; yyj3125++ {
+ if yyhl3125 {
+ if yyj3125 >= l {
break
}
} else {
@@ -39997,10 +40061,10 @@ func (x *AttachedVolume) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys3120Slc = r.DecodeBytes(yys3120Slc, true, true)
- yys3120 := string(yys3120Slc)
+ yys3125Slc = r.DecodeBytes(yys3125Slc, true, true)
+ yys3125 := string(yys3125Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys3120 {
+ switch yys3125 {
case "name":
if r.TryDecodeAsNil() {
x.Name = ""
@@ -40014,9 +40078,9 @@ func (x *AttachedVolume) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
x.DevicePath = string(r.DecodeString())
}
default:
- z.DecStructFieldNotFound(-1, yys3120)
- } // end switch yys3120
- } // end for yyj3120
+ z.DecStructFieldNotFound(-1, yys3125)
+ } // end switch yys3125
+ } // end for yyj3125
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -40024,16 +40088,16 @@ func (x *AttachedVolume) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj3123 int
- var yyb3123 bool
- var yyhl3123 bool = l >= 0
- yyj3123++
- if yyhl3123 {
- yyb3123 = yyj3123 > l
+ var yyj3128 int
+ var yyb3128 bool
+ var yyhl3128 bool = l >= 0
+ yyj3128++
+ if yyhl3128 {
+ yyb3128 = yyj3128 > l
} else {
- yyb3123 = r.CheckBreak()
+ yyb3128 = r.CheckBreak()
}
- if yyb3123 {
+ if yyb3128 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -40043,13 +40107,13 @@ func (x *AttachedVolume) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Name = UniqueVolumeName(r.DecodeString())
}
- yyj3123++
- if yyhl3123 {
- yyb3123 = yyj3123 > l
+ yyj3128++
+ if yyhl3128 {
+ yyb3128 = yyj3128 > l
} else {
- yyb3123 = r.CheckBreak()
+ yyb3128 = r.CheckBreak()
}
- if yyb3123 {
+ if yyb3128 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -40060,17 +40124,17 @@ func (x *AttachedVolume) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
x.DevicePath = string(r.DecodeString())
}
for {
- yyj3123++
- if yyhl3123 {
- yyb3123 = yyj3123 > l
+ yyj3128++
+ if yyhl3128 {
+ yyb3128 = yyj3128 > l
} else {
- yyb3123 = r.CheckBreak()
+ yyb3128 = r.CheckBreak()
}
- if yyb3123 {
+ if yyb3128 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj3123-1, "")
+ z.DecStructFieldNotFound(yyj3128-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -40082,38 +40146,38 @@ func (x *AvoidPods) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym3126 := z.EncBinary()
- _ = yym3126
+ yym3131 := z.EncBinary()
+ _ = yym3131
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep3127 := !z.EncBinary()
- yy2arr3127 := z.EncBasicHandle().StructToArray
- var yyq3127 [1]bool
- _, _, _ = yysep3127, yyq3127, yy2arr3127
- const yyr3127 bool = false
- yyq3127[0] = len(x.PreferAvoidPods) != 0
- var yynn3127 int
- if yyr3127 || yy2arr3127 {
+ yysep3132 := !z.EncBinary()
+ yy2arr3132 := z.EncBasicHandle().StructToArray
+ var yyq3132 [1]bool
+ _, _, _ = yysep3132, yyq3132, yy2arr3132
+ const yyr3132 bool = false
+ yyq3132[0] = len(x.PreferAvoidPods) != 0
+ var yynn3132 int
+ if yyr3132 || yy2arr3132 {
r.EncodeArrayStart(1)
} else {
- yynn3127 = 0
- for _, b := range yyq3127 {
+ yynn3132 = 0
+ for _, b := range yyq3132 {
if b {
- yynn3127++
+ yynn3132++
}
}
- r.EncodeMapStart(yynn3127)
- yynn3127 = 0
+ r.EncodeMapStart(yynn3132)
+ yynn3132 = 0
}
- if yyr3127 || yy2arr3127 {
+ if yyr3132 || yy2arr3132 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3127[0] {
+ if yyq3132[0] {
if x.PreferAvoidPods == nil {
r.EncodeNil()
} else {
- yym3129 := z.EncBinary()
- _ = yym3129
+ yym3134 := z.EncBinary()
+ _ = yym3134
if false {
} else {
h.encSlicePreferAvoidPodsEntry(([]PreferAvoidPodsEntry)(x.PreferAvoidPods), e)
@@ -40123,15 +40187,15 @@ func (x *AvoidPods) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeNil()
}
} else {
- if yyq3127[0] {
+ if yyq3132[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("preferAvoidPods"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
if x.PreferAvoidPods == nil {
r.EncodeNil()
} else {
- yym3130 := z.EncBinary()
- _ = yym3130
+ yym3135 := z.EncBinary()
+ _ = yym3135
if false {
} else {
h.encSlicePreferAvoidPodsEntry(([]PreferAvoidPodsEntry)(x.PreferAvoidPods), e)
@@ -40139,7 +40203,7 @@ func (x *AvoidPods) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
- if yyr3127 || yy2arr3127 {
+ if yyr3132 || yy2arr3132 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -40152,25 +40216,25 @@ func (x *AvoidPods) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym3131 := z.DecBinary()
- _ = yym3131
+ yym3136 := z.DecBinary()
+ _ = yym3136
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct3132 := r.ContainerType()
- if yyct3132 == codecSelferValueTypeMap1234 {
- yyl3132 := r.ReadMapStart()
- if yyl3132 == 0 {
+ yyct3137 := r.ContainerType()
+ if yyct3137 == codecSelferValueTypeMap1234 {
+ yyl3137 := r.ReadMapStart()
+ if yyl3137 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl3132, d)
+ x.codecDecodeSelfFromMap(yyl3137, d)
}
- } else if yyct3132 == codecSelferValueTypeArray1234 {
- yyl3132 := r.ReadArrayStart()
- if yyl3132 == 0 {
+ } else if yyct3137 == codecSelferValueTypeArray1234 {
+ yyl3137 := r.ReadArrayStart()
+ if yyl3137 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl3132, d)
+ x.codecDecodeSelfFromArray(yyl3137, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -40182,12 +40246,12 @@ func (x *AvoidPods) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys3133Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys3133Slc
- var yyhl3133 bool = l >= 0
- for yyj3133 := 0; ; yyj3133++ {
- if yyhl3133 {
- if yyj3133 >= l {
+ var yys3138Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3138Slc
+ var yyhl3138 bool = l >= 0
+ for yyj3138 := 0; ; yyj3138++ {
+ if yyhl3138 {
+ if yyj3138 >= l {
break
}
} else {
@@ -40196,26 +40260,26 @@ func (x *AvoidPods) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys3133Slc = r.DecodeBytes(yys3133Slc, true, true)
- yys3133 := string(yys3133Slc)
+ yys3138Slc = r.DecodeBytes(yys3138Slc, true, true)
+ yys3138 := string(yys3138Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys3133 {
+ switch yys3138 {
case "preferAvoidPods":
if r.TryDecodeAsNil() {
x.PreferAvoidPods = nil
} else {
- yyv3134 := &x.PreferAvoidPods
- yym3135 := z.DecBinary()
- _ = yym3135
+ yyv3139 := &x.PreferAvoidPods
+ yym3140 := z.DecBinary()
+ _ = yym3140
if false {
} else {
- h.decSlicePreferAvoidPodsEntry((*[]PreferAvoidPodsEntry)(yyv3134), d)
+ h.decSlicePreferAvoidPodsEntry((*[]PreferAvoidPodsEntry)(yyv3139), d)
}
}
default:
- z.DecStructFieldNotFound(-1, yys3133)
- } // end switch yys3133
- } // end for yyj3133
+ z.DecStructFieldNotFound(-1, yys3138)
+ } // end switch yys3138
+ } // end for yyj3138
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -40223,16 +40287,16 @@ func (x *AvoidPods) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj3136 int
- var yyb3136 bool
- var yyhl3136 bool = l >= 0
- yyj3136++
- if yyhl3136 {
- yyb3136 = yyj3136 > l
+ var yyj3141 int
+ var yyb3141 bool
+ var yyhl3141 bool = l >= 0
+ yyj3141++
+ if yyhl3141 {
+ yyb3141 = yyj3141 > l
} else {
- yyb3136 = r.CheckBreak()
+ yyb3141 = r.CheckBreak()
}
- if yyb3136 {
+ if yyb3141 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -40240,26 +40304,26 @@ func (x *AvoidPods) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.PreferAvoidPods = nil
} else {
- yyv3137 := &x.PreferAvoidPods
- yym3138 := z.DecBinary()
- _ = yym3138
+ yyv3142 := &x.PreferAvoidPods
+ yym3143 := z.DecBinary()
+ _ = yym3143
if false {
} else {
- h.decSlicePreferAvoidPodsEntry((*[]PreferAvoidPodsEntry)(yyv3137), d)
+ h.decSlicePreferAvoidPodsEntry((*[]PreferAvoidPodsEntry)(yyv3142), d)
}
}
for {
- yyj3136++
- if yyhl3136 {
- yyb3136 = yyj3136 > l
+ yyj3141++
+ if yyhl3141 {
+ yyb3141 = yyj3141 > l
} else {
- yyb3136 = r.CheckBreak()
+ yyb3141 = r.CheckBreak()
}
- if yyb3136 {
+ if yyb3141 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj3136-1, "")
+ z.DecStructFieldNotFound(yyj3141-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -40271,111 +40335,111 @@ func (x *PreferAvoidPodsEntry) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym3139 := z.EncBinary()
- _ = yym3139
+ yym3144 := z.EncBinary()
+ _ = yym3144
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep3140 := !z.EncBinary()
- yy2arr3140 := z.EncBasicHandle().StructToArray
- var yyq3140 [4]bool
- _, _, _ = yysep3140, yyq3140, yy2arr3140
- const yyr3140 bool = false
- yyq3140[1] = true
- yyq3140[2] = x.Reason != ""
- yyq3140[3] = x.Message != ""
- var yynn3140 int
- if yyr3140 || yy2arr3140 {
+ yysep3145 := !z.EncBinary()
+ yy2arr3145 := z.EncBasicHandle().StructToArray
+ var yyq3145 [4]bool
+ _, _, _ = yysep3145, yyq3145, yy2arr3145
+ const yyr3145 bool = false
+ yyq3145[1] = true
+ yyq3145[2] = x.Reason != ""
+ yyq3145[3] = x.Message != ""
+ var yynn3145 int
+ if yyr3145 || yy2arr3145 {
r.EncodeArrayStart(4)
} else {
- yynn3140 = 1
- for _, b := range yyq3140 {
+ yynn3145 = 1
+ for _, b := range yyq3145 {
if b {
- yynn3140++
+ yynn3145++
}
}
- r.EncodeMapStart(yynn3140)
- yynn3140 = 0
+ r.EncodeMapStart(yynn3145)
+ yynn3145 = 0
}
- if yyr3140 || yy2arr3140 {
+ if yyr3145 || yy2arr3145 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy3142 := &x.PodSignature
- yy3142.CodecEncodeSelf(e)
+ yy3147 := &x.PodSignature
+ yy3147.CodecEncodeSelf(e)
} else {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("podSignature"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy3143 := &x.PodSignature
- yy3143.CodecEncodeSelf(e)
+ yy3148 := &x.PodSignature
+ yy3148.CodecEncodeSelf(e)
}
- if yyr3140 || yy2arr3140 {
+ if yyr3145 || yy2arr3145 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3140[1] {
- yy3145 := &x.EvictionTime
- yym3146 := z.EncBinary()
- _ = yym3146
+ if yyq3145[1] {
+ yy3150 := &x.EvictionTime
+ yym3151 := z.EncBinary()
+ _ = yym3151
if false {
- } else if z.HasExtensions() && z.EncExt(yy3145) {
- } else if yym3146 {
- z.EncBinaryMarshal(yy3145)
- } else if !yym3146 && z.IsJSONHandle() {
- z.EncJSONMarshal(yy3145)
+ } else if z.HasExtensions() && z.EncExt(yy3150) {
+ } else if yym3151 {
+ z.EncBinaryMarshal(yy3150)
+ } else if !yym3151 && z.IsJSONHandle() {
+ z.EncJSONMarshal(yy3150)
} else {
- z.EncFallback(yy3145)
+ z.EncFallback(yy3150)
}
} else {
r.EncodeNil()
}
} else {
- if yyq3140[1] {
+ if yyq3145[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("evictionTime"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy3147 := &x.EvictionTime
- yym3148 := z.EncBinary()
- _ = yym3148
- if false {
- } else if z.HasExtensions() && z.EncExt(yy3147) {
- } else if yym3148 {
- z.EncBinaryMarshal(yy3147)
- } else if !yym3148 && z.IsJSONHandle() {
- z.EncJSONMarshal(yy3147)
- } else {
- z.EncFallback(yy3147)
- }
- }
- }
- if yyr3140 || yy2arr3140 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3140[2] {
- yym3150 := z.EncBinary()
- _ = yym3150
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Reason))
- }
- } else {
- r.EncodeString(codecSelferC_UTF81234, "")
- }
- } else {
- if yyq3140[2] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("reason"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3151 := z.EncBinary()
- _ = yym3151
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Reason))
- }
- }
- }
- if yyr3140 || yy2arr3140 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3140[3] {
+ yy3152 := &x.EvictionTime
yym3153 := z.EncBinary()
_ = yym3153
if false {
+ } else if z.HasExtensions() && z.EncExt(yy3152) {
+ } else if yym3153 {
+ z.EncBinaryMarshal(yy3152)
+ } else if !yym3153 && z.IsJSONHandle() {
+ z.EncJSONMarshal(yy3152)
+ } else {
+ z.EncFallback(yy3152)
+ }
+ }
+ }
+ if yyr3145 || yy2arr3145 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq3145[2] {
+ yym3155 := z.EncBinary()
+ _ = yym3155
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Reason))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq3145[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("reason"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym3156 := z.EncBinary()
+ _ = yym3156
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Reason))
+ }
+ }
+ }
+ if yyr3145 || yy2arr3145 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq3145[3] {
+ yym3158 := z.EncBinary()
+ _ = yym3158
+ if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Message))
}
@@ -40383,19 +40447,19 @@ func (x *PreferAvoidPodsEntry) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq3140[3] {
+ if yyq3145[3] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("message"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3154 := z.EncBinary()
- _ = yym3154
+ yym3159 := z.EncBinary()
+ _ = yym3159
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Message))
}
}
}
- if yyr3140 || yy2arr3140 {
+ if yyr3145 || yy2arr3145 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -40408,25 +40472,25 @@ func (x *PreferAvoidPodsEntry) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym3155 := z.DecBinary()
- _ = yym3155
+ yym3160 := z.DecBinary()
+ _ = yym3160
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct3156 := r.ContainerType()
- if yyct3156 == codecSelferValueTypeMap1234 {
- yyl3156 := r.ReadMapStart()
- if yyl3156 == 0 {
+ yyct3161 := r.ContainerType()
+ if yyct3161 == codecSelferValueTypeMap1234 {
+ yyl3161 := r.ReadMapStart()
+ if yyl3161 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl3156, d)
+ x.codecDecodeSelfFromMap(yyl3161, d)
}
- } else if yyct3156 == codecSelferValueTypeArray1234 {
- yyl3156 := r.ReadArrayStart()
- if yyl3156 == 0 {
+ } else if yyct3161 == codecSelferValueTypeArray1234 {
+ yyl3161 := r.ReadArrayStart()
+ if yyl3161 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl3156, d)
+ x.codecDecodeSelfFromArray(yyl3161, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -40438,12 +40502,12 @@ func (x *PreferAvoidPodsEntry) codecDecodeSelfFromMap(l int, d *codec1978.Decode
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys3157Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys3157Slc
- var yyhl3157 bool = l >= 0
- for yyj3157 := 0; ; yyj3157++ {
- if yyhl3157 {
- if yyj3157 >= l {
+ var yys3162Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3162Slc
+ var yyhl3162 bool = l >= 0
+ for yyj3162 := 0; ; yyj3162++ {
+ if yyhl3162 {
+ if yyj3162 >= l {
break
}
} else {
@@ -40452,32 +40516,32 @@ func (x *PreferAvoidPodsEntry) codecDecodeSelfFromMap(l int, d *codec1978.Decode
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys3157Slc = r.DecodeBytes(yys3157Slc, true, true)
- yys3157 := string(yys3157Slc)
+ yys3162Slc = r.DecodeBytes(yys3162Slc, true, true)
+ yys3162 := string(yys3162Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys3157 {
+ switch yys3162 {
case "podSignature":
if r.TryDecodeAsNil() {
x.PodSignature = PodSignature{}
} else {
- yyv3158 := &x.PodSignature
- yyv3158.CodecDecodeSelf(d)
+ yyv3163 := &x.PodSignature
+ yyv3163.CodecDecodeSelf(d)
}
case "evictionTime":
if r.TryDecodeAsNil() {
x.EvictionTime = pkg2_v1.Time{}
} else {
- yyv3159 := &x.EvictionTime
- yym3160 := z.DecBinary()
- _ = yym3160
+ yyv3164 := &x.EvictionTime
+ yym3165 := z.DecBinary()
+ _ = yym3165
if false {
- } else if z.HasExtensions() && z.DecExt(yyv3159) {
- } else if yym3160 {
- z.DecBinaryUnmarshal(yyv3159)
- } else if !yym3160 && z.IsJSONHandle() {
- z.DecJSONUnmarshal(yyv3159)
+ } else if z.HasExtensions() && z.DecExt(yyv3164) {
+ } else if yym3165 {
+ z.DecBinaryUnmarshal(yyv3164)
+ } else if !yym3165 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv3164)
} else {
- z.DecFallback(yyv3159, false)
+ z.DecFallback(yyv3164, false)
}
}
case "reason":
@@ -40493,9 +40557,9 @@ func (x *PreferAvoidPodsEntry) codecDecodeSelfFromMap(l int, d *codec1978.Decode
x.Message = string(r.DecodeString())
}
default:
- z.DecStructFieldNotFound(-1, yys3157)
- } // end switch yys3157
- } // end for yyj3157
+ z.DecStructFieldNotFound(-1, yys3162)
+ } // end switch yys3162
+ } // end for yyj3162
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -40503,16 +40567,16 @@ func (x *PreferAvoidPodsEntry) codecDecodeSelfFromArray(l int, d *codec1978.Deco
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj3163 int
- var yyb3163 bool
- var yyhl3163 bool = l >= 0
- yyj3163++
- if yyhl3163 {
- yyb3163 = yyj3163 > l
+ var yyj3168 int
+ var yyb3168 bool
+ var yyhl3168 bool = l >= 0
+ yyj3168++
+ if yyhl3168 {
+ yyb3168 = yyj3168 > l
} else {
- yyb3163 = r.CheckBreak()
+ yyb3168 = r.CheckBreak()
}
- if yyb3163 {
+ if yyb3168 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -40520,16 +40584,16 @@ func (x *PreferAvoidPodsEntry) codecDecodeSelfFromArray(l int, d *codec1978.Deco
if r.TryDecodeAsNil() {
x.PodSignature = PodSignature{}
} else {
- yyv3164 := &x.PodSignature
- yyv3164.CodecDecodeSelf(d)
+ yyv3169 := &x.PodSignature
+ yyv3169.CodecDecodeSelf(d)
}
- yyj3163++
- if yyhl3163 {
- yyb3163 = yyj3163 > l
+ yyj3168++
+ if yyhl3168 {
+ yyb3168 = yyj3168 > l
} else {
- yyb3163 = r.CheckBreak()
+ yyb3168 = r.CheckBreak()
}
- if yyb3163 {
+ if yyb3168 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -40537,26 +40601,26 @@ func (x *PreferAvoidPodsEntry) codecDecodeSelfFromArray(l int, d *codec1978.Deco
if r.TryDecodeAsNil() {
x.EvictionTime = pkg2_v1.Time{}
} else {
- yyv3165 := &x.EvictionTime
- yym3166 := z.DecBinary()
- _ = yym3166
+ yyv3170 := &x.EvictionTime
+ yym3171 := z.DecBinary()
+ _ = yym3171
if false {
- } else if z.HasExtensions() && z.DecExt(yyv3165) {
- } else if yym3166 {
- z.DecBinaryUnmarshal(yyv3165)
- } else if !yym3166 && z.IsJSONHandle() {
- z.DecJSONUnmarshal(yyv3165)
+ } else if z.HasExtensions() && z.DecExt(yyv3170) {
+ } else if yym3171 {
+ z.DecBinaryUnmarshal(yyv3170)
+ } else if !yym3171 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv3170)
} else {
- z.DecFallback(yyv3165, false)
+ z.DecFallback(yyv3170, false)
}
}
- yyj3163++
- if yyhl3163 {
- yyb3163 = yyj3163 > l
+ yyj3168++
+ if yyhl3168 {
+ yyb3168 = yyj3168 > l
} else {
- yyb3163 = r.CheckBreak()
+ yyb3168 = r.CheckBreak()
}
- if yyb3163 {
+ if yyb3168 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -40566,13 +40630,13 @@ func (x *PreferAvoidPodsEntry) codecDecodeSelfFromArray(l int, d *codec1978.Deco
} else {
x.Reason = string(r.DecodeString())
}
- yyj3163++
- if yyhl3163 {
- yyb3163 = yyj3163 > l
+ yyj3168++
+ if yyhl3168 {
+ yyb3168 = yyj3168 > l
} else {
- yyb3163 = r.CheckBreak()
+ yyb3168 = r.CheckBreak()
}
- if yyb3163 {
+ if yyb3168 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -40583,17 +40647,17 @@ func (x *PreferAvoidPodsEntry) codecDecodeSelfFromArray(l int, d *codec1978.Deco
x.Message = string(r.DecodeString())
}
for {
- yyj3163++
- if yyhl3163 {
- yyb3163 = yyj3163 > l
+ yyj3168++
+ if yyhl3168 {
+ yyb3168 = yyj3168 > l
} else {
- yyb3163 = r.CheckBreak()
+ yyb3168 = r.CheckBreak()
}
- if yyb3163 {
+ if yyb3168 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj3163-1, "")
+ z.DecStructFieldNotFound(yyj3168-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -40605,38 +40669,38 @@ func (x *PodSignature) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym3169 := z.EncBinary()
- _ = yym3169
+ yym3174 := z.EncBinary()
+ _ = yym3174
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep3170 := !z.EncBinary()
- yy2arr3170 := z.EncBasicHandle().StructToArray
- var yyq3170 [1]bool
- _, _, _ = yysep3170, yyq3170, yy2arr3170
- const yyr3170 bool = false
- yyq3170[0] = x.PodController != nil
- var yynn3170 int
- if yyr3170 || yy2arr3170 {
+ yysep3175 := !z.EncBinary()
+ yy2arr3175 := z.EncBasicHandle().StructToArray
+ var yyq3175 [1]bool
+ _, _, _ = yysep3175, yyq3175, yy2arr3175
+ const yyr3175 bool = false
+ yyq3175[0] = x.PodController != nil
+ var yynn3175 int
+ if yyr3175 || yy2arr3175 {
r.EncodeArrayStart(1)
} else {
- yynn3170 = 0
- for _, b := range yyq3170 {
+ yynn3175 = 0
+ for _, b := range yyq3175 {
if b {
- yynn3170++
+ yynn3175++
}
}
- r.EncodeMapStart(yynn3170)
- yynn3170 = 0
+ r.EncodeMapStart(yynn3175)
+ yynn3175 = 0
}
- if yyr3170 || yy2arr3170 {
+ if yyr3175 || yy2arr3175 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3170[0] {
+ if yyq3175[0] {
if x.PodController == nil {
r.EncodeNil()
} else {
- yym3172 := z.EncBinary()
- _ = yym3172
+ yym3177 := z.EncBinary()
+ _ = yym3177
if false {
} else if z.HasExtensions() && z.EncExt(x.PodController) {
} else {
@@ -40647,15 +40711,15 @@ func (x *PodSignature) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeNil()
}
} else {
- if yyq3170[0] {
+ if yyq3175[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("podController"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
if x.PodController == nil {
r.EncodeNil()
} else {
- yym3173 := z.EncBinary()
- _ = yym3173
+ yym3178 := z.EncBinary()
+ _ = yym3178
if false {
} else if z.HasExtensions() && z.EncExt(x.PodController) {
} else {
@@ -40664,7 +40728,7 @@ func (x *PodSignature) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
- if yyr3170 || yy2arr3170 {
+ if yyr3175 || yy2arr3175 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -40677,25 +40741,25 @@ func (x *PodSignature) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym3174 := z.DecBinary()
- _ = yym3174
+ yym3179 := z.DecBinary()
+ _ = yym3179
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct3175 := r.ContainerType()
- if yyct3175 == codecSelferValueTypeMap1234 {
- yyl3175 := r.ReadMapStart()
- if yyl3175 == 0 {
+ yyct3180 := r.ContainerType()
+ if yyct3180 == codecSelferValueTypeMap1234 {
+ yyl3180 := r.ReadMapStart()
+ if yyl3180 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl3175, d)
+ x.codecDecodeSelfFromMap(yyl3180, d)
}
- } else if yyct3175 == codecSelferValueTypeArray1234 {
- yyl3175 := r.ReadArrayStart()
- if yyl3175 == 0 {
+ } else if yyct3180 == codecSelferValueTypeArray1234 {
+ yyl3180 := r.ReadArrayStart()
+ if yyl3180 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl3175, d)
+ x.codecDecodeSelfFromArray(yyl3180, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -40707,12 +40771,12 @@ func (x *PodSignature) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys3176Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys3176Slc
- var yyhl3176 bool = l >= 0
- for yyj3176 := 0; ; yyj3176++ {
- if yyhl3176 {
- if yyj3176 >= l {
+ var yys3181Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3181Slc
+ var yyhl3181 bool = l >= 0
+ for yyj3181 := 0; ; yyj3181++ {
+ if yyhl3181 {
+ if yyj3181 >= l {
break
}
} else {
@@ -40721,10 +40785,10 @@ func (x *PodSignature) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys3176Slc = r.DecodeBytes(yys3176Slc, true, true)
- yys3176 := string(yys3176Slc)
+ yys3181Slc = r.DecodeBytes(yys3181Slc, true, true)
+ yys3181 := string(yys3181Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys3176 {
+ switch yys3181 {
case "podController":
if r.TryDecodeAsNil() {
if x.PodController != nil {
@@ -40734,8 +40798,8 @@ func (x *PodSignature) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
if x.PodController == nil {
x.PodController = new(pkg2_v1.OwnerReference)
}
- yym3178 := z.DecBinary()
- _ = yym3178
+ yym3183 := z.DecBinary()
+ _ = yym3183
if false {
} else if z.HasExtensions() && z.DecExt(x.PodController) {
} else {
@@ -40743,9 +40807,9 @@ func (x *PodSignature) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
}
default:
- z.DecStructFieldNotFound(-1, yys3176)
- } // end switch yys3176
- } // end for yyj3176
+ z.DecStructFieldNotFound(-1, yys3181)
+ } // end switch yys3181
+ } // end for yyj3181
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -40753,16 +40817,16 @@ func (x *PodSignature) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj3179 int
- var yyb3179 bool
- var yyhl3179 bool = l >= 0
- yyj3179++
- if yyhl3179 {
- yyb3179 = yyj3179 > l
+ var yyj3184 int
+ var yyb3184 bool
+ var yyhl3184 bool = l >= 0
+ yyj3184++
+ if yyhl3184 {
+ yyb3184 = yyj3184 > l
} else {
- yyb3179 = r.CheckBreak()
+ yyb3184 = r.CheckBreak()
}
- if yyb3179 {
+ if yyb3184 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -40775,8 +40839,8 @@ func (x *PodSignature) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if x.PodController == nil {
x.PodController = new(pkg2_v1.OwnerReference)
}
- yym3181 := z.DecBinary()
- _ = yym3181
+ yym3186 := z.DecBinary()
+ _ = yym3186
if false {
} else if z.HasExtensions() && z.DecExt(x.PodController) {
} else {
@@ -40784,17 +40848,17 @@ func (x *PodSignature) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
}
}
for {
- yyj3179++
- if yyhl3179 {
- yyb3179 = yyj3179 > l
+ yyj3184++
+ if yyhl3184 {
+ yyb3184 = yyj3184 > l
} else {
- yyb3179 = r.CheckBreak()
+ yyb3184 = r.CheckBreak()
}
- if yyb3179 {
+ if yyb3184 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj3179-1, "")
+ z.DecStructFieldNotFound(yyj3184-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -40806,37 +40870,37 @@ func (x *ContainerImage) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym3182 := z.EncBinary()
- _ = yym3182
+ yym3187 := z.EncBinary()
+ _ = yym3187
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep3183 := !z.EncBinary()
- yy2arr3183 := z.EncBasicHandle().StructToArray
- var yyq3183 [2]bool
- _, _, _ = yysep3183, yyq3183, yy2arr3183
- const yyr3183 bool = false
- yyq3183[1] = x.SizeBytes != 0
- var yynn3183 int
- if yyr3183 || yy2arr3183 {
+ yysep3188 := !z.EncBinary()
+ yy2arr3188 := z.EncBasicHandle().StructToArray
+ var yyq3188 [2]bool
+ _, _, _ = yysep3188, yyq3188, yy2arr3188
+ const yyr3188 bool = false
+ yyq3188[1] = x.SizeBytes != 0
+ var yynn3188 int
+ if yyr3188 || yy2arr3188 {
r.EncodeArrayStart(2)
} else {
- yynn3183 = 1
- for _, b := range yyq3183 {
+ yynn3188 = 1
+ for _, b := range yyq3188 {
if b {
- yynn3183++
+ yynn3188++
}
}
- r.EncodeMapStart(yynn3183)
- yynn3183 = 0
+ r.EncodeMapStart(yynn3188)
+ yynn3188 = 0
}
- if yyr3183 || yy2arr3183 {
+ if yyr3188 || yy2arr3188 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if x.Names == nil {
r.EncodeNil()
} else {
- yym3185 := z.EncBinary()
- _ = yym3185
+ yym3190 := z.EncBinary()
+ _ = yym3190
if false {
} else {
z.F.EncSliceStringV(x.Names, false, e)
@@ -40849,19 +40913,19 @@ func (x *ContainerImage) CodecEncodeSelf(e *codec1978.Encoder) {
if x.Names == nil {
r.EncodeNil()
} else {
- yym3186 := z.EncBinary()
- _ = yym3186
+ yym3191 := z.EncBinary()
+ _ = yym3191
if false {
} else {
z.F.EncSliceStringV(x.Names, false, e)
}
}
}
- if yyr3183 || yy2arr3183 {
+ if yyr3188 || yy2arr3188 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3183[1] {
- yym3188 := z.EncBinary()
- _ = yym3188
+ if yyq3188[1] {
+ yym3193 := z.EncBinary()
+ _ = yym3193
if false {
} else {
r.EncodeInt(int64(x.SizeBytes))
@@ -40870,19 +40934,19 @@ func (x *ContainerImage) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeInt(0)
}
} else {
- if yyq3183[1] {
+ if yyq3188[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("sizeBytes"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3189 := z.EncBinary()
- _ = yym3189
+ yym3194 := z.EncBinary()
+ _ = yym3194
if false {
} else {
r.EncodeInt(int64(x.SizeBytes))
}
}
}
- if yyr3183 || yy2arr3183 {
+ if yyr3188 || yy2arr3188 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -40895,25 +40959,25 @@ func (x *ContainerImage) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym3190 := z.DecBinary()
- _ = yym3190
+ yym3195 := z.DecBinary()
+ _ = yym3195
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct3191 := r.ContainerType()
- if yyct3191 == codecSelferValueTypeMap1234 {
- yyl3191 := r.ReadMapStart()
- if yyl3191 == 0 {
+ yyct3196 := r.ContainerType()
+ if yyct3196 == codecSelferValueTypeMap1234 {
+ yyl3196 := r.ReadMapStart()
+ if yyl3196 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl3191, d)
+ x.codecDecodeSelfFromMap(yyl3196, d)
}
- } else if yyct3191 == codecSelferValueTypeArray1234 {
- yyl3191 := r.ReadArrayStart()
- if yyl3191 == 0 {
+ } else if yyct3196 == codecSelferValueTypeArray1234 {
+ yyl3196 := r.ReadArrayStart()
+ if yyl3196 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl3191, d)
+ x.codecDecodeSelfFromArray(yyl3196, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -40925,12 +40989,12 @@ func (x *ContainerImage) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys3192Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys3192Slc
- var yyhl3192 bool = l >= 0
- for yyj3192 := 0; ; yyj3192++ {
- if yyhl3192 {
- if yyj3192 >= l {
+ var yys3197Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3197Slc
+ var yyhl3197 bool = l >= 0
+ for yyj3197 := 0; ; yyj3197++ {
+ if yyhl3197 {
+ if yyj3197 >= l {
break
}
} else {
@@ -40939,20 +41003,20 @@ func (x *ContainerImage) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys3192Slc = r.DecodeBytes(yys3192Slc, true, true)
- yys3192 := string(yys3192Slc)
+ yys3197Slc = r.DecodeBytes(yys3197Slc, true, true)
+ yys3197 := string(yys3197Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys3192 {
+ switch yys3197 {
case "names":
if r.TryDecodeAsNil() {
x.Names = nil
} else {
- yyv3193 := &x.Names
- yym3194 := z.DecBinary()
- _ = yym3194
+ yyv3198 := &x.Names
+ yym3199 := z.DecBinary()
+ _ = yym3199
if false {
} else {
- z.F.DecSliceStringX(yyv3193, false, d)
+ z.F.DecSliceStringX(yyv3198, false, d)
}
}
case "sizeBytes":
@@ -40962,9 +41026,9 @@ func (x *ContainerImage) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
x.SizeBytes = int64(r.DecodeInt(64))
}
default:
- z.DecStructFieldNotFound(-1, yys3192)
- } // end switch yys3192
- } // end for yyj3192
+ z.DecStructFieldNotFound(-1, yys3197)
+ } // end switch yys3197
+ } // end for yyj3197
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -40972,16 +41036,16 @@ func (x *ContainerImage) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj3196 int
- var yyb3196 bool
- var yyhl3196 bool = l >= 0
- yyj3196++
- if yyhl3196 {
- yyb3196 = yyj3196 > l
+ var yyj3201 int
+ var yyb3201 bool
+ var yyhl3201 bool = l >= 0
+ yyj3201++
+ if yyhl3201 {
+ yyb3201 = yyj3201 > l
} else {
- yyb3196 = r.CheckBreak()
+ yyb3201 = r.CheckBreak()
}
- if yyb3196 {
+ if yyb3201 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -40989,21 +41053,21 @@ func (x *ContainerImage) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Names = nil
} else {
- yyv3197 := &x.Names
- yym3198 := z.DecBinary()
- _ = yym3198
+ yyv3202 := &x.Names
+ yym3203 := z.DecBinary()
+ _ = yym3203
if false {
} else {
- z.F.DecSliceStringX(yyv3197, false, d)
+ z.F.DecSliceStringX(yyv3202, false, d)
}
}
- yyj3196++
- if yyhl3196 {
- yyb3196 = yyj3196 > l
+ yyj3201++
+ if yyhl3201 {
+ yyb3201 = yyj3201 > l
} else {
- yyb3196 = r.CheckBreak()
+ yyb3201 = r.CheckBreak()
}
- if yyb3196 {
+ if yyb3201 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -41014,17 +41078,17 @@ func (x *ContainerImage) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
x.SizeBytes = int64(r.DecodeInt(64))
}
for {
- yyj3196++
- if yyhl3196 {
- yyb3196 = yyj3196 > l
+ yyj3201++
+ if yyhl3201 {
+ yyb3201 = yyj3201 > l
} else {
- yyb3196 = r.CheckBreak()
+ yyb3201 = r.CheckBreak()
}
- if yyb3196 {
+ if yyb3201 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj3196-1, "")
+ z.DecStructFieldNotFound(yyj3201-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -41033,8 +41097,8 @@ func (x NodePhase) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
- yym3200 := z.EncBinary()
- _ = yym3200
+ yym3205 := z.EncBinary()
+ _ = yym3205
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
@@ -41046,8 +41110,8 @@ func (x *NodePhase) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym3201 := z.DecBinary()
- _ = yym3201
+ yym3206 := z.DecBinary()
+ _ = yym3206
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
@@ -41059,8 +41123,8 @@ func (x NodeConditionType) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
- yym3202 := z.EncBinary()
- _ = yym3202
+ yym3207 := z.EncBinary()
+ _ = yym3207
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
@@ -41072,8 +41136,8 @@ func (x *NodeConditionType) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym3203 := z.DecBinary()
- _ = yym3203
+ yym3208 := z.DecBinary()
+ _ = yym3208
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
@@ -41088,34 +41152,34 @@ func (x *NodeCondition) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym3204 := z.EncBinary()
- _ = yym3204
+ yym3209 := z.EncBinary()
+ _ = yym3209
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep3205 := !z.EncBinary()
- yy2arr3205 := z.EncBasicHandle().StructToArray
- var yyq3205 [6]bool
- _, _, _ = yysep3205, yyq3205, yy2arr3205
- const yyr3205 bool = false
- yyq3205[2] = true
- yyq3205[3] = true
- yyq3205[4] = x.Reason != ""
- yyq3205[5] = x.Message != ""
- var yynn3205 int
- if yyr3205 || yy2arr3205 {
+ yysep3210 := !z.EncBinary()
+ yy2arr3210 := z.EncBasicHandle().StructToArray
+ var yyq3210 [6]bool
+ _, _, _ = yysep3210, yyq3210, yy2arr3210
+ const yyr3210 bool = false
+ yyq3210[2] = true
+ yyq3210[3] = true
+ yyq3210[4] = x.Reason != ""
+ yyq3210[5] = x.Message != ""
+ var yynn3210 int
+ if yyr3210 || yy2arr3210 {
r.EncodeArrayStart(6)
} else {
- yynn3205 = 2
- for _, b := range yyq3205 {
+ yynn3210 = 2
+ for _, b := range yyq3210 {
if b {
- yynn3205++
+ yynn3210++
}
}
- r.EncodeMapStart(yynn3205)
- yynn3205 = 0
+ r.EncodeMapStart(yynn3210)
+ yynn3210 = 0
}
- if yyr3205 || yy2arr3205 {
+ if yyr3210 || yy2arr3210 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
x.Type.CodecEncodeSelf(e)
} else {
@@ -41124,7 +41188,7 @@ func (x *NodeCondition) CodecEncodeSelf(e *codec1978.Encoder) {
z.EncSendContainerState(codecSelfer_containerMapValue1234)
x.Type.CodecEncodeSelf(e)
}
- if yyr3205 || yy2arr3205 {
+ if yyr3210 || yy2arr3210 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
x.Status.CodecEncodeSelf(e)
} else {
@@ -41133,47 +41197,10 @@ func (x *NodeCondition) CodecEncodeSelf(e *codec1978.Encoder) {
z.EncSendContainerState(codecSelfer_containerMapValue1234)
x.Status.CodecEncodeSelf(e)
}
- if yyr3205 || yy2arr3205 {
+ if yyr3210 || yy2arr3210 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3205[2] {
- yy3209 := &x.LastHeartbeatTime
- yym3210 := z.EncBinary()
- _ = yym3210
- if false {
- } else if z.HasExtensions() && z.EncExt(yy3209) {
- } else if yym3210 {
- z.EncBinaryMarshal(yy3209)
- } else if !yym3210 && z.IsJSONHandle() {
- z.EncJSONMarshal(yy3209)
- } else {
- z.EncFallback(yy3209)
- }
- } else {
- r.EncodeNil()
- }
- } else {
- if yyq3205[2] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("lastHeartbeatTime"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy3211 := &x.LastHeartbeatTime
- yym3212 := z.EncBinary()
- _ = yym3212
- if false {
- } else if z.HasExtensions() && z.EncExt(yy3211) {
- } else if yym3212 {
- z.EncBinaryMarshal(yy3211)
- } else if !yym3212 && z.IsJSONHandle() {
- z.EncJSONMarshal(yy3211)
- } else {
- z.EncFallback(yy3211)
- }
- }
- }
- if yyr3205 || yy2arr3205 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3205[3] {
- yy3214 := &x.LastTransitionTime
+ if yyq3210[2] {
+ yy3214 := &x.LastHeartbeatTime
yym3215 := z.EncBinary()
_ = yym3215
if false {
@@ -41189,11 +41216,11 @@ func (x *NodeCondition) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeNil()
}
} else {
- if yyq3205[3] {
+ if yyq3210[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("lastTransitionTime"))
+ r.EncodeString(codecSelferC_UTF81234, string("lastHeartbeatTime"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy3216 := &x.LastTransitionTime
+ yy3216 := &x.LastHeartbeatTime
yym3217 := z.EncBinary()
_ = yym3217
if false {
@@ -41207,36 +41234,73 @@ func (x *NodeCondition) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
- if yyr3205 || yy2arr3205 {
+ if yyr3210 || yy2arr3210 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3205[4] {
- yym3219 := z.EncBinary()
- _ = yym3219
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Reason))
- }
- } else {
- r.EncodeString(codecSelferC_UTF81234, "")
- }
- } else {
- if yyq3205[4] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("reason"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if yyq3210[3] {
+ yy3219 := &x.LastTransitionTime
yym3220 := z.EncBinary()
_ = yym3220
if false {
+ } else if z.HasExtensions() && z.EncExt(yy3219) {
+ } else if yym3220 {
+ z.EncBinaryMarshal(yy3219)
+ } else if !yym3220 && z.IsJSONHandle() {
+ z.EncJSONMarshal(yy3219)
+ } else {
+ z.EncFallback(yy3219)
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq3210[3] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("lastTransitionTime"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy3221 := &x.LastTransitionTime
+ yym3222 := z.EncBinary()
+ _ = yym3222
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy3221) {
+ } else if yym3222 {
+ z.EncBinaryMarshal(yy3221)
+ } else if !yym3222 && z.IsJSONHandle() {
+ z.EncJSONMarshal(yy3221)
+ } else {
+ z.EncFallback(yy3221)
+ }
+ }
+ }
+ if yyr3210 || yy2arr3210 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq3210[4] {
+ yym3224 := z.EncBinary()
+ _ = yym3224
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Reason))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq3210[4] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("reason"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym3225 := z.EncBinary()
+ _ = yym3225
+ if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Reason))
}
}
}
- if yyr3205 || yy2arr3205 {
+ if yyr3210 || yy2arr3210 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3205[5] {
- yym3222 := z.EncBinary()
- _ = yym3222
+ if yyq3210[5] {
+ yym3227 := z.EncBinary()
+ _ = yym3227
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Message))
@@ -41245,19 +41309,19 @@ func (x *NodeCondition) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq3205[5] {
+ if yyq3210[5] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("message"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3223 := z.EncBinary()
- _ = yym3223
+ yym3228 := z.EncBinary()
+ _ = yym3228
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Message))
}
}
}
- if yyr3205 || yy2arr3205 {
+ if yyr3210 || yy2arr3210 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -41270,25 +41334,25 @@ func (x *NodeCondition) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym3224 := z.DecBinary()
- _ = yym3224
+ yym3229 := z.DecBinary()
+ _ = yym3229
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct3225 := r.ContainerType()
- if yyct3225 == codecSelferValueTypeMap1234 {
- yyl3225 := r.ReadMapStart()
- if yyl3225 == 0 {
+ yyct3230 := r.ContainerType()
+ if yyct3230 == codecSelferValueTypeMap1234 {
+ yyl3230 := r.ReadMapStart()
+ if yyl3230 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl3225, d)
+ x.codecDecodeSelfFromMap(yyl3230, d)
}
- } else if yyct3225 == codecSelferValueTypeArray1234 {
- yyl3225 := r.ReadArrayStart()
- if yyl3225 == 0 {
+ } else if yyct3230 == codecSelferValueTypeArray1234 {
+ yyl3230 := r.ReadArrayStart()
+ if yyl3230 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl3225, d)
+ x.codecDecodeSelfFromArray(yyl3230, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -41300,12 +41364,12 @@ func (x *NodeCondition) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys3226Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys3226Slc
- var yyhl3226 bool = l >= 0
- for yyj3226 := 0; ; yyj3226++ {
- if yyhl3226 {
- if yyj3226 >= l {
+ var yys3231Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3231Slc
+ var yyhl3231 bool = l >= 0
+ for yyj3231 := 0; ; yyj3231++ {
+ if yyhl3231 {
+ if yyj3231 >= l {
break
}
} else {
@@ -41314,10 +41378,10 @@ func (x *NodeCondition) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys3226Slc = r.DecodeBytes(yys3226Slc, true, true)
- yys3226 := string(yys3226Slc)
+ yys3231Slc = r.DecodeBytes(yys3231Slc, true, true)
+ yys3231 := string(yys3231Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys3226 {
+ switch yys3231 {
case "type":
if r.TryDecodeAsNil() {
x.Type = ""
@@ -41334,34 +41398,34 @@ func (x *NodeCondition) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.LastHeartbeatTime = pkg2_v1.Time{}
} else {
- yyv3229 := &x.LastHeartbeatTime
- yym3230 := z.DecBinary()
- _ = yym3230
+ yyv3234 := &x.LastHeartbeatTime
+ yym3235 := z.DecBinary()
+ _ = yym3235
if false {
- } else if z.HasExtensions() && z.DecExt(yyv3229) {
- } else if yym3230 {
- z.DecBinaryUnmarshal(yyv3229)
- } else if !yym3230 && z.IsJSONHandle() {
- z.DecJSONUnmarshal(yyv3229)
+ } else if z.HasExtensions() && z.DecExt(yyv3234) {
+ } else if yym3235 {
+ z.DecBinaryUnmarshal(yyv3234)
+ } else if !yym3235 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv3234)
} else {
- z.DecFallback(yyv3229, false)
+ z.DecFallback(yyv3234, false)
}
}
case "lastTransitionTime":
if r.TryDecodeAsNil() {
x.LastTransitionTime = pkg2_v1.Time{}
} else {
- yyv3231 := &x.LastTransitionTime
- yym3232 := z.DecBinary()
- _ = yym3232
+ yyv3236 := &x.LastTransitionTime
+ yym3237 := z.DecBinary()
+ _ = yym3237
if false {
- } else if z.HasExtensions() && z.DecExt(yyv3231) {
- } else if yym3232 {
- z.DecBinaryUnmarshal(yyv3231)
- } else if !yym3232 && z.IsJSONHandle() {
- z.DecJSONUnmarshal(yyv3231)
+ } else if z.HasExtensions() && z.DecExt(yyv3236) {
+ } else if yym3237 {
+ z.DecBinaryUnmarshal(yyv3236)
+ } else if !yym3237 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv3236)
} else {
- z.DecFallback(yyv3231, false)
+ z.DecFallback(yyv3236, false)
}
}
case "reason":
@@ -41377,9 +41441,9 @@ func (x *NodeCondition) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
x.Message = string(r.DecodeString())
}
default:
- z.DecStructFieldNotFound(-1, yys3226)
- } // end switch yys3226
- } // end for yyj3226
+ z.DecStructFieldNotFound(-1, yys3231)
+ } // end switch yys3231
+ } // end for yyj3231
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -41387,16 +41451,16 @@ func (x *NodeCondition) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj3235 int
- var yyb3235 bool
- var yyhl3235 bool = l >= 0
- yyj3235++
- if yyhl3235 {
- yyb3235 = yyj3235 > l
+ var yyj3240 int
+ var yyb3240 bool
+ var yyhl3240 bool = l >= 0
+ yyj3240++
+ if yyhl3240 {
+ yyb3240 = yyj3240 > l
} else {
- yyb3235 = r.CheckBreak()
+ yyb3240 = r.CheckBreak()
}
- if yyb3235 {
+ if yyb3240 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -41406,13 +41470,13 @@ func (x *NodeCondition) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Type = NodeConditionType(r.DecodeString())
}
- yyj3235++
- if yyhl3235 {
- yyb3235 = yyj3235 > l
+ yyj3240++
+ if yyhl3240 {
+ yyb3240 = yyj3240 > l
} else {
- yyb3235 = r.CheckBreak()
+ yyb3240 = r.CheckBreak()
}
- if yyb3235 {
+ if yyb3240 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -41422,13 +41486,13 @@ func (x *NodeCondition) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Status = ConditionStatus(r.DecodeString())
}
- yyj3235++
- if yyhl3235 {
- yyb3235 = yyj3235 > l
+ yyj3240++
+ if yyhl3240 {
+ yyb3240 = yyj3240 > l
} else {
- yyb3235 = r.CheckBreak()
+ yyb3240 = r.CheckBreak()
}
- if yyb3235 {
+ if yyb3240 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -41436,26 +41500,26 @@ func (x *NodeCondition) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.LastHeartbeatTime = pkg2_v1.Time{}
} else {
- yyv3238 := &x.LastHeartbeatTime
- yym3239 := z.DecBinary()
- _ = yym3239
+ yyv3243 := &x.LastHeartbeatTime
+ yym3244 := z.DecBinary()
+ _ = yym3244
if false {
- } else if z.HasExtensions() && z.DecExt(yyv3238) {
- } else if yym3239 {
- z.DecBinaryUnmarshal(yyv3238)
- } else if !yym3239 && z.IsJSONHandle() {
- z.DecJSONUnmarshal(yyv3238)
+ } else if z.HasExtensions() && z.DecExt(yyv3243) {
+ } else if yym3244 {
+ z.DecBinaryUnmarshal(yyv3243)
+ } else if !yym3244 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv3243)
} else {
- z.DecFallback(yyv3238, false)
+ z.DecFallback(yyv3243, false)
}
}
- yyj3235++
- if yyhl3235 {
- yyb3235 = yyj3235 > l
+ yyj3240++
+ if yyhl3240 {
+ yyb3240 = yyj3240 > l
} else {
- yyb3235 = r.CheckBreak()
+ yyb3240 = r.CheckBreak()
}
- if yyb3235 {
+ if yyb3240 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -41463,26 +41527,26 @@ func (x *NodeCondition) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.LastTransitionTime = pkg2_v1.Time{}
} else {
- yyv3240 := &x.LastTransitionTime
- yym3241 := z.DecBinary()
- _ = yym3241
+ yyv3245 := &x.LastTransitionTime
+ yym3246 := z.DecBinary()
+ _ = yym3246
if false {
- } else if z.HasExtensions() && z.DecExt(yyv3240) {
- } else if yym3241 {
- z.DecBinaryUnmarshal(yyv3240)
- } else if !yym3241 && z.IsJSONHandle() {
- z.DecJSONUnmarshal(yyv3240)
+ } else if z.HasExtensions() && z.DecExt(yyv3245) {
+ } else if yym3246 {
+ z.DecBinaryUnmarshal(yyv3245)
+ } else if !yym3246 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv3245)
} else {
- z.DecFallback(yyv3240, false)
+ z.DecFallback(yyv3245, false)
}
}
- yyj3235++
- if yyhl3235 {
- yyb3235 = yyj3235 > l
+ yyj3240++
+ if yyhl3240 {
+ yyb3240 = yyj3240 > l
} else {
- yyb3235 = r.CheckBreak()
+ yyb3240 = r.CheckBreak()
}
- if yyb3235 {
+ if yyb3240 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -41492,13 +41556,13 @@ func (x *NodeCondition) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Reason = string(r.DecodeString())
}
- yyj3235++
- if yyhl3235 {
- yyb3235 = yyj3235 > l
+ yyj3240++
+ if yyhl3240 {
+ yyb3240 = yyj3240 > l
} else {
- yyb3235 = r.CheckBreak()
+ yyb3240 = r.CheckBreak()
}
- if yyb3235 {
+ if yyb3240 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -41509,17 +41573,17 @@ func (x *NodeCondition) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
x.Message = string(r.DecodeString())
}
for {
- yyj3235++
- if yyhl3235 {
- yyb3235 = yyj3235 > l
+ yyj3240++
+ if yyhl3240 {
+ yyb3240 = yyj3240 > l
} else {
- yyb3235 = r.CheckBreak()
+ yyb3240 = r.CheckBreak()
}
- if yyb3235 {
+ if yyb3240 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj3235-1, "")
+ z.DecStructFieldNotFound(yyj3240-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -41528,8 +41592,8 @@ func (x NodeAddressType) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
- yym3244 := z.EncBinary()
- _ = yym3244
+ yym3249 := z.EncBinary()
+ _ = yym3249
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
@@ -41541,8 +41605,8 @@ func (x *NodeAddressType) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym3245 := z.DecBinary()
- _ = yym3245
+ yym3250 := z.DecBinary()
+ _ = yym3250
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
@@ -41557,30 +41621,30 @@ func (x *NodeAddress) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym3246 := z.EncBinary()
- _ = yym3246
+ yym3251 := z.EncBinary()
+ _ = yym3251
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep3247 := !z.EncBinary()
- yy2arr3247 := z.EncBasicHandle().StructToArray
- var yyq3247 [2]bool
- _, _, _ = yysep3247, yyq3247, yy2arr3247
- const yyr3247 bool = false
- var yynn3247 int
- if yyr3247 || yy2arr3247 {
+ yysep3252 := !z.EncBinary()
+ yy2arr3252 := z.EncBasicHandle().StructToArray
+ var yyq3252 [2]bool
+ _, _, _ = yysep3252, yyq3252, yy2arr3252
+ const yyr3252 bool = false
+ var yynn3252 int
+ if yyr3252 || yy2arr3252 {
r.EncodeArrayStart(2)
} else {
- yynn3247 = 2
- for _, b := range yyq3247 {
+ yynn3252 = 2
+ for _, b := range yyq3252 {
if b {
- yynn3247++
+ yynn3252++
}
}
- r.EncodeMapStart(yynn3247)
- yynn3247 = 0
+ r.EncodeMapStart(yynn3252)
+ yynn3252 = 0
}
- if yyr3247 || yy2arr3247 {
+ if yyr3252 || yy2arr3252 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
x.Type.CodecEncodeSelf(e)
} else {
@@ -41589,10 +41653,10 @@ func (x *NodeAddress) CodecEncodeSelf(e *codec1978.Encoder) {
z.EncSendContainerState(codecSelfer_containerMapValue1234)
x.Type.CodecEncodeSelf(e)
}
- if yyr3247 || yy2arr3247 {
+ if yyr3252 || yy2arr3252 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym3250 := z.EncBinary()
- _ = yym3250
+ yym3255 := z.EncBinary()
+ _ = yym3255
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Address))
@@ -41601,14 +41665,14 @@ func (x *NodeAddress) CodecEncodeSelf(e *codec1978.Encoder) {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("address"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3251 := z.EncBinary()
- _ = yym3251
+ yym3256 := z.EncBinary()
+ _ = yym3256
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Address))
}
}
- if yyr3247 || yy2arr3247 {
+ if yyr3252 || yy2arr3252 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -41621,25 +41685,25 @@ func (x *NodeAddress) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym3252 := z.DecBinary()
- _ = yym3252
+ yym3257 := z.DecBinary()
+ _ = yym3257
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct3253 := r.ContainerType()
- if yyct3253 == codecSelferValueTypeMap1234 {
- yyl3253 := r.ReadMapStart()
- if yyl3253 == 0 {
+ yyct3258 := r.ContainerType()
+ if yyct3258 == codecSelferValueTypeMap1234 {
+ yyl3258 := r.ReadMapStart()
+ if yyl3258 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl3253, d)
+ x.codecDecodeSelfFromMap(yyl3258, d)
}
- } else if yyct3253 == codecSelferValueTypeArray1234 {
- yyl3253 := r.ReadArrayStart()
- if yyl3253 == 0 {
+ } else if yyct3258 == codecSelferValueTypeArray1234 {
+ yyl3258 := r.ReadArrayStart()
+ if yyl3258 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl3253, d)
+ x.codecDecodeSelfFromArray(yyl3258, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -41651,12 +41715,12 @@ func (x *NodeAddress) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys3254Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys3254Slc
- var yyhl3254 bool = l >= 0
- for yyj3254 := 0; ; yyj3254++ {
- if yyhl3254 {
- if yyj3254 >= l {
+ var yys3259Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3259Slc
+ var yyhl3259 bool = l >= 0
+ for yyj3259 := 0; ; yyj3259++ {
+ if yyhl3259 {
+ if yyj3259 >= l {
break
}
} else {
@@ -41665,10 +41729,10 @@ func (x *NodeAddress) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys3254Slc = r.DecodeBytes(yys3254Slc, true, true)
- yys3254 := string(yys3254Slc)
+ yys3259Slc = r.DecodeBytes(yys3259Slc, true, true)
+ yys3259 := string(yys3259Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys3254 {
+ switch yys3259 {
case "type":
if r.TryDecodeAsNil() {
x.Type = ""
@@ -41682,9 +41746,9 @@ func (x *NodeAddress) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
x.Address = string(r.DecodeString())
}
default:
- z.DecStructFieldNotFound(-1, yys3254)
- } // end switch yys3254
- } // end for yyj3254
+ z.DecStructFieldNotFound(-1, yys3259)
+ } // end switch yys3259
+ } // end for yyj3259
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -41692,16 +41756,16 @@ func (x *NodeAddress) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj3257 int
- var yyb3257 bool
- var yyhl3257 bool = l >= 0
- yyj3257++
- if yyhl3257 {
- yyb3257 = yyj3257 > l
+ var yyj3262 int
+ var yyb3262 bool
+ var yyhl3262 bool = l >= 0
+ yyj3262++
+ if yyhl3262 {
+ yyb3262 = yyj3262 > l
} else {
- yyb3257 = r.CheckBreak()
+ yyb3262 = r.CheckBreak()
}
- if yyb3257 {
+ if yyb3262 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -41711,13 +41775,13 @@ func (x *NodeAddress) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Type = NodeAddressType(r.DecodeString())
}
- yyj3257++
- if yyhl3257 {
- yyb3257 = yyj3257 > l
+ yyj3262++
+ if yyhl3262 {
+ yyb3262 = yyj3262 > l
} else {
- yyb3257 = r.CheckBreak()
+ yyb3262 = r.CheckBreak()
}
- if yyb3257 {
+ if yyb3262 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -41728,17 +41792,17 @@ func (x *NodeAddress) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
x.Address = string(r.DecodeString())
}
for {
- yyj3257++
- if yyhl3257 {
- yyb3257 = yyj3257 > l
+ yyj3262++
+ if yyhl3262 {
+ yyb3262 = yyj3262 > l
} else {
- yyb3257 = r.CheckBreak()
+ yyb3262 = r.CheckBreak()
}
- if yyb3257 {
+ if yyb3262 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj3257-1, "")
+ z.DecStructFieldNotFound(yyj3262-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -41747,8 +41811,8 @@ func (x ResourceName) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
- yym3260 := z.EncBinary()
- _ = yym3260
+ yym3265 := z.EncBinary()
+ _ = yym3265
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
@@ -41760,8 +41824,8 @@ func (x *ResourceName) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym3261 := z.DecBinary()
- _ = yym3261
+ yym3266 := z.DecBinary()
+ _ = yym3266
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
@@ -41776,8 +41840,8 @@ func (x ResourceList) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym3262 := z.EncBinary()
- _ = yym3262
+ yym3267 := z.EncBinary()
+ _ = yym3267
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
@@ -41790,8 +41854,8 @@ func (x *ResourceList) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym3263 := z.DecBinary()
- _ = yym3263
+ yym3268 := z.DecBinary()
+ _ = yym3268
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
@@ -41806,39 +41870,39 @@ func (x *Node) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym3264 := z.EncBinary()
- _ = yym3264
+ yym3269 := z.EncBinary()
+ _ = yym3269
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep3265 := !z.EncBinary()
- yy2arr3265 := z.EncBasicHandle().StructToArray
- var yyq3265 [5]bool
- _, _, _ = yysep3265, yyq3265, yy2arr3265
- const yyr3265 bool = false
- yyq3265[0] = x.Kind != ""
- yyq3265[1] = x.APIVersion != ""
- yyq3265[2] = true
- yyq3265[3] = true
- yyq3265[4] = true
- var yynn3265 int
- if yyr3265 || yy2arr3265 {
+ yysep3270 := !z.EncBinary()
+ yy2arr3270 := z.EncBasicHandle().StructToArray
+ var yyq3270 [5]bool
+ _, _, _ = yysep3270, yyq3270, yy2arr3270
+ const yyr3270 bool = false
+ yyq3270[0] = x.Kind != ""
+ yyq3270[1] = x.APIVersion != ""
+ yyq3270[2] = true
+ yyq3270[3] = true
+ yyq3270[4] = true
+ var yynn3270 int
+ if yyr3270 || yy2arr3270 {
r.EncodeArrayStart(5)
} else {
- yynn3265 = 0
- for _, b := range yyq3265 {
+ yynn3270 = 0
+ for _, b := range yyq3270 {
if b {
- yynn3265++
+ yynn3270++
}
}
- r.EncodeMapStart(yynn3265)
- yynn3265 = 0
+ r.EncodeMapStart(yynn3270)
+ yynn3270 = 0
}
- if yyr3265 || yy2arr3265 {
+ if yyr3270 || yy2arr3270 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3265[0] {
- yym3267 := z.EncBinary()
- _ = yym3267
+ if yyq3270[0] {
+ yym3272 := z.EncBinary()
+ _ = yym3272
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
@@ -41847,23 +41911,23 @@ func (x *Node) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq3265[0] {
+ if yyq3270[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("kind"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3268 := z.EncBinary()
- _ = yym3268
+ yym3273 := z.EncBinary()
+ _ = yym3273
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
}
}
}
- if yyr3265 || yy2arr3265 {
+ if yyr3270 || yy2arr3270 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3265[1] {
- yym3270 := z.EncBinary()
- _ = yym3270
+ if yyq3270[1] {
+ yym3275 := z.EncBinary()
+ _ = yym3275
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
@@ -41872,70 +41936,70 @@ func (x *Node) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq3265[1] {
+ if yyq3270[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3271 := z.EncBinary()
- _ = yym3271
+ yym3276 := z.EncBinary()
+ _ = yym3276
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
}
}
}
- if yyr3265 || yy2arr3265 {
+ if yyr3270 || yy2arr3270 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3265[2] {
- yy3273 := &x.ObjectMeta
- yy3273.CodecEncodeSelf(e)
+ if yyq3270[2] {
+ yy3278 := &x.ObjectMeta
+ yy3278.CodecEncodeSelf(e)
} else {
r.EncodeNil()
}
} else {
- if yyq3265[2] {
+ if yyq3270[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("metadata"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy3274 := &x.ObjectMeta
- yy3274.CodecEncodeSelf(e)
+ yy3279 := &x.ObjectMeta
+ yy3279.CodecEncodeSelf(e)
}
}
- if yyr3265 || yy2arr3265 {
+ if yyr3270 || yy2arr3270 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3265[3] {
- yy3276 := &x.Spec
- yy3276.CodecEncodeSelf(e)
+ if yyq3270[3] {
+ yy3281 := &x.Spec
+ yy3281.CodecEncodeSelf(e)
} else {
r.EncodeNil()
}
} else {
- if yyq3265[3] {
+ if yyq3270[3] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("spec"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy3277 := &x.Spec
- yy3277.CodecEncodeSelf(e)
+ yy3282 := &x.Spec
+ yy3282.CodecEncodeSelf(e)
}
}
- if yyr3265 || yy2arr3265 {
+ if yyr3270 || yy2arr3270 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3265[4] {
- yy3279 := &x.Status
- yy3279.CodecEncodeSelf(e)
+ if yyq3270[4] {
+ yy3284 := &x.Status
+ yy3284.CodecEncodeSelf(e)
} else {
r.EncodeNil()
}
} else {
- if yyq3265[4] {
+ if yyq3270[4] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("status"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy3280 := &x.Status
- yy3280.CodecEncodeSelf(e)
+ yy3285 := &x.Status
+ yy3285.CodecEncodeSelf(e)
}
}
- if yyr3265 || yy2arr3265 {
+ if yyr3270 || yy2arr3270 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -41948,25 +42012,25 @@ func (x *Node) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym3281 := z.DecBinary()
- _ = yym3281
+ yym3286 := z.DecBinary()
+ _ = yym3286
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct3282 := r.ContainerType()
- if yyct3282 == codecSelferValueTypeMap1234 {
- yyl3282 := r.ReadMapStart()
- if yyl3282 == 0 {
+ yyct3287 := r.ContainerType()
+ if yyct3287 == codecSelferValueTypeMap1234 {
+ yyl3287 := r.ReadMapStart()
+ if yyl3287 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl3282, d)
+ x.codecDecodeSelfFromMap(yyl3287, d)
}
- } else if yyct3282 == codecSelferValueTypeArray1234 {
- yyl3282 := r.ReadArrayStart()
- if yyl3282 == 0 {
+ } else if yyct3287 == codecSelferValueTypeArray1234 {
+ yyl3287 := r.ReadArrayStart()
+ if yyl3287 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl3282, d)
+ x.codecDecodeSelfFromArray(yyl3287, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -41978,12 +42042,12 @@ func (x *Node) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys3283Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys3283Slc
- var yyhl3283 bool = l >= 0
- for yyj3283 := 0; ; yyj3283++ {
- if yyhl3283 {
- if yyj3283 >= l {
+ var yys3288Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3288Slc
+ var yyhl3288 bool = l >= 0
+ for yyj3288 := 0; ; yyj3288++ {
+ if yyhl3288 {
+ if yyj3288 >= l {
break
}
} else {
@@ -41992,10 +42056,10 @@ func (x *Node) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys3283Slc = r.DecodeBytes(yys3283Slc, true, true)
- yys3283 := string(yys3283Slc)
+ yys3288Slc = r.DecodeBytes(yys3288Slc, true, true)
+ yys3288 := string(yys3288Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys3283 {
+ switch yys3288 {
case "kind":
if r.TryDecodeAsNil() {
x.Kind = ""
@@ -42012,27 +42076,27 @@ func (x *Node) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.ObjectMeta = ObjectMeta{}
} else {
- yyv3286 := &x.ObjectMeta
- yyv3286.CodecDecodeSelf(d)
+ yyv3291 := &x.ObjectMeta
+ yyv3291.CodecDecodeSelf(d)
}
case "spec":
if r.TryDecodeAsNil() {
x.Spec = NodeSpec{}
} else {
- yyv3287 := &x.Spec
- yyv3287.CodecDecodeSelf(d)
+ yyv3292 := &x.Spec
+ yyv3292.CodecDecodeSelf(d)
}
case "status":
if r.TryDecodeAsNil() {
x.Status = NodeStatus{}
} else {
- yyv3288 := &x.Status
- yyv3288.CodecDecodeSelf(d)
+ yyv3293 := &x.Status
+ yyv3293.CodecDecodeSelf(d)
}
default:
- z.DecStructFieldNotFound(-1, yys3283)
- } // end switch yys3283
- } // end for yyj3283
+ z.DecStructFieldNotFound(-1, yys3288)
+ } // end switch yys3288
+ } // end for yyj3288
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -42040,16 +42104,16 @@ func (x *Node) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj3289 int
- var yyb3289 bool
- var yyhl3289 bool = l >= 0
- yyj3289++
- if yyhl3289 {
- yyb3289 = yyj3289 > l
+ var yyj3294 int
+ var yyb3294 bool
+ var yyhl3294 bool = l >= 0
+ yyj3294++
+ if yyhl3294 {
+ yyb3294 = yyj3294 > l
} else {
- yyb3289 = r.CheckBreak()
+ yyb3294 = r.CheckBreak()
}
- if yyb3289 {
+ if yyb3294 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -42059,13 +42123,13 @@ func (x *Node) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Kind = string(r.DecodeString())
}
- yyj3289++
- if yyhl3289 {
- yyb3289 = yyj3289 > l
+ yyj3294++
+ if yyhl3294 {
+ yyb3294 = yyj3294 > l
} else {
- yyb3289 = r.CheckBreak()
+ yyb3294 = r.CheckBreak()
}
- if yyb3289 {
+ if yyb3294 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -42075,13 +42139,13 @@ func (x *Node) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.APIVersion = string(r.DecodeString())
}
- yyj3289++
- if yyhl3289 {
- yyb3289 = yyj3289 > l
+ yyj3294++
+ if yyhl3294 {
+ yyb3294 = yyj3294 > l
} else {
- yyb3289 = r.CheckBreak()
+ yyb3294 = r.CheckBreak()
}
- if yyb3289 {
+ if yyb3294 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -42089,16 +42153,16 @@ func (x *Node) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.ObjectMeta = ObjectMeta{}
} else {
- yyv3292 := &x.ObjectMeta
- yyv3292.CodecDecodeSelf(d)
+ yyv3297 := &x.ObjectMeta
+ yyv3297.CodecDecodeSelf(d)
}
- yyj3289++
- if yyhl3289 {
- yyb3289 = yyj3289 > l
+ yyj3294++
+ if yyhl3294 {
+ yyb3294 = yyj3294 > l
} else {
- yyb3289 = r.CheckBreak()
+ yyb3294 = r.CheckBreak()
}
- if yyb3289 {
+ if yyb3294 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -42106,16 +42170,16 @@ func (x *Node) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Spec = NodeSpec{}
} else {
- yyv3293 := &x.Spec
- yyv3293.CodecDecodeSelf(d)
+ yyv3298 := &x.Spec
+ yyv3298.CodecDecodeSelf(d)
}
- yyj3289++
- if yyhl3289 {
- yyb3289 = yyj3289 > l
+ yyj3294++
+ if yyhl3294 {
+ yyb3294 = yyj3294 > l
} else {
- yyb3289 = r.CheckBreak()
+ yyb3294 = r.CheckBreak()
}
- if yyb3289 {
+ if yyb3294 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -42123,21 +42187,21 @@ func (x *Node) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Status = NodeStatus{}
} else {
- yyv3294 := &x.Status
- yyv3294.CodecDecodeSelf(d)
+ yyv3299 := &x.Status
+ yyv3299.CodecDecodeSelf(d)
}
for {
- yyj3289++
- if yyhl3289 {
- yyb3289 = yyj3289 > l
+ yyj3294++
+ if yyhl3294 {
+ yyb3294 = yyj3294 > l
} else {
- yyb3289 = r.CheckBreak()
+ yyb3294 = r.CheckBreak()
}
- if yyb3289 {
+ if yyb3294 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj3289-1, "")
+ z.DecStructFieldNotFound(yyj3294-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -42149,37 +42213,37 @@ func (x *NodeList) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym3295 := z.EncBinary()
- _ = yym3295
+ yym3300 := z.EncBinary()
+ _ = yym3300
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep3296 := !z.EncBinary()
- yy2arr3296 := z.EncBasicHandle().StructToArray
- var yyq3296 [4]bool
- _, _, _ = yysep3296, yyq3296, yy2arr3296
- const yyr3296 bool = false
- yyq3296[0] = x.Kind != ""
- yyq3296[1] = x.APIVersion != ""
- yyq3296[2] = true
- var yynn3296 int
- if yyr3296 || yy2arr3296 {
+ yysep3301 := !z.EncBinary()
+ yy2arr3301 := z.EncBasicHandle().StructToArray
+ var yyq3301 [4]bool
+ _, _, _ = yysep3301, yyq3301, yy2arr3301
+ const yyr3301 bool = false
+ yyq3301[0] = x.Kind != ""
+ yyq3301[1] = x.APIVersion != ""
+ yyq3301[2] = true
+ var yynn3301 int
+ if yyr3301 || yy2arr3301 {
r.EncodeArrayStart(4)
} else {
- yynn3296 = 1
- for _, b := range yyq3296 {
+ yynn3301 = 1
+ for _, b := range yyq3301 {
if b {
- yynn3296++
+ yynn3301++
}
}
- r.EncodeMapStart(yynn3296)
- yynn3296 = 0
+ r.EncodeMapStart(yynn3301)
+ yynn3301 = 0
}
- if yyr3296 || yy2arr3296 {
+ if yyr3301 || yy2arr3301 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3296[0] {
- yym3298 := z.EncBinary()
- _ = yym3298
+ if yyq3301[0] {
+ yym3303 := z.EncBinary()
+ _ = yym3303
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
@@ -42188,23 +42252,23 @@ func (x *NodeList) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq3296[0] {
+ if yyq3301[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("kind"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3299 := z.EncBinary()
- _ = yym3299
+ yym3304 := z.EncBinary()
+ _ = yym3304
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
}
}
}
- if yyr3296 || yy2arr3296 {
+ if yyr3301 || yy2arr3301 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3296[1] {
- yym3301 := z.EncBinary()
- _ = yym3301
+ if yyq3301[1] {
+ yym3306 := z.EncBinary()
+ _ = yym3306
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
@@ -42213,54 +42277,54 @@ func (x *NodeList) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq3296[1] {
+ if yyq3301[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3302 := z.EncBinary()
- _ = yym3302
+ yym3307 := z.EncBinary()
+ _ = yym3307
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
}
}
}
- if yyr3296 || yy2arr3296 {
+ if yyr3301 || yy2arr3301 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3296[2] {
- yy3304 := &x.ListMeta
- yym3305 := z.EncBinary()
- _ = yym3305
+ if yyq3301[2] {
+ yy3309 := &x.ListMeta
+ yym3310 := z.EncBinary()
+ _ = yym3310
if false {
- } else if z.HasExtensions() && z.EncExt(yy3304) {
+ } else if z.HasExtensions() && z.EncExt(yy3309) {
} else {
- z.EncFallback(yy3304)
+ z.EncFallback(yy3309)
}
} else {
r.EncodeNil()
}
} else {
- if yyq3296[2] {
+ if yyq3301[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("metadata"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy3306 := &x.ListMeta
- yym3307 := z.EncBinary()
- _ = yym3307
+ yy3311 := &x.ListMeta
+ yym3312 := z.EncBinary()
+ _ = yym3312
if false {
- } else if z.HasExtensions() && z.EncExt(yy3306) {
+ } else if z.HasExtensions() && z.EncExt(yy3311) {
} else {
- z.EncFallback(yy3306)
+ z.EncFallback(yy3311)
}
}
}
- if yyr3296 || yy2arr3296 {
+ if yyr3301 || yy2arr3301 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if x.Items == nil {
r.EncodeNil()
} else {
- yym3309 := z.EncBinary()
- _ = yym3309
+ yym3314 := z.EncBinary()
+ _ = yym3314
if false {
} else {
h.encSliceNode(([]Node)(x.Items), e)
@@ -42273,15 +42337,15 @@ func (x *NodeList) CodecEncodeSelf(e *codec1978.Encoder) {
if x.Items == nil {
r.EncodeNil()
} else {
- yym3310 := z.EncBinary()
- _ = yym3310
+ yym3315 := z.EncBinary()
+ _ = yym3315
if false {
} else {
h.encSliceNode(([]Node)(x.Items), e)
}
}
}
- if yyr3296 || yy2arr3296 {
+ if yyr3301 || yy2arr3301 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -42294,25 +42358,25 @@ func (x *NodeList) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym3311 := z.DecBinary()
- _ = yym3311
+ yym3316 := z.DecBinary()
+ _ = yym3316
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct3312 := r.ContainerType()
- if yyct3312 == codecSelferValueTypeMap1234 {
- yyl3312 := r.ReadMapStart()
- if yyl3312 == 0 {
+ yyct3317 := r.ContainerType()
+ if yyct3317 == codecSelferValueTypeMap1234 {
+ yyl3317 := r.ReadMapStart()
+ if yyl3317 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl3312, d)
+ x.codecDecodeSelfFromMap(yyl3317, d)
}
- } else if yyct3312 == codecSelferValueTypeArray1234 {
- yyl3312 := r.ReadArrayStart()
- if yyl3312 == 0 {
+ } else if yyct3317 == codecSelferValueTypeArray1234 {
+ yyl3317 := r.ReadArrayStart()
+ if yyl3317 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl3312, d)
+ x.codecDecodeSelfFromArray(yyl3317, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -42324,12 +42388,12 @@ func (x *NodeList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys3313Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys3313Slc
- var yyhl3313 bool = l >= 0
- for yyj3313 := 0; ; yyj3313++ {
- if yyhl3313 {
- if yyj3313 >= l {
+ var yys3318Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3318Slc
+ var yyhl3318 bool = l >= 0
+ for yyj3318 := 0; ; yyj3318++ {
+ if yyhl3318 {
+ if yyj3318 >= l {
break
}
} else {
@@ -42338,10 +42402,10 @@ func (x *NodeList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys3313Slc = r.DecodeBytes(yys3313Slc, true, true)
- yys3313 := string(yys3313Slc)
+ yys3318Slc = r.DecodeBytes(yys3318Slc, true, true)
+ yys3318 := string(yys3318Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys3313 {
+ switch yys3318 {
case "kind":
if r.TryDecodeAsNil() {
x.Kind = ""
@@ -42358,31 +42422,31 @@ func (x *NodeList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.ListMeta = pkg2_v1.ListMeta{}
} else {
- yyv3316 := &x.ListMeta
- yym3317 := z.DecBinary()
- _ = yym3317
+ yyv3321 := &x.ListMeta
+ yym3322 := z.DecBinary()
+ _ = yym3322
if false {
- } else if z.HasExtensions() && z.DecExt(yyv3316) {
+ } else if z.HasExtensions() && z.DecExt(yyv3321) {
} else {
- z.DecFallback(yyv3316, false)
+ z.DecFallback(yyv3321, false)
}
}
case "items":
if r.TryDecodeAsNil() {
x.Items = nil
} else {
- yyv3318 := &x.Items
- yym3319 := z.DecBinary()
- _ = yym3319
+ yyv3323 := &x.Items
+ yym3324 := z.DecBinary()
+ _ = yym3324
if false {
} else {
- h.decSliceNode((*[]Node)(yyv3318), d)
+ h.decSliceNode((*[]Node)(yyv3323), d)
}
}
default:
- z.DecStructFieldNotFound(-1, yys3313)
- } // end switch yys3313
- } // end for yyj3313
+ z.DecStructFieldNotFound(-1, yys3318)
+ } // end switch yys3318
+ } // end for yyj3318
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -42390,16 +42454,16 @@ func (x *NodeList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj3320 int
- var yyb3320 bool
- var yyhl3320 bool = l >= 0
- yyj3320++
- if yyhl3320 {
- yyb3320 = yyj3320 > l
+ var yyj3325 int
+ var yyb3325 bool
+ var yyhl3325 bool = l >= 0
+ yyj3325++
+ if yyhl3325 {
+ yyb3325 = yyj3325 > l
} else {
- yyb3320 = r.CheckBreak()
+ yyb3325 = r.CheckBreak()
}
- if yyb3320 {
+ if yyb3325 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -42409,13 +42473,13 @@ func (x *NodeList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Kind = string(r.DecodeString())
}
- yyj3320++
- if yyhl3320 {
- yyb3320 = yyj3320 > l
+ yyj3325++
+ if yyhl3325 {
+ yyb3325 = yyj3325 > l
} else {
- yyb3320 = r.CheckBreak()
+ yyb3325 = r.CheckBreak()
}
- if yyb3320 {
+ if yyb3325 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -42425,13 +42489,13 @@ func (x *NodeList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.APIVersion = string(r.DecodeString())
}
- yyj3320++
- if yyhl3320 {
- yyb3320 = yyj3320 > l
+ yyj3325++
+ if yyhl3325 {
+ yyb3325 = yyj3325 > l
} else {
- yyb3320 = r.CheckBreak()
+ yyb3325 = r.CheckBreak()
}
- if yyb3320 {
+ if yyb3325 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -42439,22 +42503,22 @@ func (x *NodeList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.ListMeta = pkg2_v1.ListMeta{}
} else {
- yyv3323 := &x.ListMeta
- yym3324 := z.DecBinary()
- _ = yym3324
+ yyv3328 := &x.ListMeta
+ yym3329 := z.DecBinary()
+ _ = yym3329
if false {
- } else if z.HasExtensions() && z.DecExt(yyv3323) {
+ } else if z.HasExtensions() && z.DecExt(yyv3328) {
} else {
- z.DecFallback(yyv3323, false)
+ z.DecFallback(yyv3328, false)
}
}
- yyj3320++
- if yyhl3320 {
- yyb3320 = yyj3320 > l
+ yyj3325++
+ if yyhl3325 {
+ yyb3325 = yyj3325 > l
} else {
- yyb3320 = r.CheckBreak()
+ yyb3325 = r.CheckBreak()
}
- if yyb3320 {
+ if yyb3325 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -42462,26 +42526,26 @@ func (x *NodeList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Items = nil
} else {
- yyv3325 := &x.Items
- yym3326 := z.DecBinary()
- _ = yym3326
+ yyv3330 := &x.Items
+ yym3331 := z.DecBinary()
+ _ = yym3331
if false {
} else {
- h.decSliceNode((*[]Node)(yyv3325), d)
+ h.decSliceNode((*[]Node)(yyv3330), d)
}
}
for {
- yyj3320++
- if yyhl3320 {
- yyb3320 = yyj3320 > l
+ yyj3325++
+ if yyhl3325 {
+ yyb3325 = yyj3325 > l
} else {
- yyb3320 = r.CheckBreak()
+ yyb3325 = r.CheckBreak()
}
- if yyb3320 {
+ if yyb3325 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj3320-1, "")
+ z.DecStructFieldNotFound(yyj3325-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -42490,8 +42554,8 @@ func (x FinalizerName) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
- yym3327 := z.EncBinary()
- _ = yym3327
+ yym3332 := z.EncBinary()
+ _ = yym3332
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
@@ -42503,8 +42567,8 @@ func (x *FinalizerName) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym3328 := z.DecBinary()
- _ = yym3328
+ yym3333 := z.DecBinary()
+ _ = yym3333
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
@@ -42519,38 +42583,38 @@ func (x *NamespaceSpec) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym3329 := z.EncBinary()
- _ = yym3329
+ yym3334 := z.EncBinary()
+ _ = yym3334
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep3330 := !z.EncBinary()
- yy2arr3330 := z.EncBasicHandle().StructToArray
- var yyq3330 [1]bool
- _, _, _ = yysep3330, yyq3330, yy2arr3330
- const yyr3330 bool = false
- yyq3330[0] = len(x.Finalizers) != 0
- var yynn3330 int
- if yyr3330 || yy2arr3330 {
+ yysep3335 := !z.EncBinary()
+ yy2arr3335 := z.EncBasicHandle().StructToArray
+ var yyq3335 [1]bool
+ _, _, _ = yysep3335, yyq3335, yy2arr3335
+ const yyr3335 bool = false
+ yyq3335[0] = len(x.Finalizers) != 0
+ var yynn3335 int
+ if yyr3335 || yy2arr3335 {
r.EncodeArrayStart(1)
} else {
- yynn3330 = 0
- for _, b := range yyq3330 {
+ yynn3335 = 0
+ for _, b := range yyq3335 {
if b {
- yynn3330++
+ yynn3335++
}
}
- r.EncodeMapStart(yynn3330)
- yynn3330 = 0
+ r.EncodeMapStart(yynn3335)
+ yynn3335 = 0
}
- if yyr3330 || yy2arr3330 {
+ if yyr3335 || yy2arr3335 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3330[0] {
+ if yyq3335[0] {
if x.Finalizers == nil {
r.EncodeNil()
} else {
- yym3332 := z.EncBinary()
- _ = yym3332
+ yym3337 := z.EncBinary()
+ _ = yym3337
if false {
} else {
h.encSliceFinalizerName(([]FinalizerName)(x.Finalizers), e)
@@ -42560,15 +42624,15 @@ func (x *NamespaceSpec) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeNil()
}
} else {
- if yyq3330[0] {
+ if yyq3335[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("finalizers"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
if x.Finalizers == nil {
r.EncodeNil()
} else {
- yym3333 := z.EncBinary()
- _ = yym3333
+ yym3338 := z.EncBinary()
+ _ = yym3338
if false {
} else {
h.encSliceFinalizerName(([]FinalizerName)(x.Finalizers), e)
@@ -42576,7 +42640,7 @@ func (x *NamespaceSpec) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
- if yyr3330 || yy2arr3330 {
+ if yyr3335 || yy2arr3335 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -42589,25 +42653,25 @@ func (x *NamespaceSpec) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym3334 := z.DecBinary()
- _ = yym3334
+ yym3339 := z.DecBinary()
+ _ = yym3339
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct3335 := r.ContainerType()
- if yyct3335 == codecSelferValueTypeMap1234 {
- yyl3335 := r.ReadMapStart()
- if yyl3335 == 0 {
+ yyct3340 := r.ContainerType()
+ if yyct3340 == codecSelferValueTypeMap1234 {
+ yyl3340 := r.ReadMapStart()
+ if yyl3340 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl3335, d)
+ x.codecDecodeSelfFromMap(yyl3340, d)
}
- } else if yyct3335 == codecSelferValueTypeArray1234 {
- yyl3335 := r.ReadArrayStart()
- if yyl3335 == 0 {
+ } else if yyct3340 == codecSelferValueTypeArray1234 {
+ yyl3340 := r.ReadArrayStart()
+ if yyl3340 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl3335, d)
+ x.codecDecodeSelfFromArray(yyl3340, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -42619,12 +42683,12 @@ func (x *NamespaceSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys3336Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys3336Slc
- var yyhl3336 bool = l >= 0
- for yyj3336 := 0; ; yyj3336++ {
- if yyhl3336 {
- if yyj3336 >= l {
+ var yys3341Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3341Slc
+ var yyhl3341 bool = l >= 0
+ for yyj3341 := 0; ; yyj3341++ {
+ if yyhl3341 {
+ if yyj3341 >= l {
break
}
} else {
@@ -42633,26 +42697,26 @@ func (x *NamespaceSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys3336Slc = r.DecodeBytes(yys3336Slc, true, true)
- yys3336 := string(yys3336Slc)
+ yys3341Slc = r.DecodeBytes(yys3341Slc, true, true)
+ yys3341 := string(yys3341Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys3336 {
+ switch yys3341 {
case "finalizers":
if r.TryDecodeAsNil() {
x.Finalizers = nil
} else {
- yyv3337 := &x.Finalizers
- yym3338 := z.DecBinary()
- _ = yym3338
+ yyv3342 := &x.Finalizers
+ yym3343 := z.DecBinary()
+ _ = yym3343
if false {
} else {
- h.decSliceFinalizerName((*[]FinalizerName)(yyv3337), d)
+ h.decSliceFinalizerName((*[]FinalizerName)(yyv3342), d)
}
}
default:
- z.DecStructFieldNotFound(-1, yys3336)
- } // end switch yys3336
- } // end for yyj3336
+ z.DecStructFieldNotFound(-1, yys3341)
+ } // end switch yys3341
+ } // end for yyj3341
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -42660,16 +42724,16 @@ func (x *NamespaceSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj3339 int
- var yyb3339 bool
- var yyhl3339 bool = l >= 0
- yyj3339++
- if yyhl3339 {
- yyb3339 = yyj3339 > l
+ var yyj3344 int
+ var yyb3344 bool
+ var yyhl3344 bool = l >= 0
+ yyj3344++
+ if yyhl3344 {
+ yyb3344 = yyj3344 > l
} else {
- yyb3339 = r.CheckBreak()
+ yyb3344 = r.CheckBreak()
}
- if yyb3339 {
+ if yyb3344 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -42677,26 +42741,26 @@ func (x *NamespaceSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Finalizers = nil
} else {
- yyv3340 := &x.Finalizers
- yym3341 := z.DecBinary()
- _ = yym3341
+ yyv3345 := &x.Finalizers
+ yym3346 := z.DecBinary()
+ _ = yym3346
if false {
} else {
- h.decSliceFinalizerName((*[]FinalizerName)(yyv3340), d)
+ h.decSliceFinalizerName((*[]FinalizerName)(yyv3345), d)
}
}
for {
- yyj3339++
- if yyhl3339 {
- yyb3339 = yyj3339 > l
+ yyj3344++
+ if yyhl3344 {
+ yyb3344 = yyj3344 > l
} else {
- yyb3339 = r.CheckBreak()
+ yyb3344 = r.CheckBreak()
}
- if yyb3339 {
+ if yyb3344 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj3339-1, "")
+ z.DecStructFieldNotFound(yyj3344-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -42708,46 +42772,46 @@ func (x *NamespaceStatus) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym3342 := z.EncBinary()
- _ = yym3342
+ yym3347 := z.EncBinary()
+ _ = yym3347
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep3343 := !z.EncBinary()
- yy2arr3343 := z.EncBasicHandle().StructToArray
- var yyq3343 [1]bool
- _, _, _ = yysep3343, yyq3343, yy2arr3343
- const yyr3343 bool = false
- yyq3343[0] = x.Phase != ""
- var yynn3343 int
- if yyr3343 || yy2arr3343 {
+ yysep3348 := !z.EncBinary()
+ yy2arr3348 := z.EncBasicHandle().StructToArray
+ var yyq3348 [1]bool
+ _, _, _ = yysep3348, yyq3348, yy2arr3348
+ const yyr3348 bool = false
+ yyq3348[0] = x.Phase != ""
+ var yynn3348 int
+ if yyr3348 || yy2arr3348 {
r.EncodeArrayStart(1)
} else {
- yynn3343 = 0
- for _, b := range yyq3343 {
+ yynn3348 = 0
+ for _, b := range yyq3348 {
if b {
- yynn3343++
+ yynn3348++
}
}
- r.EncodeMapStart(yynn3343)
- yynn3343 = 0
+ r.EncodeMapStart(yynn3348)
+ yynn3348 = 0
}
- if yyr3343 || yy2arr3343 {
+ if yyr3348 || yy2arr3348 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3343[0] {
+ if yyq3348[0] {
x.Phase.CodecEncodeSelf(e)
} else {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq3343[0] {
+ if yyq3348[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("phase"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
x.Phase.CodecEncodeSelf(e)
}
}
- if yyr3343 || yy2arr3343 {
+ if yyr3348 || yy2arr3348 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -42760,25 +42824,25 @@ func (x *NamespaceStatus) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym3345 := z.DecBinary()
- _ = yym3345
+ yym3350 := z.DecBinary()
+ _ = yym3350
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct3346 := r.ContainerType()
- if yyct3346 == codecSelferValueTypeMap1234 {
- yyl3346 := r.ReadMapStart()
- if yyl3346 == 0 {
+ yyct3351 := r.ContainerType()
+ if yyct3351 == codecSelferValueTypeMap1234 {
+ yyl3351 := r.ReadMapStart()
+ if yyl3351 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl3346, d)
+ x.codecDecodeSelfFromMap(yyl3351, d)
}
- } else if yyct3346 == codecSelferValueTypeArray1234 {
- yyl3346 := r.ReadArrayStart()
- if yyl3346 == 0 {
+ } else if yyct3351 == codecSelferValueTypeArray1234 {
+ yyl3351 := r.ReadArrayStart()
+ if yyl3351 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl3346, d)
+ x.codecDecodeSelfFromArray(yyl3351, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -42790,12 +42854,12 @@ func (x *NamespaceStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys3347Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys3347Slc
- var yyhl3347 bool = l >= 0
- for yyj3347 := 0; ; yyj3347++ {
- if yyhl3347 {
- if yyj3347 >= l {
+ var yys3352Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3352Slc
+ var yyhl3352 bool = l >= 0
+ for yyj3352 := 0; ; yyj3352++ {
+ if yyhl3352 {
+ if yyj3352 >= l {
break
}
} else {
@@ -42804,10 +42868,10 @@ func (x *NamespaceStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys3347Slc = r.DecodeBytes(yys3347Slc, true, true)
- yys3347 := string(yys3347Slc)
+ yys3352Slc = r.DecodeBytes(yys3352Slc, true, true)
+ yys3352 := string(yys3352Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys3347 {
+ switch yys3352 {
case "phase":
if r.TryDecodeAsNil() {
x.Phase = ""
@@ -42815,9 +42879,9 @@ func (x *NamespaceStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
x.Phase = NamespacePhase(r.DecodeString())
}
default:
- z.DecStructFieldNotFound(-1, yys3347)
- } // end switch yys3347
- } // end for yyj3347
+ z.DecStructFieldNotFound(-1, yys3352)
+ } // end switch yys3352
+ } // end for yyj3352
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -42825,16 +42889,16 @@ func (x *NamespaceStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj3349 int
- var yyb3349 bool
- var yyhl3349 bool = l >= 0
- yyj3349++
- if yyhl3349 {
- yyb3349 = yyj3349 > l
+ var yyj3354 int
+ var yyb3354 bool
+ var yyhl3354 bool = l >= 0
+ yyj3354++
+ if yyhl3354 {
+ yyb3354 = yyj3354 > l
} else {
- yyb3349 = r.CheckBreak()
+ yyb3354 = r.CheckBreak()
}
- if yyb3349 {
+ if yyb3354 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -42845,17 +42909,17 @@ func (x *NamespaceStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
x.Phase = NamespacePhase(r.DecodeString())
}
for {
- yyj3349++
- if yyhl3349 {
- yyb3349 = yyj3349 > l
+ yyj3354++
+ if yyhl3354 {
+ yyb3354 = yyj3354 > l
} else {
- yyb3349 = r.CheckBreak()
+ yyb3354 = r.CheckBreak()
}
- if yyb3349 {
+ if yyb3354 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj3349-1, "")
+ z.DecStructFieldNotFound(yyj3354-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -42864,8 +42928,8 @@ func (x NamespacePhase) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
- yym3351 := z.EncBinary()
- _ = yym3351
+ yym3356 := z.EncBinary()
+ _ = yym3356
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
@@ -42877,8 +42941,8 @@ func (x *NamespacePhase) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym3352 := z.DecBinary()
- _ = yym3352
+ yym3357 := z.DecBinary()
+ _ = yym3357
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
@@ -42893,39 +42957,39 @@ func (x *Namespace) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym3353 := z.EncBinary()
- _ = yym3353
+ yym3358 := z.EncBinary()
+ _ = yym3358
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep3354 := !z.EncBinary()
- yy2arr3354 := z.EncBasicHandle().StructToArray
- var yyq3354 [5]bool
- _, _, _ = yysep3354, yyq3354, yy2arr3354
- const yyr3354 bool = false
- yyq3354[0] = x.Kind != ""
- yyq3354[1] = x.APIVersion != ""
- yyq3354[2] = true
- yyq3354[3] = true
- yyq3354[4] = true
- var yynn3354 int
- if yyr3354 || yy2arr3354 {
+ yysep3359 := !z.EncBinary()
+ yy2arr3359 := z.EncBasicHandle().StructToArray
+ var yyq3359 [5]bool
+ _, _, _ = yysep3359, yyq3359, yy2arr3359
+ const yyr3359 bool = false
+ yyq3359[0] = x.Kind != ""
+ yyq3359[1] = x.APIVersion != ""
+ yyq3359[2] = true
+ yyq3359[3] = true
+ yyq3359[4] = true
+ var yynn3359 int
+ if yyr3359 || yy2arr3359 {
r.EncodeArrayStart(5)
} else {
- yynn3354 = 0
- for _, b := range yyq3354 {
+ yynn3359 = 0
+ for _, b := range yyq3359 {
if b {
- yynn3354++
+ yynn3359++
}
}
- r.EncodeMapStart(yynn3354)
- yynn3354 = 0
+ r.EncodeMapStart(yynn3359)
+ yynn3359 = 0
}
- if yyr3354 || yy2arr3354 {
+ if yyr3359 || yy2arr3359 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3354[0] {
- yym3356 := z.EncBinary()
- _ = yym3356
+ if yyq3359[0] {
+ yym3361 := z.EncBinary()
+ _ = yym3361
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
@@ -42934,23 +42998,23 @@ func (x *Namespace) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq3354[0] {
+ if yyq3359[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("kind"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3357 := z.EncBinary()
- _ = yym3357
+ yym3362 := z.EncBinary()
+ _ = yym3362
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
}
}
}
- if yyr3354 || yy2arr3354 {
+ if yyr3359 || yy2arr3359 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3354[1] {
- yym3359 := z.EncBinary()
- _ = yym3359
+ if yyq3359[1] {
+ yym3364 := z.EncBinary()
+ _ = yym3364
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
@@ -42959,70 +43023,70 @@ func (x *Namespace) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq3354[1] {
+ if yyq3359[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3360 := z.EncBinary()
- _ = yym3360
+ yym3365 := z.EncBinary()
+ _ = yym3365
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
}
}
}
- if yyr3354 || yy2arr3354 {
+ if yyr3359 || yy2arr3359 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3354[2] {
- yy3362 := &x.ObjectMeta
- yy3362.CodecEncodeSelf(e)
+ if yyq3359[2] {
+ yy3367 := &x.ObjectMeta
+ yy3367.CodecEncodeSelf(e)
} else {
r.EncodeNil()
}
} else {
- if yyq3354[2] {
+ if yyq3359[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("metadata"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy3363 := &x.ObjectMeta
- yy3363.CodecEncodeSelf(e)
+ yy3368 := &x.ObjectMeta
+ yy3368.CodecEncodeSelf(e)
}
}
- if yyr3354 || yy2arr3354 {
+ if yyr3359 || yy2arr3359 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3354[3] {
- yy3365 := &x.Spec
- yy3365.CodecEncodeSelf(e)
+ if yyq3359[3] {
+ yy3370 := &x.Spec
+ yy3370.CodecEncodeSelf(e)
} else {
r.EncodeNil()
}
} else {
- if yyq3354[3] {
+ if yyq3359[3] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("spec"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy3366 := &x.Spec
- yy3366.CodecEncodeSelf(e)
+ yy3371 := &x.Spec
+ yy3371.CodecEncodeSelf(e)
}
}
- if yyr3354 || yy2arr3354 {
+ if yyr3359 || yy2arr3359 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3354[4] {
- yy3368 := &x.Status
- yy3368.CodecEncodeSelf(e)
+ if yyq3359[4] {
+ yy3373 := &x.Status
+ yy3373.CodecEncodeSelf(e)
} else {
r.EncodeNil()
}
} else {
- if yyq3354[4] {
+ if yyq3359[4] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("status"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy3369 := &x.Status
- yy3369.CodecEncodeSelf(e)
+ yy3374 := &x.Status
+ yy3374.CodecEncodeSelf(e)
}
}
- if yyr3354 || yy2arr3354 {
+ if yyr3359 || yy2arr3359 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -43035,25 +43099,25 @@ func (x *Namespace) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym3370 := z.DecBinary()
- _ = yym3370
+ yym3375 := z.DecBinary()
+ _ = yym3375
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct3371 := r.ContainerType()
- if yyct3371 == codecSelferValueTypeMap1234 {
- yyl3371 := r.ReadMapStart()
- if yyl3371 == 0 {
+ yyct3376 := r.ContainerType()
+ if yyct3376 == codecSelferValueTypeMap1234 {
+ yyl3376 := r.ReadMapStart()
+ if yyl3376 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl3371, d)
+ x.codecDecodeSelfFromMap(yyl3376, d)
}
- } else if yyct3371 == codecSelferValueTypeArray1234 {
- yyl3371 := r.ReadArrayStart()
- if yyl3371 == 0 {
+ } else if yyct3376 == codecSelferValueTypeArray1234 {
+ yyl3376 := r.ReadArrayStart()
+ if yyl3376 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl3371, d)
+ x.codecDecodeSelfFromArray(yyl3376, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -43065,12 +43129,12 @@ func (x *Namespace) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys3372Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys3372Slc
- var yyhl3372 bool = l >= 0
- for yyj3372 := 0; ; yyj3372++ {
- if yyhl3372 {
- if yyj3372 >= l {
+ var yys3377Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3377Slc
+ var yyhl3377 bool = l >= 0
+ for yyj3377 := 0; ; yyj3377++ {
+ if yyhl3377 {
+ if yyj3377 >= l {
break
}
} else {
@@ -43079,10 +43143,10 @@ func (x *Namespace) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys3372Slc = r.DecodeBytes(yys3372Slc, true, true)
- yys3372 := string(yys3372Slc)
+ yys3377Slc = r.DecodeBytes(yys3377Slc, true, true)
+ yys3377 := string(yys3377Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys3372 {
+ switch yys3377 {
case "kind":
if r.TryDecodeAsNil() {
x.Kind = ""
@@ -43099,27 +43163,27 @@ func (x *Namespace) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.ObjectMeta = ObjectMeta{}
} else {
- yyv3375 := &x.ObjectMeta
- yyv3375.CodecDecodeSelf(d)
+ yyv3380 := &x.ObjectMeta
+ yyv3380.CodecDecodeSelf(d)
}
case "spec":
if r.TryDecodeAsNil() {
x.Spec = NamespaceSpec{}
} else {
- yyv3376 := &x.Spec
- yyv3376.CodecDecodeSelf(d)
+ yyv3381 := &x.Spec
+ yyv3381.CodecDecodeSelf(d)
}
case "status":
if r.TryDecodeAsNil() {
x.Status = NamespaceStatus{}
} else {
- yyv3377 := &x.Status
- yyv3377.CodecDecodeSelf(d)
+ yyv3382 := &x.Status
+ yyv3382.CodecDecodeSelf(d)
}
default:
- z.DecStructFieldNotFound(-1, yys3372)
- } // end switch yys3372
- } // end for yyj3372
+ z.DecStructFieldNotFound(-1, yys3377)
+ } // end switch yys3377
+ } // end for yyj3377
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -43127,16 +43191,16 @@ func (x *Namespace) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj3378 int
- var yyb3378 bool
- var yyhl3378 bool = l >= 0
- yyj3378++
- if yyhl3378 {
- yyb3378 = yyj3378 > l
+ var yyj3383 int
+ var yyb3383 bool
+ var yyhl3383 bool = l >= 0
+ yyj3383++
+ if yyhl3383 {
+ yyb3383 = yyj3383 > l
} else {
- yyb3378 = r.CheckBreak()
+ yyb3383 = r.CheckBreak()
}
- if yyb3378 {
+ if yyb3383 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -43146,13 +43210,13 @@ func (x *Namespace) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Kind = string(r.DecodeString())
}
- yyj3378++
- if yyhl3378 {
- yyb3378 = yyj3378 > l
+ yyj3383++
+ if yyhl3383 {
+ yyb3383 = yyj3383 > l
} else {
- yyb3378 = r.CheckBreak()
+ yyb3383 = r.CheckBreak()
}
- if yyb3378 {
+ if yyb3383 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -43162,13 +43226,13 @@ func (x *Namespace) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.APIVersion = string(r.DecodeString())
}
- yyj3378++
- if yyhl3378 {
- yyb3378 = yyj3378 > l
+ yyj3383++
+ if yyhl3383 {
+ yyb3383 = yyj3383 > l
} else {
- yyb3378 = r.CheckBreak()
+ yyb3383 = r.CheckBreak()
}
- if yyb3378 {
+ if yyb3383 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -43176,16 +43240,16 @@ func (x *Namespace) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.ObjectMeta = ObjectMeta{}
} else {
- yyv3381 := &x.ObjectMeta
- yyv3381.CodecDecodeSelf(d)
+ yyv3386 := &x.ObjectMeta
+ yyv3386.CodecDecodeSelf(d)
}
- yyj3378++
- if yyhl3378 {
- yyb3378 = yyj3378 > l
+ yyj3383++
+ if yyhl3383 {
+ yyb3383 = yyj3383 > l
} else {
- yyb3378 = r.CheckBreak()
+ yyb3383 = r.CheckBreak()
}
- if yyb3378 {
+ if yyb3383 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -43193,16 +43257,16 @@ func (x *Namespace) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Spec = NamespaceSpec{}
} else {
- yyv3382 := &x.Spec
- yyv3382.CodecDecodeSelf(d)
+ yyv3387 := &x.Spec
+ yyv3387.CodecDecodeSelf(d)
}
- yyj3378++
- if yyhl3378 {
- yyb3378 = yyj3378 > l
+ yyj3383++
+ if yyhl3383 {
+ yyb3383 = yyj3383 > l
} else {
- yyb3378 = r.CheckBreak()
+ yyb3383 = r.CheckBreak()
}
- if yyb3378 {
+ if yyb3383 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -43210,21 +43274,21 @@ func (x *Namespace) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Status = NamespaceStatus{}
} else {
- yyv3383 := &x.Status
- yyv3383.CodecDecodeSelf(d)
+ yyv3388 := &x.Status
+ yyv3388.CodecDecodeSelf(d)
}
for {
- yyj3378++
- if yyhl3378 {
- yyb3378 = yyj3378 > l
+ yyj3383++
+ if yyhl3383 {
+ yyb3383 = yyj3383 > l
} else {
- yyb3378 = r.CheckBreak()
+ yyb3383 = r.CheckBreak()
}
- if yyb3378 {
+ if yyb3383 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj3378-1, "")
+ z.DecStructFieldNotFound(yyj3383-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -43236,37 +43300,37 @@ func (x *NamespaceList) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym3384 := z.EncBinary()
- _ = yym3384
+ yym3389 := z.EncBinary()
+ _ = yym3389
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep3385 := !z.EncBinary()
- yy2arr3385 := z.EncBasicHandle().StructToArray
- var yyq3385 [4]bool
- _, _, _ = yysep3385, yyq3385, yy2arr3385
- const yyr3385 bool = false
- yyq3385[0] = x.Kind != ""
- yyq3385[1] = x.APIVersion != ""
- yyq3385[2] = true
- var yynn3385 int
- if yyr3385 || yy2arr3385 {
+ yysep3390 := !z.EncBinary()
+ yy2arr3390 := z.EncBasicHandle().StructToArray
+ var yyq3390 [4]bool
+ _, _, _ = yysep3390, yyq3390, yy2arr3390
+ const yyr3390 bool = false
+ yyq3390[0] = x.Kind != ""
+ yyq3390[1] = x.APIVersion != ""
+ yyq3390[2] = true
+ var yynn3390 int
+ if yyr3390 || yy2arr3390 {
r.EncodeArrayStart(4)
} else {
- yynn3385 = 1
- for _, b := range yyq3385 {
+ yynn3390 = 1
+ for _, b := range yyq3390 {
if b {
- yynn3385++
+ yynn3390++
}
}
- r.EncodeMapStart(yynn3385)
- yynn3385 = 0
+ r.EncodeMapStart(yynn3390)
+ yynn3390 = 0
}
- if yyr3385 || yy2arr3385 {
+ if yyr3390 || yy2arr3390 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3385[0] {
- yym3387 := z.EncBinary()
- _ = yym3387
+ if yyq3390[0] {
+ yym3392 := z.EncBinary()
+ _ = yym3392
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
@@ -43275,23 +43339,23 @@ func (x *NamespaceList) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq3385[0] {
+ if yyq3390[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("kind"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3388 := z.EncBinary()
- _ = yym3388
+ yym3393 := z.EncBinary()
+ _ = yym3393
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
}
}
}
- if yyr3385 || yy2arr3385 {
+ if yyr3390 || yy2arr3390 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3385[1] {
- yym3390 := z.EncBinary()
- _ = yym3390
+ if yyq3390[1] {
+ yym3395 := z.EncBinary()
+ _ = yym3395
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
@@ -43300,54 +43364,54 @@ func (x *NamespaceList) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq3385[1] {
+ if yyq3390[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3391 := z.EncBinary()
- _ = yym3391
+ yym3396 := z.EncBinary()
+ _ = yym3396
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
}
}
}
- if yyr3385 || yy2arr3385 {
+ if yyr3390 || yy2arr3390 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3385[2] {
- yy3393 := &x.ListMeta
- yym3394 := z.EncBinary()
- _ = yym3394
+ if yyq3390[2] {
+ yy3398 := &x.ListMeta
+ yym3399 := z.EncBinary()
+ _ = yym3399
if false {
- } else if z.HasExtensions() && z.EncExt(yy3393) {
+ } else if z.HasExtensions() && z.EncExt(yy3398) {
} else {
- z.EncFallback(yy3393)
+ z.EncFallback(yy3398)
}
} else {
r.EncodeNil()
}
} else {
- if yyq3385[2] {
+ if yyq3390[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("metadata"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy3395 := &x.ListMeta
- yym3396 := z.EncBinary()
- _ = yym3396
+ yy3400 := &x.ListMeta
+ yym3401 := z.EncBinary()
+ _ = yym3401
if false {
- } else if z.HasExtensions() && z.EncExt(yy3395) {
+ } else if z.HasExtensions() && z.EncExt(yy3400) {
} else {
- z.EncFallback(yy3395)
+ z.EncFallback(yy3400)
}
}
}
- if yyr3385 || yy2arr3385 {
+ if yyr3390 || yy2arr3390 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if x.Items == nil {
r.EncodeNil()
} else {
- yym3398 := z.EncBinary()
- _ = yym3398
+ yym3403 := z.EncBinary()
+ _ = yym3403
if false {
} else {
h.encSliceNamespace(([]Namespace)(x.Items), e)
@@ -43360,15 +43424,15 @@ func (x *NamespaceList) CodecEncodeSelf(e *codec1978.Encoder) {
if x.Items == nil {
r.EncodeNil()
} else {
- yym3399 := z.EncBinary()
- _ = yym3399
+ yym3404 := z.EncBinary()
+ _ = yym3404
if false {
} else {
h.encSliceNamespace(([]Namespace)(x.Items), e)
}
}
}
- if yyr3385 || yy2arr3385 {
+ if yyr3390 || yy2arr3390 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -43381,25 +43445,25 @@ func (x *NamespaceList) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym3400 := z.DecBinary()
- _ = yym3400
+ yym3405 := z.DecBinary()
+ _ = yym3405
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct3401 := r.ContainerType()
- if yyct3401 == codecSelferValueTypeMap1234 {
- yyl3401 := r.ReadMapStart()
- if yyl3401 == 0 {
+ yyct3406 := r.ContainerType()
+ if yyct3406 == codecSelferValueTypeMap1234 {
+ yyl3406 := r.ReadMapStart()
+ if yyl3406 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl3401, d)
+ x.codecDecodeSelfFromMap(yyl3406, d)
}
- } else if yyct3401 == codecSelferValueTypeArray1234 {
- yyl3401 := r.ReadArrayStart()
- if yyl3401 == 0 {
+ } else if yyct3406 == codecSelferValueTypeArray1234 {
+ yyl3406 := r.ReadArrayStart()
+ if yyl3406 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl3401, d)
+ x.codecDecodeSelfFromArray(yyl3406, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -43411,12 +43475,12 @@ func (x *NamespaceList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys3402Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys3402Slc
- var yyhl3402 bool = l >= 0
- for yyj3402 := 0; ; yyj3402++ {
- if yyhl3402 {
- if yyj3402 >= l {
+ var yys3407Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3407Slc
+ var yyhl3407 bool = l >= 0
+ for yyj3407 := 0; ; yyj3407++ {
+ if yyhl3407 {
+ if yyj3407 >= l {
break
}
} else {
@@ -43425,10 +43489,10 @@ func (x *NamespaceList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys3402Slc = r.DecodeBytes(yys3402Slc, true, true)
- yys3402 := string(yys3402Slc)
+ yys3407Slc = r.DecodeBytes(yys3407Slc, true, true)
+ yys3407 := string(yys3407Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys3402 {
+ switch yys3407 {
case "kind":
if r.TryDecodeAsNil() {
x.Kind = ""
@@ -43445,31 +43509,31 @@ func (x *NamespaceList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.ListMeta = pkg2_v1.ListMeta{}
} else {
- yyv3405 := &x.ListMeta
- yym3406 := z.DecBinary()
- _ = yym3406
+ yyv3410 := &x.ListMeta
+ yym3411 := z.DecBinary()
+ _ = yym3411
if false {
- } else if z.HasExtensions() && z.DecExt(yyv3405) {
+ } else if z.HasExtensions() && z.DecExt(yyv3410) {
} else {
- z.DecFallback(yyv3405, false)
+ z.DecFallback(yyv3410, false)
}
}
case "items":
if r.TryDecodeAsNil() {
x.Items = nil
} else {
- yyv3407 := &x.Items
- yym3408 := z.DecBinary()
- _ = yym3408
+ yyv3412 := &x.Items
+ yym3413 := z.DecBinary()
+ _ = yym3413
if false {
} else {
- h.decSliceNamespace((*[]Namespace)(yyv3407), d)
+ h.decSliceNamespace((*[]Namespace)(yyv3412), d)
}
}
default:
- z.DecStructFieldNotFound(-1, yys3402)
- } // end switch yys3402
- } // end for yyj3402
+ z.DecStructFieldNotFound(-1, yys3407)
+ } // end switch yys3407
+ } // end for yyj3407
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -43477,16 +43541,16 @@ func (x *NamespaceList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj3409 int
- var yyb3409 bool
- var yyhl3409 bool = l >= 0
- yyj3409++
- if yyhl3409 {
- yyb3409 = yyj3409 > l
+ var yyj3414 int
+ var yyb3414 bool
+ var yyhl3414 bool = l >= 0
+ yyj3414++
+ if yyhl3414 {
+ yyb3414 = yyj3414 > l
} else {
- yyb3409 = r.CheckBreak()
+ yyb3414 = r.CheckBreak()
}
- if yyb3409 {
+ if yyb3414 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -43496,13 +43560,13 @@ func (x *NamespaceList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Kind = string(r.DecodeString())
}
- yyj3409++
- if yyhl3409 {
- yyb3409 = yyj3409 > l
+ yyj3414++
+ if yyhl3414 {
+ yyb3414 = yyj3414 > l
} else {
- yyb3409 = r.CheckBreak()
+ yyb3414 = r.CheckBreak()
}
- if yyb3409 {
+ if yyb3414 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -43512,13 +43576,13 @@ func (x *NamespaceList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.APIVersion = string(r.DecodeString())
}
- yyj3409++
- if yyhl3409 {
- yyb3409 = yyj3409 > l
+ yyj3414++
+ if yyhl3414 {
+ yyb3414 = yyj3414 > l
} else {
- yyb3409 = r.CheckBreak()
+ yyb3414 = r.CheckBreak()
}
- if yyb3409 {
+ if yyb3414 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -43526,22 +43590,22 @@ func (x *NamespaceList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.ListMeta = pkg2_v1.ListMeta{}
} else {
- yyv3412 := &x.ListMeta
- yym3413 := z.DecBinary()
- _ = yym3413
+ yyv3417 := &x.ListMeta
+ yym3418 := z.DecBinary()
+ _ = yym3418
if false {
- } else if z.HasExtensions() && z.DecExt(yyv3412) {
+ } else if z.HasExtensions() && z.DecExt(yyv3417) {
} else {
- z.DecFallback(yyv3412, false)
+ z.DecFallback(yyv3417, false)
}
}
- yyj3409++
- if yyhl3409 {
- yyb3409 = yyj3409 > l
+ yyj3414++
+ if yyhl3414 {
+ yyb3414 = yyj3414 > l
} else {
- yyb3409 = r.CheckBreak()
+ yyb3414 = r.CheckBreak()
}
- if yyb3409 {
+ if yyb3414 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -43549,26 +43613,26 @@ func (x *NamespaceList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Items = nil
} else {
- yyv3414 := &x.Items
- yym3415 := z.DecBinary()
- _ = yym3415
+ yyv3419 := &x.Items
+ yym3420 := z.DecBinary()
+ _ = yym3420
if false {
} else {
- h.decSliceNamespace((*[]Namespace)(yyv3414), d)
+ h.decSliceNamespace((*[]Namespace)(yyv3419), d)
}
}
for {
- yyj3409++
- if yyhl3409 {
- yyb3409 = yyj3409 > l
+ yyj3414++
+ if yyhl3414 {
+ yyb3414 = yyj3414 > l
} else {
- yyb3409 = r.CheckBreak()
+ yyb3414 = r.CheckBreak()
}
- if yyb3409 {
+ if yyb3414 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj3409-1, "")
+ z.DecStructFieldNotFound(yyj3414-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -43580,37 +43644,37 @@ func (x *Binding) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym3416 := z.EncBinary()
- _ = yym3416
+ yym3421 := z.EncBinary()
+ _ = yym3421
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep3417 := !z.EncBinary()
- yy2arr3417 := z.EncBasicHandle().StructToArray
- var yyq3417 [4]bool
- _, _, _ = yysep3417, yyq3417, yy2arr3417
- const yyr3417 bool = false
- yyq3417[0] = x.Kind != ""
- yyq3417[1] = x.APIVersion != ""
- yyq3417[2] = true
- var yynn3417 int
- if yyr3417 || yy2arr3417 {
+ yysep3422 := !z.EncBinary()
+ yy2arr3422 := z.EncBasicHandle().StructToArray
+ var yyq3422 [4]bool
+ _, _, _ = yysep3422, yyq3422, yy2arr3422
+ const yyr3422 bool = false
+ yyq3422[0] = x.Kind != ""
+ yyq3422[1] = x.APIVersion != ""
+ yyq3422[2] = true
+ var yynn3422 int
+ if yyr3422 || yy2arr3422 {
r.EncodeArrayStart(4)
} else {
- yynn3417 = 1
- for _, b := range yyq3417 {
+ yynn3422 = 1
+ for _, b := range yyq3422 {
if b {
- yynn3417++
+ yynn3422++
}
}
- r.EncodeMapStart(yynn3417)
- yynn3417 = 0
+ r.EncodeMapStart(yynn3422)
+ yynn3422 = 0
}
- if yyr3417 || yy2arr3417 {
+ if yyr3422 || yy2arr3422 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3417[0] {
- yym3419 := z.EncBinary()
- _ = yym3419
+ if yyq3422[0] {
+ yym3424 := z.EncBinary()
+ _ = yym3424
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
@@ -43619,23 +43683,23 @@ func (x *Binding) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq3417[0] {
+ if yyq3422[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("kind"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3420 := z.EncBinary()
- _ = yym3420
+ yym3425 := z.EncBinary()
+ _ = yym3425
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
}
}
}
- if yyr3417 || yy2arr3417 {
+ if yyr3422 || yy2arr3422 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3417[1] {
- yym3422 := z.EncBinary()
- _ = yym3422
+ if yyq3422[1] {
+ yym3427 := z.EncBinary()
+ _ = yym3427
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
@@ -43644,47 +43708,47 @@ func (x *Binding) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq3417[1] {
+ if yyq3422[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3423 := z.EncBinary()
- _ = yym3423
+ yym3428 := z.EncBinary()
+ _ = yym3428
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
}
}
}
- if yyr3417 || yy2arr3417 {
+ if yyr3422 || yy2arr3422 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3417[2] {
- yy3425 := &x.ObjectMeta
- yy3425.CodecEncodeSelf(e)
+ if yyq3422[2] {
+ yy3430 := &x.ObjectMeta
+ yy3430.CodecEncodeSelf(e)
} else {
r.EncodeNil()
}
} else {
- if yyq3417[2] {
+ if yyq3422[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("metadata"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy3426 := &x.ObjectMeta
- yy3426.CodecEncodeSelf(e)
+ yy3431 := &x.ObjectMeta
+ yy3431.CodecEncodeSelf(e)
}
}
- if yyr3417 || yy2arr3417 {
+ if yyr3422 || yy2arr3422 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy3428 := &x.Target
- yy3428.CodecEncodeSelf(e)
+ yy3433 := &x.Target
+ yy3433.CodecEncodeSelf(e)
} else {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("target"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy3429 := &x.Target
- yy3429.CodecEncodeSelf(e)
+ yy3434 := &x.Target
+ yy3434.CodecEncodeSelf(e)
}
- if yyr3417 || yy2arr3417 {
+ if yyr3422 || yy2arr3422 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -43697,25 +43761,25 @@ func (x *Binding) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym3430 := z.DecBinary()
- _ = yym3430
+ yym3435 := z.DecBinary()
+ _ = yym3435
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct3431 := r.ContainerType()
- if yyct3431 == codecSelferValueTypeMap1234 {
- yyl3431 := r.ReadMapStart()
- if yyl3431 == 0 {
+ yyct3436 := r.ContainerType()
+ if yyct3436 == codecSelferValueTypeMap1234 {
+ yyl3436 := r.ReadMapStart()
+ if yyl3436 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl3431, d)
+ x.codecDecodeSelfFromMap(yyl3436, d)
}
- } else if yyct3431 == codecSelferValueTypeArray1234 {
- yyl3431 := r.ReadArrayStart()
- if yyl3431 == 0 {
+ } else if yyct3436 == codecSelferValueTypeArray1234 {
+ yyl3436 := r.ReadArrayStart()
+ if yyl3436 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl3431, d)
+ x.codecDecodeSelfFromArray(yyl3436, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -43727,12 +43791,12 @@ func (x *Binding) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys3432Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys3432Slc
- var yyhl3432 bool = l >= 0
- for yyj3432 := 0; ; yyj3432++ {
- if yyhl3432 {
- if yyj3432 >= l {
+ var yys3437Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3437Slc
+ var yyhl3437 bool = l >= 0
+ for yyj3437 := 0; ; yyj3437++ {
+ if yyhl3437 {
+ if yyj3437 >= l {
break
}
} else {
@@ -43741,10 +43805,10 @@ func (x *Binding) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys3432Slc = r.DecodeBytes(yys3432Slc, true, true)
- yys3432 := string(yys3432Slc)
+ yys3437Slc = r.DecodeBytes(yys3437Slc, true, true)
+ yys3437 := string(yys3437Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys3432 {
+ switch yys3437 {
case "kind":
if r.TryDecodeAsNil() {
x.Kind = ""
@@ -43761,20 +43825,20 @@ func (x *Binding) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.ObjectMeta = ObjectMeta{}
} else {
- yyv3435 := &x.ObjectMeta
- yyv3435.CodecDecodeSelf(d)
+ yyv3440 := &x.ObjectMeta
+ yyv3440.CodecDecodeSelf(d)
}
case "target":
if r.TryDecodeAsNil() {
x.Target = ObjectReference{}
} else {
- yyv3436 := &x.Target
- yyv3436.CodecDecodeSelf(d)
+ yyv3441 := &x.Target
+ yyv3441.CodecDecodeSelf(d)
}
default:
- z.DecStructFieldNotFound(-1, yys3432)
- } // end switch yys3432
- } // end for yyj3432
+ z.DecStructFieldNotFound(-1, yys3437)
+ } // end switch yys3437
+ } // end for yyj3437
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -43782,16 +43846,16 @@ func (x *Binding) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj3437 int
- var yyb3437 bool
- var yyhl3437 bool = l >= 0
- yyj3437++
- if yyhl3437 {
- yyb3437 = yyj3437 > l
+ var yyj3442 int
+ var yyb3442 bool
+ var yyhl3442 bool = l >= 0
+ yyj3442++
+ if yyhl3442 {
+ yyb3442 = yyj3442 > l
} else {
- yyb3437 = r.CheckBreak()
+ yyb3442 = r.CheckBreak()
}
- if yyb3437 {
+ if yyb3442 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -43801,13 +43865,13 @@ func (x *Binding) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Kind = string(r.DecodeString())
}
- yyj3437++
- if yyhl3437 {
- yyb3437 = yyj3437 > l
+ yyj3442++
+ if yyhl3442 {
+ yyb3442 = yyj3442 > l
} else {
- yyb3437 = r.CheckBreak()
+ yyb3442 = r.CheckBreak()
}
- if yyb3437 {
+ if yyb3442 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -43817,13 +43881,13 @@ func (x *Binding) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.APIVersion = string(r.DecodeString())
}
- yyj3437++
- if yyhl3437 {
- yyb3437 = yyj3437 > l
+ yyj3442++
+ if yyhl3442 {
+ yyb3442 = yyj3442 > l
} else {
- yyb3437 = r.CheckBreak()
+ yyb3442 = r.CheckBreak()
}
- if yyb3437 {
+ if yyb3442 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -43831,16 +43895,16 @@ func (x *Binding) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.ObjectMeta = ObjectMeta{}
} else {
- yyv3440 := &x.ObjectMeta
- yyv3440.CodecDecodeSelf(d)
+ yyv3445 := &x.ObjectMeta
+ yyv3445.CodecDecodeSelf(d)
}
- yyj3437++
- if yyhl3437 {
- yyb3437 = yyj3437 > l
+ yyj3442++
+ if yyhl3442 {
+ yyb3442 = yyj3442 > l
} else {
- yyb3437 = r.CheckBreak()
+ yyb3442 = r.CheckBreak()
}
- if yyb3437 {
+ if yyb3442 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -43848,21 +43912,21 @@ func (x *Binding) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Target = ObjectReference{}
} else {
- yyv3441 := &x.Target
- yyv3441.CodecDecodeSelf(d)
+ yyv3446 := &x.Target
+ yyv3446.CodecDecodeSelf(d)
}
for {
- yyj3437++
- if yyhl3437 {
- yyb3437 = yyj3437 > l
+ yyj3442++
+ if yyhl3442 {
+ yyb3442 = yyj3442 > l
} else {
- yyb3437 = r.CheckBreak()
+ yyb3442 = r.CheckBreak()
}
- if yyb3437 {
+ if yyb3442 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj3437-1, "")
+ z.DecStructFieldNotFound(yyj3442-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -43874,68 +43938,68 @@ func (x *Preconditions) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym3442 := z.EncBinary()
- _ = yym3442
+ yym3447 := z.EncBinary()
+ _ = yym3447
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep3443 := !z.EncBinary()
- yy2arr3443 := z.EncBasicHandle().StructToArray
- var yyq3443 [1]bool
- _, _, _ = yysep3443, yyq3443, yy2arr3443
- const yyr3443 bool = false
- yyq3443[0] = x.UID != nil
- var yynn3443 int
- if yyr3443 || yy2arr3443 {
+ yysep3448 := !z.EncBinary()
+ yy2arr3448 := z.EncBasicHandle().StructToArray
+ var yyq3448 [1]bool
+ _, _, _ = yysep3448, yyq3448, yy2arr3448
+ const yyr3448 bool = false
+ yyq3448[0] = x.UID != nil
+ var yynn3448 int
+ if yyr3448 || yy2arr3448 {
r.EncodeArrayStart(1)
} else {
- yynn3443 = 0
- for _, b := range yyq3443 {
+ yynn3448 = 0
+ for _, b := range yyq3448 {
if b {
- yynn3443++
+ yynn3448++
}
}
- r.EncodeMapStart(yynn3443)
- yynn3443 = 0
+ r.EncodeMapStart(yynn3448)
+ yynn3448 = 0
}
- if yyr3443 || yy2arr3443 {
+ if yyr3448 || yy2arr3448 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3443[0] {
+ if yyq3448[0] {
if x.UID == nil {
r.EncodeNil()
} else {
- yy3445 := *x.UID
- yym3446 := z.EncBinary()
- _ = yym3446
+ yy3450 := *x.UID
+ yym3451 := z.EncBinary()
+ _ = yym3451
if false {
- } else if z.HasExtensions() && z.EncExt(yy3445) {
+ } else if z.HasExtensions() && z.EncExt(yy3450) {
} else {
- r.EncodeString(codecSelferC_UTF81234, string(yy3445))
+ r.EncodeString(codecSelferC_UTF81234, string(yy3450))
}
}
} else {
r.EncodeNil()
}
} else {
- if yyq3443[0] {
+ if yyq3448[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("uid"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
if x.UID == nil {
r.EncodeNil()
} else {
- yy3447 := *x.UID
- yym3448 := z.EncBinary()
- _ = yym3448
+ yy3452 := *x.UID
+ yym3453 := z.EncBinary()
+ _ = yym3453
if false {
- } else if z.HasExtensions() && z.EncExt(yy3447) {
+ } else if z.HasExtensions() && z.EncExt(yy3452) {
} else {
- r.EncodeString(codecSelferC_UTF81234, string(yy3447))
+ r.EncodeString(codecSelferC_UTF81234, string(yy3452))
}
}
}
}
- if yyr3443 || yy2arr3443 {
+ if yyr3448 || yy2arr3448 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -43948,25 +44012,25 @@ func (x *Preconditions) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym3449 := z.DecBinary()
- _ = yym3449
+ yym3454 := z.DecBinary()
+ _ = yym3454
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct3450 := r.ContainerType()
- if yyct3450 == codecSelferValueTypeMap1234 {
- yyl3450 := r.ReadMapStart()
- if yyl3450 == 0 {
+ yyct3455 := r.ContainerType()
+ if yyct3455 == codecSelferValueTypeMap1234 {
+ yyl3455 := r.ReadMapStart()
+ if yyl3455 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl3450, d)
+ x.codecDecodeSelfFromMap(yyl3455, d)
}
- } else if yyct3450 == codecSelferValueTypeArray1234 {
- yyl3450 := r.ReadArrayStart()
- if yyl3450 == 0 {
+ } else if yyct3455 == codecSelferValueTypeArray1234 {
+ yyl3455 := r.ReadArrayStart()
+ if yyl3455 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl3450, d)
+ x.codecDecodeSelfFromArray(yyl3455, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -43978,12 +44042,12 @@ func (x *Preconditions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys3451Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys3451Slc
- var yyhl3451 bool = l >= 0
- for yyj3451 := 0; ; yyj3451++ {
- if yyhl3451 {
- if yyj3451 >= l {
+ var yys3456Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3456Slc
+ var yyhl3456 bool = l >= 0
+ for yyj3456 := 0; ; yyj3456++ {
+ if yyhl3456 {
+ if yyj3456 >= l {
break
}
} else {
@@ -43992,10 +44056,10 @@ func (x *Preconditions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys3451Slc = r.DecodeBytes(yys3451Slc, true, true)
- yys3451 := string(yys3451Slc)
+ yys3456Slc = r.DecodeBytes(yys3456Slc, true, true)
+ yys3456 := string(yys3456Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys3451 {
+ switch yys3456 {
case "uid":
if r.TryDecodeAsNil() {
if x.UID != nil {
@@ -44005,8 +44069,8 @@ func (x *Preconditions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
if x.UID == nil {
x.UID = new(pkg1_types.UID)
}
- yym3453 := z.DecBinary()
- _ = yym3453
+ yym3458 := z.DecBinary()
+ _ = yym3458
if false {
} else if z.HasExtensions() && z.DecExt(x.UID) {
} else {
@@ -44014,9 +44078,9 @@ func (x *Preconditions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
}
default:
- z.DecStructFieldNotFound(-1, yys3451)
- } // end switch yys3451
- } // end for yyj3451
+ z.DecStructFieldNotFound(-1, yys3456)
+ } // end switch yys3456
+ } // end for yyj3456
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -44024,16 +44088,16 @@ func (x *Preconditions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj3454 int
- var yyb3454 bool
- var yyhl3454 bool = l >= 0
- yyj3454++
- if yyhl3454 {
- yyb3454 = yyj3454 > l
+ var yyj3459 int
+ var yyb3459 bool
+ var yyhl3459 bool = l >= 0
+ yyj3459++
+ if yyhl3459 {
+ yyb3459 = yyj3459 > l
} else {
- yyb3454 = r.CheckBreak()
+ yyb3459 = r.CheckBreak()
}
- if yyb3454 {
+ if yyb3459 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -44046,8 +44110,8 @@ func (x *Preconditions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if x.UID == nil {
x.UID = new(pkg1_types.UID)
}
- yym3456 := z.DecBinary()
- _ = yym3456
+ yym3461 := z.DecBinary()
+ _ = yym3461
if false {
} else if z.HasExtensions() && z.DecExt(x.UID) {
} else {
@@ -44055,17 +44119,17 @@ func (x *Preconditions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
}
}
for {
- yyj3454++
- if yyhl3454 {
- yyb3454 = yyj3454 > l
+ yyj3459++
+ if yyhl3459 {
+ yyb3459 = yyj3459 > l
} else {
- yyb3454 = r.CheckBreak()
+ yyb3459 = r.CheckBreak()
}
- if yyb3454 {
+ if yyb3459 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj3454-1, "")
+ z.DecStructFieldNotFound(yyj3459-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -44077,39 +44141,39 @@ func (x *DeleteOptions) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym3457 := z.EncBinary()
- _ = yym3457
+ yym3462 := z.EncBinary()
+ _ = yym3462
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep3458 := !z.EncBinary()
- yy2arr3458 := z.EncBasicHandle().StructToArray
- var yyq3458 [5]bool
- _, _, _ = yysep3458, yyq3458, yy2arr3458
- const yyr3458 bool = false
- yyq3458[0] = x.Kind != ""
- yyq3458[1] = x.APIVersion != ""
- yyq3458[2] = x.GracePeriodSeconds != nil
- yyq3458[3] = x.Preconditions != nil
- yyq3458[4] = x.OrphanDependents != nil
- var yynn3458 int
- if yyr3458 || yy2arr3458 {
+ yysep3463 := !z.EncBinary()
+ yy2arr3463 := z.EncBasicHandle().StructToArray
+ var yyq3463 [5]bool
+ _, _, _ = yysep3463, yyq3463, yy2arr3463
+ const yyr3463 bool = false
+ yyq3463[0] = x.Kind != ""
+ yyq3463[1] = x.APIVersion != ""
+ yyq3463[2] = x.GracePeriodSeconds != nil
+ yyq3463[3] = x.Preconditions != nil
+ yyq3463[4] = x.OrphanDependents != nil
+ var yynn3463 int
+ if yyr3463 || yy2arr3463 {
r.EncodeArrayStart(5)
} else {
- yynn3458 = 0
- for _, b := range yyq3458 {
+ yynn3463 = 0
+ for _, b := range yyq3463 {
if b {
- yynn3458++
+ yynn3463++
}
}
- r.EncodeMapStart(yynn3458)
- yynn3458 = 0
+ r.EncodeMapStart(yynn3463)
+ yynn3463 = 0
}
- if yyr3458 || yy2arr3458 {
+ if yyr3463 || yy2arr3463 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3458[0] {
- yym3460 := z.EncBinary()
- _ = yym3460
+ if yyq3463[0] {
+ yym3465 := z.EncBinary()
+ _ = yym3465
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
@@ -44118,23 +44182,23 @@ func (x *DeleteOptions) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq3458[0] {
+ if yyq3463[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("kind"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3461 := z.EncBinary()
- _ = yym3461
+ yym3466 := z.EncBinary()
+ _ = yym3466
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
}
}
}
- if yyr3458 || yy2arr3458 {
+ if yyr3463 || yy2arr3463 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3458[1] {
- yym3463 := z.EncBinary()
- _ = yym3463
+ if yyq3463[1] {
+ yym3468 := z.EncBinary()
+ _ = yym3468
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
@@ -44143,56 +44207,56 @@ func (x *DeleteOptions) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq3458[1] {
+ if yyq3463[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3464 := z.EncBinary()
- _ = yym3464
+ yym3469 := z.EncBinary()
+ _ = yym3469
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
}
}
}
- if yyr3458 || yy2arr3458 {
+ if yyr3463 || yy2arr3463 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3458[2] {
+ if yyq3463[2] {
if x.GracePeriodSeconds == nil {
r.EncodeNil()
} else {
- yy3466 := *x.GracePeriodSeconds
- yym3467 := z.EncBinary()
- _ = yym3467
+ yy3471 := *x.GracePeriodSeconds
+ yym3472 := z.EncBinary()
+ _ = yym3472
if false {
} else {
- r.EncodeInt(int64(yy3466))
+ r.EncodeInt(int64(yy3471))
}
}
} else {
r.EncodeNil()
}
} else {
- if yyq3458[2] {
+ if yyq3463[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("gracePeriodSeconds"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
if x.GracePeriodSeconds == nil {
r.EncodeNil()
} else {
- yy3468 := *x.GracePeriodSeconds
- yym3469 := z.EncBinary()
- _ = yym3469
+ yy3473 := *x.GracePeriodSeconds
+ yym3474 := z.EncBinary()
+ _ = yym3474
if false {
} else {
- r.EncodeInt(int64(yy3468))
+ r.EncodeInt(int64(yy3473))
}
}
}
}
- if yyr3458 || yy2arr3458 {
+ if yyr3463 || yy2arr3463 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3458[3] {
+ if yyq3463[3] {
if x.Preconditions == nil {
r.EncodeNil()
} else {
@@ -44202,7 +44266,7 @@ func (x *DeleteOptions) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeNil()
}
} else {
- if yyq3458[3] {
+ if yyq3463[3] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("preconditions"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
@@ -44213,42 +44277,42 @@ func (x *DeleteOptions) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
- if yyr3458 || yy2arr3458 {
+ if yyr3463 || yy2arr3463 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3458[4] {
+ if yyq3463[4] {
if x.OrphanDependents == nil {
r.EncodeNil()
} else {
- yy3472 := *x.OrphanDependents
- yym3473 := z.EncBinary()
- _ = yym3473
+ yy3477 := *x.OrphanDependents
+ yym3478 := z.EncBinary()
+ _ = yym3478
if false {
} else {
- r.EncodeBool(bool(yy3472))
+ r.EncodeBool(bool(yy3477))
}
}
} else {
r.EncodeNil()
}
} else {
- if yyq3458[4] {
+ if yyq3463[4] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("orphanDependents"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
if x.OrphanDependents == nil {
r.EncodeNil()
} else {
- yy3474 := *x.OrphanDependents
- yym3475 := z.EncBinary()
- _ = yym3475
+ yy3479 := *x.OrphanDependents
+ yym3480 := z.EncBinary()
+ _ = yym3480
if false {
} else {
- r.EncodeBool(bool(yy3474))
+ r.EncodeBool(bool(yy3479))
}
}
}
}
- if yyr3458 || yy2arr3458 {
+ if yyr3463 || yy2arr3463 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -44261,25 +44325,25 @@ func (x *DeleteOptions) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym3476 := z.DecBinary()
- _ = yym3476
+ yym3481 := z.DecBinary()
+ _ = yym3481
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct3477 := r.ContainerType()
- if yyct3477 == codecSelferValueTypeMap1234 {
- yyl3477 := r.ReadMapStart()
- if yyl3477 == 0 {
+ yyct3482 := r.ContainerType()
+ if yyct3482 == codecSelferValueTypeMap1234 {
+ yyl3482 := r.ReadMapStart()
+ if yyl3482 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl3477, d)
+ x.codecDecodeSelfFromMap(yyl3482, d)
}
- } else if yyct3477 == codecSelferValueTypeArray1234 {
- yyl3477 := r.ReadArrayStart()
- if yyl3477 == 0 {
+ } else if yyct3482 == codecSelferValueTypeArray1234 {
+ yyl3482 := r.ReadArrayStart()
+ if yyl3482 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl3477, d)
+ x.codecDecodeSelfFromArray(yyl3482, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -44291,12 +44355,12 @@ func (x *DeleteOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys3478Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys3478Slc
- var yyhl3478 bool = l >= 0
- for yyj3478 := 0; ; yyj3478++ {
- if yyhl3478 {
- if yyj3478 >= l {
+ var yys3483Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3483Slc
+ var yyhl3483 bool = l >= 0
+ for yyj3483 := 0; ; yyj3483++ {
+ if yyhl3483 {
+ if yyj3483 >= l {
break
}
} else {
@@ -44305,10 +44369,10 @@ func (x *DeleteOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys3478Slc = r.DecodeBytes(yys3478Slc, true, true)
- yys3478 := string(yys3478Slc)
+ yys3483Slc = r.DecodeBytes(yys3483Slc, true, true)
+ yys3483 := string(yys3483Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys3478 {
+ switch yys3483 {
case "kind":
if r.TryDecodeAsNil() {
x.Kind = ""
@@ -44330,8 +44394,8 @@ func (x *DeleteOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
if x.GracePeriodSeconds == nil {
x.GracePeriodSeconds = new(int64)
}
- yym3482 := z.DecBinary()
- _ = yym3482
+ yym3487 := z.DecBinary()
+ _ = yym3487
if false {
} else {
*((*int64)(x.GracePeriodSeconds)) = int64(r.DecodeInt(64))
@@ -44357,17 +44421,17 @@ func (x *DeleteOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
if x.OrphanDependents == nil {
x.OrphanDependents = new(bool)
}
- yym3485 := z.DecBinary()
- _ = yym3485
+ yym3490 := z.DecBinary()
+ _ = yym3490
if false {
} else {
*((*bool)(x.OrphanDependents)) = r.DecodeBool()
}
}
default:
- z.DecStructFieldNotFound(-1, yys3478)
- } // end switch yys3478
- } // end for yyj3478
+ z.DecStructFieldNotFound(-1, yys3483)
+ } // end switch yys3483
+ } // end for yyj3483
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -44375,16 +44439,16 @@ func (x *DeleteOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj3486 int
- var yyb3486 bool
- var yyhl3486 bool = l >= 0
- yyj3486++
- if yyhl3486 {
- yyb3486 = yyj3486 > l
+ var yyj3491 int
+ var yyb3491 bool
+ var yyhl3491 bool = l >= 0
+ yyj3491++
+ if yyhl3491 {
+ yyb3491 = yyj3491 > l
} else {
- yyb3486 = r.CheckBreak()
+ yyb3491 = r.CheckBreak()
}
- if yyb3486 {
+ if yyb3491 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -44394,13 +44458,13 @@ func (x *DeleteOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Kind = string(r.DecodeString())
}
- yyj3486++
- if yyhl3486 {
- yyb3486 = yyj3486 > l
+ yyj3491++
+ if yyhl3491 {
+ yyb3491 = yyj3491 > l
} else {
- yyb3486 = r.CheckBreak()
+ yyb3491 = r.CheckBreak()
}
- if yyb3486 {
+ if yyb3491 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -44410,13 +44474,13 @@ func (x *DeleteOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.APIVersion = string(r.DecodeString())
}
- yyj3486++
- if yyhl3486 {
- yyb3486 = yyj3486 > l
+ yyj3491++
+ if yyhl3491 {
+ yyb3491 = yyj3491 > l
} else {
- yyb3486 = r.CheckBreak()
+ yyb3491 = r.CheckBreak()
}
- if yyb3486 {
+ if yyb3491 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -44429,20 +44493,20 @@ func (x *DeleteOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if x.GracePeriodSeconds == nil {
x.GracePeriodSeconds = new(int64)
}
- yym3490 := z.DecBinary()
- _ = yym3490
+ yym3495 := z.DecBinary()
+ _ = yym3495
if false {
} else {
*((*int64)(x.GracePeriodSeconds)) = int64(r.DecodeInt(64))
}
}
- yyj3486++
- if yyhl3486 {
- yyb3486 = yyj3486 > l
+ yyj3491++
+ if yyhl3491 {
+ yyb3491 = yyj3491 > l
} else {
- yyb3486 = r.CheckBreak()
+ yyb3491 = r.CheckBreak()
}
- if yyb3486 {
+ if yyb3491 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -44457,13 +44521,13 @@ func (x *DeleteOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
}
x.Preconditions.CodecDecodeSelf(d)
}
- yyj3486++
- if yyhl3486 {
- yyb3486 = yyj3486 > l
+ yyj3491++
+ if yyhl3491 {
+ yyb3491 = yyj3491 > l
} else {
- yyb3486 = r.CheckBreak()
+ yyb3491 = r.CheckBreak()
}
- if yyb3486 {
+ if yyb3491 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -44476,25 +44540,25 @@ func (x *DeleteOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if x.OrphanDependents == nil {
x.OrphanDependents = new(bool)
}
- yym3493 := z.DecBinary()
- _ = yym3493
+ yym3498 := z.DecBinary()
+ _ = yym3498
if false {
} else {
*((*bool)(x.OrphanDependents)) = r.DecodeBool()
}
}
for {
- yyj3486++
- if yyhl3486 {
- yyb3486 = yyj3486 > l
+ yyj3491++
+ if yyhl3491 {
+ yyb3491 = yyj3491 > l
} else {
- yyb3486 = r.CheckBreak()
+ yyb3491 = r.CheckBreak()
}
- if yyb3486 {
+ if yyb3491 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj3486-1, "")
+ z.DecStructFieldNotFound(yyj3491-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -44506,41 +44570,41 @@ func (x *ListOptions) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym3494 := z.EncBinary()
- _ = yym3494
+ yym3499 := z.EncBinary()
+ _ = yym3499
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep3495 := !z.EncBinary()
- yy2arr3495 := z.EncBasicHandle().StructToArray
- var yyq3495 [7]bool
- _, _, _ = yysep3495, yyq3495, yy2arr3495
- const yyr3495 bool = false
- yyq3495[0] = x.Kind != ""
- yyq3495[1] = x.APIVersion != ""
- yyq3495[2] = x.LabelSelector != ""
- yyq3495[3] = x.FieldSelector != ""
- yyq3495[4] = x.Watch != false
- yyq3495[5] = x.ResourceVersion != ""
- yyq3495[6] = x.TimeoutSeconds != nil
- var yynn3495 int
- if yyr3495 || yy2arr3495 {
+ yysep3500 := !z.EncBinary()
+ yy2arr3500 := z.EncBasicHandle().StructToArray
+ var yyq3500 [7]bool
+ _, _, _ = yysep3500, yyq3500, yy2arr3500
+ const yyr3500 bool = false
+ yyq3500[0] = x.Kind != ""
+ yyq3500[1] = x.APIVersion != ""
+ yyq3500[2] = x.LabelSelector != ""
+ yyq3500[3] = x.FieldSelector != ""
+ yyq3500[4] = x.Watch != false
+ yyq3500[5] = x.ResourceVersion != ""
+ yyq3500[6] = x.TimeoutSeconds != nil
+ var yynn3500 int
+ if yyr3500 || yy2arr3500 {
r.EncodeArrayStart(7)
} else {
- yynn3495 = 0
- for _, b := range yyq3495 {
+ yynn3500 = 0
+ for _, b := range yyq3500 {
if b {
- yynn3495++
+ yynn3500++
}
}
- r.EncodeMapStart(yynn3495)
- yynn3495 = 0
+ r.EncodeMapStart(yynn3500)
+ yynn3500 = 0
}
- if yyr3495 || yy2arr3495 {
+ if yyr3500 || yy2arr3500 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3495[0] {
- yym3497 := z.EncBinary()
- _ = yym3497
+ if yyq3500[0] {
+ yym3502 := z.EncBinary()
+ _ = yym3502
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
@@ -44549,74 +44613,74 @@ func (x *ListOptions) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq3495[0] {
+ if yyq3500[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("kind"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3498 := z.EncBinary()
- _ = yym3498
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
- }
- }
- }
- if yyr3495 || yy2arr3495 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3495[1] {
- yym3500 := z.EncBinary()
- _ = yym3500
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
- }
- } else {
- r.EncodeString(codecSelferC_UTF81234, "")
- }
- } else {
- if yyq3495[1] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3501 := z.EncBinary()
- _ = yym3501
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
- }
- }
- }
- if yyr3495 || yy2arr3495 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3495[2] {
yym3503 := z.EncBinary()
_ = yym3503
if false {
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.LabelSelector))
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ }
+ }
+ if yyr3500 || yy2arr3500 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq3500[1] {
+ yym3505 := z.EncBinary()
+ _ = yym3505
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
}
} else {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq3495[2] {
+ if yyq3500[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("labelSelector"))
+ r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3504 := z.EncBinary()
- _ = yym3504
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.LabelSelector))
- }
- }
- }
- if yyr3495 || yy2arr3495 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3495[3] {
yym3506 := z.EncBinary()
_ = yym3506
if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ }
+ }
+ if yyr3500 || yy2arr3500 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq3500[2] {
+ yym3508 := z.EncBinary()
+ _ = yym3508
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.LabelSelector))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq3500[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("labelSelector"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym3509 := z.EncBinary()
+ _ = yym3509
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.LabelSelector))
+ }
+ }
+ }
+ if yyr3500 || yy2arr3500 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq3500[3] {
+ yym3511 := z.EncBinary()
+ _ = yym3511
+ if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.FieldSelector))
}
@@ -44624,23 +44688,23 @@ func (x *ListOptions) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq3495[3] {
+ if yyq3500[3] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("fieldSelector"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3507 := z.EncBinary()
- _ = yym3507
+ yym3512 := z.EncBinary()
+ _ = yym3512
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.FieldSelector))
}
}
}
- if yyr3495 || yy2arr3495 {
+ if yyr3500 || yy2arr3500 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3495[4] {
- yym3509 := z.EncBinary()
- _ = yym3509
+ if yyq3500[4] {
+ yym3514 := z.EncBinary()
+ _ = yym3514
if false {
} else {
r.EncodeBool(bool(x.Watch))
@@ -44649,23 +44713,23 @@ func (x *ListOptions) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeBool(false)
}
} else {
- if yyq3495[4] {
+ if yyq3500[4] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("watch"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3510 := z.EncBinary()
- _ = yym3510
+ yym3515 := z.EncBinary()
+ _ = yym3515
if false {
} else {
r.EncodeBool(bool(x.Watch))
}
}
}
- if yyr3495 || yy2arr3495 {
+ if yyr3500 || yy2arr3500 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3495[5] {
- yym3512 := z.EncBinary()
- _ = yym3512
+ if yyq3500[5] {
+ yym3517 := z.EncBinary()
+ _ = yym3517
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.ResourceVersion))
@@ -44674,54 +44738,54 @@ func (x *ListOptions) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq3495[5] {
+ if yyq3500[5] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("resourceVersion"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3513 := z.EncBinary()
- _ = yym3513
+ yym3518 := z.EncBinary()
+ _ = yym3518
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.ResourceVersion))
}
}
}
- if yyr3495 || yy2arr3495 {
+ if yyr3500 || yy2arr3500 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3495[6] {
+ if yyq3500[6] {
if x.TimeoutSeconds == nil {
r.EncodeNil()
} else {
- yy3515 := *x.TimeoutSeconds
- yym3516 := z.EncBinary()
- _ = yym3516
+ yy3520 := *x.TimeoutSeconds
+ yym3521 := z.EncBinary()
+ _ = yym3521
if false {
} else {
- r.EncodeInt(int64(yy3515))
+ r.EncodeInt(int64(yy3520))
}
}
} else {
r.EncodeNil()
}
} else {
- if yyq3495[6] {
+ if yyq3500[6] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("timeoutSeconds"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
if x.TimeoutSeconds == nil {
r.EncodeNil()
} else {
- yy3517 := *x.TimeoutSeconds
- yym3518 := z.EncBinary()
- _ = yym3518
+ yy3522 := *x.TimeoutSeconds
+ yym3523 := z.EncBinary()
+ _ = yym3523
if false {
} else {
- r.EncodeInt(int64(yy3517))
+ r.EncodeInt(int64(yy3522))
}
}
}
}
- if yyr3495 || yy2arr3495 {
+ if yyr3500 || yy2arr3500 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -44734,25 +44798,25 @@ func (x *ListOptions) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym3519 := z.DecBinary()
- _ = yym3519
+ yym3524 := z.DecBinary()
+ _ = yym3524
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct3520 := r.ContainerType()
- if yyct3520 == codecSelferValueTypeMap1234 {
- yyl3520 := r.ReadMapStart()
- if yyl3520 == 0 {
+ yyct3525 := r.ContainerType()
+ if yyct3525 == codecSelferValueTypeMap1234 {
+ yyl3525 := r.ReadMapStart()
+ if yyl3525 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl3520, d)
+ x.codecDecodeSelfFromMap(yyl3525, d)
}
- } else if yyct3520 == codecSelferValueTypeArray1234 {
- yyl3520 := r.ReadArrayStart()
- if yyl3520 == 0 {
+ } else if yyct3525 == codecSelferValueTypeArray1234 {
+ yyl3525 := r.ReadArrayStart()
+ if yyl3525 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl3520, d)
+ x.codecDecodeSelfFromArray(yyl3525, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -44764,12 +44828,12 @@ func (x *ListOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys3521Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys3521Slc
- var yyhl3521 bool = l >= 0
- for yyj3521 := 0; ; yyj3521++ {
- if yyhl3521 {
- if yyj3521 >= l {
+ var yys3526Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3526Slc
+ var yyhl3526 bool = l >= 0
+ for yyj3526 := 0; ; yyj3526++ {
+ if yyhl3526 {
+ if yyj3526 >= l {
break
}
} else {
@@ -44778,10 +44842,10 @@ func (x *ListOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys3521Slc = r.DecodeBytes(yys3521Slc, true, true)
- yys3521 := string(yys3521Slc)
+ yys3526Slc = r.DecodeBytes(yys3526Slc, true, true)
+ yys3526 := string(yys3526Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys3521 {
+ switch yys3526 {
case "kind":
if r.TryDecodeAsNil() {
x.Kind = ""
@@ -44827,17 +44891,17 @@ func (x *ListOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
if x.TimeoutSeconds == nil {
x.TimeoutSeconds = new(int64)
}
- yym3529 := z.DecBinary()
- _ = yym3529
+ yym3534 := z.DecBinary()
+ _ = yym3534
if false {
} else {
*((*int64)(x.TimeoutSeconds)) = int64(r.DecodeInt(64))
}
}
default:
- z.DecStructFieldNotFound(-1, yys3521)
- } // end switch yys3521
- } // end for yyj3521
+ z.DecStructFieldNotFound(-1, yys3526)
+ } // end switch yys3526
+ } // end for yyj3526
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -44845,16 +44909,16 @@ func (x *ListOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj3530 int
- var yyb3530 bool
- var yyhl3530 bool = l >= 0
- yyj3530++
- if yyhl3530 {
- yyb3530 = yyj3530 > l
+ var yyj3535 int
+ var yyb3535 bool
+ var yyhl3535 bool = l >= 0
+ yyj3535++
+ if yyhl3535 {
+ yyb3535 = yyj3535 > l
} else {
- yyb3530 = r.CheckBreak()
+ yyb3535 = r.CheckBreak()
}
- if yyb3530 {
+ if yyb3535 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -44864,13 +44928,13 @@ func (x *ListOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Kind = string(r.DecodeString())
}
- yyj3530++
- if yyhl3530 {
- yyb3530 = yyj3530 > l
+ yyj3535++
+ if yyhl3535 {
+ yyb3535 = yyj3535 > l
} else {
- yyb3530 = r.CheckBreak()
+ yyb3535 = r.CheckBreak()
}
- if yyb3530 {
+ if yyb3535 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -44880,13 +44944,13 @@ func (x *ListOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.APIVersion = string(r.DecodeString())
}
- yyj3530++
- if yyhl3530 {
- yyb3530 = yyj3530 > l
+ yyj3535++
+ if yyhl3535 {
+ yyb3535 = yyj3535 > l
} else {
- yyb3530 = r.CheckBreak()
+ yyb3535 = r.CheckBreak()
}
- if yyb3530 {
+ if yyb3535 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -44896,13 +44960,13 @@ func (x *ListOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.LabelSelector = string(r.DecodeString())
}
- yyj3530++
- if yyhl3530 {
- yyb3530 = yyj3530 > l
+ yyj3535++
+ if yyhl3535 {
+ yyb3535 = yyj3535 > l
} else {
- yyb3530 = r.CheckBreak()
+ yyb3535 = r.CheckBreak()
}
- if yyb3530 {
+ if yyb3535 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -44912,13 +44976,13 @@ func (x *ListOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.FieldSelector = string(r.DecodeString())
}
- yyj3530++
- if yyhl3530 {
- yyb3530 = yyj3530 > l
+ yyj3535++
+ if yyhl3535 {
+ yyb3535 = yyj3535 > l
} else {
- yyb3530 = r.CheckBreak()
+ yyb3535 = r.CheckBreak()
}
- if yyb3530 {
+ if yyb3535 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -44928,13 +44992,13 @@ func (x *ListOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Watch = bool(r.DecodeBool())
}
- yyj3530++
- if yyhl3530 {
- yyb3530 = yyj3530 > l
+ yyj3535++
+ if yyhl3535 {
+ yyb3535 = yyj3535 > l
} else {
- yyb3530 = r.CheckBreak()
+ yyb3535 = r.CheckBreak()
}
- if yyb3530 {
+ if yyb3535 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -44944,13 +45008,13 @@ func (x *ListOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.ResourceVersion = string(r.DecodeString())
}
- yyj3530++
- if yyhl3530 {
- yyb3530 = yyj3530 > l
+ yyj3535++
+ if yyhl3535 {
+ yyb3535 = yyj3535 > l
} else {
- yyb3530 = r.CheckBreak()
+ yyb3535 = r.CheckBreak()
}
- if yyb3530 {
+ if yyb3535 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -44963,25 +45027,25 @@ func (x *ListOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if x.TimeoutSeconds == nil {
x.TimeoutSeconds = new(int64)
}
- yym3538 := z.DecBinary()
- _ = yym3538
+ yym3543 := z.DecBinary()
+ _ = yym3543
if false {
} else {
*((*int64)(x.TimeoutSeconds)) = int64(r.DecodeInt(64))
}
}
for {
- yyj3530++
- if yyhl3530 {
- yyb3530 = yyj3530 > l
+ yyj3535++
+ if yyhl3535 {
+ yyb3535 = yyj3535 > l
} else {
- yyb3530 = r.CheckBreak()
+ yyb3535 = r.CheckBreak()
}
- if yyb3530 {
+ if yyb3535 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj3530-1, "")
+ z.DecStructFieldNotFound(yyj3535-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -44993,44 +45057,44 @@ func (x *PodLogOptions) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym3539 := z.EncBinary()
- _ = yym3539
+ yym3544 := z.EncBinary()
+ _ = yym3544
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep3540 := !z.EncBinary()
- yy2arr3540 := z.EncBasicHandle().StructToArray
- var yyq3540 [10]bool
- _, _, _ = yysep3540, yyq3540, yy2arr3540
- const yyr3540 bool = false
- yyq3540[0] = x.Kind != ""
- yyq3540[1] = x.APIVersion != ""
- yyq3540[2] = x.Container != ""
- yyq3540[3] = x.Follow != false
- yyq3540[4] = x.Previous != false
- yyq3540[5] = x.SinceSeconds != nil
- yyq3540[6] = x.SinceTime != nil
- yyq3540[7] = x.Timestamps != false
- yyq3540[8] = x.TailLines != nil
- yyq3540[9] = x.LimitBytes != nil
- var yynn3540 int
- if yyr3540 || yy2arr3540 {
+ yysep3545 := !z.EncBinary()
+ yy2arr3545 := z.EncBasicHandle().StructToArray
+ var yyq3545 [10]bool
+ _, _, _ = yysep3545, yyq3545, yy2arr3545
+ const yyr3545 bool = false
+ yyq3545[0] = x.Kind != ""
+ yyq3545[1] = x.APIVersion != ""
+ yyq3545[2] = x.Container != ""
+ yyq3545[3] = x.Follow != false
+ yyq3545[4] = x.Previous != false
+ yyq3545[5] = x.SinceSeconds != nil
+ yyq3545[6] = x.SinceTime != nil
+ yyq3545[7] = x.Timestamps != false
+ yyq3545[8] = x.TailLines != nil
+ yyq3545[9] = x.LimitBytes != nil
+ var yynn3545 int
+ if yyr3545 || yy2arr3545 {
r.EncodeArrayStart(10)
} else {
- yynn3540 = 0
- for _, b := range yyq3540 {
+ yynn3545 = 0
+ for _, b := range yyq3545 {
if b {
- yynn3540++
+ yynn3545++
}
}
- r.EncodeMapStart(yynn3540)
- yynn3540 = 0
+ r.EncodeMapStart(yynn3545)
+ yynn3545 = 0
}
- if yyr3540 || yy2arr3540 {
+ if yyr3545 || yy2arr3545 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3540[0] {
- yym3542 := z.EncBinary()
- _ = yym3542
+ if yyq3545[0] {
+ yym3547 := z.EncBinary()
+ _ = yym3547
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
@@ -45039,49 +45103,49 @@ func (x *PodLogOptions) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq3540[0] {
+ if yyq3545[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("kind"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3543 := z.EncBinary()
- _ = yym3543
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
- }
- }
- }
- if yyr3540 || yy2arr3540 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3540[1] {
- yym3545 := z.EncBinary()
- _ = yym3545
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
- }
- } else {
- r.EncodeString(codecSelferC_UTF81234, "")
- }
- } else {
- if yyq3540[1] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3546 := z.EncBinary()
- _ = yym3546
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
- }
- }
- }
- if yyr3540 || yy2arr3540 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3540[2] {
yym3548 := z.EncBinary()
_ = yym3548
if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ }
+ }
+ if yyr3545 || yy2arr3545 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq3545[1] {
+ yym3550 := z.EncBinary()
+ _ = yym3550
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq3545[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym3551 := z.EncBinary()
+ _ = yym3551
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ }
+ }
+ if yyr3545 || yy2arr3545 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq3545[2] {
+ yym3553 := z.EncBinary()
+ _ = yym3553
+ if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Container))
}
@@ -45089,23 +45153,23 @@ func (x *PodLogOptions) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq3540[2] {
+ if yyq3545[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("container"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3549 := z.EncBinary()
- _ = yym3549
+ yym3554 := z.EncBinary()
+ _ = yym3554
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Container))
}
}
}
- if yyr3540 || yy2arr3540 {
+ if yyr3545 || yy2arr3545 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3540[3] {
- yym3551 := z.EncBinary()
- _ = yym3551
+ if yyq3545[3] {
+ yym3556 := z.EncBinary()
+ _ = yym3556
if false {
} else {
r.EncodeBool(bool(x.Follow))
@@ -45114,23 +45178,23 @@ func (x *PodLogOptions) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeBool(false)
}
} else {
- if yyq3540[3] {
+ if yyq3545[3] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("follow"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3552 := z.EncBinary()
- _ = yym3552
+ yym3557 := z.EncBinary()
+ _ = yym3557
if false {
} else {
r.EncodeBool(bool(x.Follow))
}
}
}
- if yyr3540 || yy2arr3540 {
+ if yyr3545 || yy2arr3545 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3540[4] {
- yym3554 := z.EncBinary()
- _ = yym3554
+ if yyq3545[4] {
+ yym3559 := z.EncBinary()
+ _ = yym3559
if false {
} else {
r.EncodeBool(bool(x.Previous))
@@ -45139,66 +45203,66 @@ func (x *PodLogOptions) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeBool(false)
}
} else {
- if yyq3540[4] {
+ if yyq3545[4] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("previous"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3555 := z.EncBinary()
- _ = yym3555
+ yym3560 := z.EncBinary()
+ _ = yym3560
if false {
} else {
r.EncodeBool(bool(x.Previous))
}
}
}
- if yyr3540 || yy2arr3540 {
+ if yyr3545 || yy2arr3545 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3540[5] {
+ if yyq3545[5] {
if x.SinceSeconds == nil {
r.EncodeNil()
} else {
- yy3557 := *x.SinceSeconds
- yym3558 := z.EncBinary()
- _ = yym3558
+ yy3562 := *x.SinceSeconds
+ yym3563 := z.EncBinary()
+ _ = yym3563
if false {
} else {
- r.EncodeInt(int64(yy3557))
+ r.EncodeInt(int64(yy3562))
}
}
} else {
r.EncodeNil()
}
} else {
- if yyq3540[5] {
+ if yyq3545[5] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("sinceSeconds"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
if x.SinceSeconds == nil {
r.EncodeNil()
} else {
- yy3559 := *x.SinceSeconds
- yym3560 := z.EncBinary()
- _ = yym3560
+ yy3564 := *x.SinceSeconds
+ yym3565 := z.EncBinary()
+ _ = yym3565
if false {
} else {
- r.EncodeInt(int64(yy3559))
+ r.EncodeInt(int64(yy3564))
}
}
}
}
- if yyr3540 || yy2arr3540 {
+ if yyr3545 || yy2arr3545 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3540[6] {
+ if yyq3545[6] {
if x.SinceTime == nil {
r.EncodeNil()
} else {
- yym3562 := z.EncBinary()
- _ = yym3562
+ yym3567 := z.EncBinary()
+ _ = yym3567
if false {
} else if z.HasExtensions() && z.EncExt(x.SinceTime) {
- } else if yym3562 {
+ } else if yym3567 {
z.EncBinaryMarshal(x.SinceTime)
- } else if !yym3562 && z.IsJSONHandle() {
+ } else if !yym3567 && z.IsJSONHandle() {
z.EncJSONMarshal(x.SinceTime)
} else {
z.EncFallback(x.SinceTime)
@@ -45208,20 +45272,20 @@ func (x *PodLogOptions) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeNil()
}
} else {
- if yyq3540[6] {
+ if yyq3545[6] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("sinceTime"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
if x.SinceTime == nil {
r.EncodeNil()
} else {
- yym3563 := z.EncBinary()
- _ = yym3563
+ yym3568 := z.EncBinary()
+ _ = yym3568
if false {
} else if z.HasExtensions() && z.EncExt(x.SinceTime) {
- } else if yym3563 {
+ } else if yym3568 {
z.EncBinaryMarshal(x.SinceTime)
- } else if !yym3563 && z.IsJSONHandle() {
+ } else if !yym3568 && z.IsJSONHandle() {
z.EncJSONMarshal(x.SinceTime)
} else {
z.EncFallback(x.SinceTime)
@@ -45229,11 +45293,11 @@ func (x *PodLogOptions) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
- if yyr3540 || yy2arr3540 {
+ if yyr3545 || yy2arr3545 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3540[7] {
- yym3565 := z.EncBinary()
- _ = yym3565
+ if yyq3545[7] {
+ yym3570 := z.EncBinary()
+ _ = yym3570
if false {
} else {
r.EncodeBool(bool(x.Timestamps))
@@ -45242,60 +45306,25 @@ func (x *PodLogOptions) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeBool(false)
}
} else {
- if yyq3540[7] {
+ if yyq3545[7] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("timestamps"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3566 := z.EncBinary()
- _ = yym3566
+ yym3571 := z.EncBinary()
+ _ = yym3571
if false {
} else {
r.EncodeBool(bool(x.Timestamps))
}
}
}
- if yyr3540 || yy2arr3540 {
+ if yyr3545 || yy2arr3545 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3540[8] {
+ if yyq3545[8] {
if x.TailLines == nil {
r.EncodeNil()
} else {
- yy3568 := *x.TailLines
- yym3569 := z.EncBinary()
- _ = yym3569
- if false {
- } else {
- r.EncodeInt(int64(yy3568))
- }
- }
- } else {
- r.EncodeNil()
- }
- } else {
- if yyq3540[8] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("tailLines"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- if x.TailLines == nil {
- r.EncodeNil()
- } else {
- yy3570 := *x.TailLines
- yym3571 := z.EncBinary()
- _ = yym3571
- if false {
- } else {
- r.EncodeInt(int64(yy3570))
- }
- }
- }
- }
- if yyr3540 || yy2arr3540 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3540[9] {
- if x.LimitBytes == nil {
- r.EncodeNil()
- } else {
- yy3573 := *x.LimitBytes
+ yy3573 := *x.TailLines
yym3574 := z.EncBinary()
_ = yym3574
if false {
@@ -45307,14 +45336,14 @@ func (x *PodLogOptions) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeNil()
}
} else {
- if yyq3540[9] {
+ if yyq3545[8] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("limitBytes"))
+ r.EncodeString(codecSelferC_UTF81234, string("tailLines"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- if x.LimitBytes == nil {
+ if x.TailLines == nil {
r.EncodeNil()
} else {
- yy3575 := *x.LimitBytes
+ yy3575 := *x.TailLines
yym3576 := z.EncBinary()
_ = yym3576
if false {
@@ -45324,7 +45353,42 @@ func (x *PodLogOptions) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
- if yyr3540 || yy2arr3540 {
+ if yyr3545 || yy2arr3545 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq3545[9] {
+ if x.LimitBytes == nil {
+ r.EncodeNil()
+ } else {
+ yy3578 := *x.LimitBytes
+ yym3579 := z.EncBinary()
+ _ = yym3579
+ if false {
+ } else {
+ r.EncodeInt(int64(yy3578))
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq3545[9] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("limitBytes"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.LimitBytes == nil {
+ r.EncodeNil()
+ } else {
+ yy3580 := *x.LimitBytes
+ yym3581 := z.EncBinary()
+ _ = yym3581
+ if false {
+ } else {
+ r.EncodeInt(int64(yy3580))
+ }
+ }
+ }
+ }
+ if yyr3545 || yy2arr3545 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -45337,25 +45401,25 @@ func (x *PodLogOptions) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym3577 := z.DecBinary()
- _ = yym3577
+ yym3582 := z.DecBinary()
+ _ = yym3582
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct3578 := r.ContainerType()
- if yyct3578 == codecSelferValueTypeMap1234 {
- yyl3578 := r.ReadMapStart()
- if yyl3578 == 0 {
+ yyct3583 := r.ContainerType()
+ if yyct3583 == codecSelferValueTypeMap1234 {
+ yyl3583 := r.ReadMapStart()
+ if yyl3583 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl3578, d)
+ x.codecDecodeSelfFromMap(yyl3583, d)
}
- } else if yyct3578 == codecSelferValueTypeArray1234 {
- yyl3578 := r.ReadArrayStart()
- if yyl3578 == 0 {
+ } else if yyct3583 == codecSelferValueTypeArray1234 {
+ yyl3583 := r.ReadArrayStart()
+ if yyl3583 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl3578, d)
+ x.codecDecodeSelfFromArray(yyl3583, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -45367,12 +45431,12 @@ func (x *PodLogOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys3579Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys3579Slc
- var yyhl3579 bool = l >= 0
- for yyj3579 := 0; ; yyj3579++ {
- if yyhl3579 {
- if yyj3579 >= l {
+ var yys3584Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3584Slc
+ var yyhl3584 bool = l >= 0
+ for yyj3584 := 0; ; yyj3584++ {
+ if yyhl3584 {
+ if yyj3584 >= l {
break
}
} else {
@@ -45381,10 +45445,10 @@ func (x *PodLogOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys3579Slc = r.DecodeBytes(yys3579Slc, true, true)
- yys3579 := string(yys3579Slc)
+ yys3584Slc = r.DecodeBytes(yys3584Slc, true, true)
+ yys3584 := string(yys3584Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys3579 {
+ switch yys3584 {
case "kind":
if r.TryDecodeAsNil() {
x.Kind = ""
@@ -45424,8 +45488,8 @@ func (x *PodLogOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
if x.SinceSeconds == nil {
x.SinceSeconds = new(int64)
}
- yym3586 := z.DecBinary()
- _ = yym3586
+ yym3591 := z.DecBinary()
+ _ = yym3591
if false {
} else {
*((*int64)(x.SinceSeconds)) = int64(r.DecodeInt(64))
@@ -45440,13 +45504,13 @@ func (x *PodLogOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
if x.SinceTime == nil {
x.SinceTime = new(pkg2_v1.Time)
}
- yym3588 := z.DecBinary()
- _ = yym3588
+ yym3593 := z.DecBinary()
+ _ = yym3593
if false {
} else if z.HasExtensions() && z.DecExt(x.SinceTime) {
- } else if yym3588 {
+ } else if yym3593 {
z.DecBinaryUnmarshal(x.SinceTime)
- } else if !yym3588 && z.IsJSONHandle() {
+ } else if !yym3593 && z.IsJSONHandle() {
z.DecJSONUnmarshal(x.SinceTime)
} else {
z.DecFallback(x.SinceTime, false)
@@ -45467,8 +45531,8 @@ func (x *PodLogOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
if x.TailLines == nil {
x.TailLines = new(int64)
}
- yym3591 := z.DecBinary()
- _ = yym3591
+ yym3596 := z.DecBinary()
+ _ = yym3596
if false {
} else {
*((*int64)(x.TailLines)) = int64(r.DecodeInt(64))
@@ -45483,17 +45547,17 @@ func (x *PodLogOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
if x.LimitBytes == nil {
x.LimitBytes = new(int64)
}
- yym3593 := z.DecBinary()
- _ = yym3593
+ yym3598 := z.DecBinary()
+ _ = yym3598
if false {
} else {
*((*int64)(x.LimitBytes)) = int64(r.DecodeInt(64))
}
}
default:
- z.DecStructFieldNotFound(-1, yys3579)
- } // end switch yys3579
- } // end for yyj3579
+ z.DecStructFieldNotFound(-1, yys3584)
+ } // end switch yys3584
+ } // end for yyj3584
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -45501,16 +45565,16 @@ func (x *PodLogOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj3594 int
- var yyb3594 bool
- var yyhl3594 bool = l >= 0
- yyj3594++
- if yyhl3594 {
- yyb3594 = yyj3594 > l
+ var yyj3599 int
+ var yyb3599 bool
+ var yyhl3599 bool = l >= 0
+ yyj3599++
+ if yyhl3599 {
+ yyb3599 = yyj3599 > l
} else {
- yyb3594 = r.CheckBreak()
+ yyb3599 = r.CheckBreak()
}
- if yyb3594 {
+ if yyb3599 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -45520,13 +45584,13 @@ func (x *PodLogOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Kind = string(r.DecodeString())
}
- yyj3594++
- if yyhl3594 {
- yyb3594 = yyj3594 > l
+ yyj3599++
+ if yyhl3599 {
+ yyb3599 = yyj3599 > l
} else {
- yyb3594 = r.CheckBreak()
+ yyb3599 = r.CheckBreak()
}
- if yyb3594 {
+ if yyb3599 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -45536,13 +45600,13 @@ func (x *PodLogOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.APIVersion = string(r.DecodeString())
}
- yyj3594++
- if yyhl3594 {
- yyb3594 = yyj3594 > l
+ yyj3599++
+ if yyhl3599 {
+ yyb3599 = yyj3599 > l
} else {
- yyb3594 = r.CheckBreak()
+ yyb3599 = r.CheckBreak()
}
- if yyb3594 {
+ if yyb3599 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -45552,13 +45616,13 @@ func (x *PodLogOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Container = string(r.DecodeString())
}
- yyj3594++
- if yyhl3594 {
- yyb3594 = yyj3594 > l
+ yyj3599++
+ if yyhl3599 {
+ yyb3599 = yyj3599 > l
} else {
- yyb3594 = r.CheckBreak()
+ yyb3599 = r.CheckBreak()
}
- if yyb3594 {
+ if yyb3599 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -45568,13 +45632,13 @@ func (x *PodLogOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Follow = bool(r.DecodeBool())
}
- yyj3594++
- if yyhl3594 {
- yyb3594 = yyj3594 > l
+ yyj3599++
+ if yyhl3599 {
+ yyb3599 = yyj3599 > l
} else {
- yyb3594 = r.CheckBreak()
+ yyb3599 = r.CheckBreak()
}
- if yyb3594 {
+ if yyb3599 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -45584,13 +45648,13 @@ func (x *PodLogOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Previous = bool(r.DecodeBool())
}
- yyj3594++
- if yyhl3594 {
- yyb3594 = yyj3594 > l
+ yyj3599++
+ if yyhl3599 {
+ yyb3599 = yyj3599 > l
} else {
- yyb3594 = r.CheckBreak()
+ yyb3599 = r.CheckBreak()
}
- if yyb3594 {
+ if yyb3599 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -45603,20 +45667,20 @@ func (x *PodLogOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if x.SinceSeconds == nil {
x.SinceSeconds = new(int64)
}
- yym3601 := z.DecBinary()
- _ = yym3601
+ yym3606 := z.DecBinary()
+ _ = yym3606
if false {
} else {
*((*int64)(x.SinceSeconds)) = int64(r.DecodeInt(64))
}
}
- yyj3594++
- if yyhl3594 {
- yyb3594 = yyj3594 > l
+ yyj3599++
+ if yyhl3599 {
+ yyb3599 = yyj3599 > l
} else {
- yyb3594 = r.CheckBreak()
+ yyb3599 = r.CheckBreak()
}
- if yyb3594 {
+ if yyb3599 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -45629,25 +45693,25 @@ func (x *PodLogOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if x.SinceTime == nil {
x.SinceTime = new(pkg2_v1.Time)
}
- yym3603 := z.DecBinary()
- _ = yym3603
+ yym3608 := z.DecBinary()
+ _ = yym3608
if false {
} else if z.HasExtensions() && z.DecExt(x.SinceTime) {
- } else if yym3603 {
+ } else if yym3608 {
z.DecBinaryUnmarshal(x.SinceTime)
- } else if !yym3603 && z.IsJSONHandle() {
+ } else if !yym3608 && z.IsJSONHandle() {
z.DecJSONUnmarshal(x.SinceTime)
} else {
z.DecFallback(x.SinceTime, false)
}
}
- yyj3594++
- if yyhl3594 {
- yyb3594 = yyj3594 > l
+ yyj3599++
+ if yyhl3599 {
+ yyb3599 = yyj3599 > l
} else {
- yyb3594 = r.CheckBreak()
+ yyb3599 = r.CheckBreak()
}
- if yyb3594 {
+ if yyb3599 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -45657,13 +45721,13 @@ func (x *PodLogOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Timestamps = bool(r.DecodeBool())
}
- yyj3594++
- if yyhl3594 {
- yyb3594 = yyj3594 > l
+ yyj3599++
+ if yyhl3599 {
+ yyb3599 = yyj3599 > l
} else {
- yyb3594 = r.CheckBreak()
+ yyb3599 = r.CheckBreak()
}
- if yyb3594 {
+ if yyb3599 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -45676,20 +45740,20 @@ func (x *PodLogOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if x.TailLines == nil {
x.TailLines = new(int64)
}
- yym3606 := z.DecBinary()
- _ = yym3606
+ yym3611 := z.DecBinary()
+ _ = yym3611
if false {
} else {
*((*int64)(x.TailLines)) = int64(r.DecodeInt(64))
}
}
- yyj3594++
- if yyhl3594 {
- yyb3594 = yyj3594 > l
+ yyj3599++
+ if yyhl3599 {
+ yyb3599 = yyj3599 > l
} else {
- yyb3594 = r.CheckBreak()
+ yyb3599 = r.CheckBreak()
}
- if yyb3594 {
+ if yyb3599 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -45702,25 +45766,25 @@ func (x *PodLogOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if x.LimitBytes == nil {
x.LimitBytes = new(int64)
}
- yym3608 := z.DecBinary()
- _ = yym3608
+ yym3613 := z.DecBinary()
+ _ = yym3613
if false {
} else {
*((*int64)(x.LimitBytes)) = int64(r.DecodeInt(64))
}
}
for {
- yyj3594++
- if yyhl3594 {
- yyb3594 = yyj3594 > l
+ yyj3599++
+ if yyhl3599 {
+ yyb3599 = yyj3599 > l
} else {
- yyb3594 = r.CheckBreak()
+ yyb3599 = r.CheckBreak()
}
- if yyb3594 {
+ if yyb3599 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj3594-1, "")
+ z.DecStructFieldNotFound(yyj3599-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -45732,41 +45796,41 @@ func (x *PodAttachOptions) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym3609 := z.EncBinary()
- _ = yym3609
+ yym3614 := z.EncBinary()
+ _ = yym3614
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep3610 := !z.EncBinary()
- yy2arr3610 := z.EncBasicHandle().StructToArray
- var yyq3610 [7]bool
- _, _, _ = yysep3610, yyq3610, yy2arr3610
- const yyr3610 bool = false
- yyq3610[0] = x.Kind != ""
- yyq3610[1] = x.APIVersion != ""
- yyq3610[2] = x.Stdin != false
- yyq3610[3] = x.Stdout != false
- yyq3610[4] = x.Stderr != false
- yyq3610[5] = x.TTY != false
- yyq3610[6] = x.Container != ""
- var yynn3610 int
- if yyr3610 || yy2arr3610 {
+ yysep3615 := !z.EncBinary()
+ yy2arr3615 := z.EncBasicHandle().StructToArray
+ var yyq3615 [7]bool
+ _, _, _ = yysep3615, yyq3615, yy2arr3615
+ const yyr3615 bool = false
+ yyq3615[0] = x.Kind != ""
+ yyq3615[1] = x.APIVersion != ""
+ yyq3615[2] = x.Stdin != false
+ yyq3615[3] = x.Stdout != false
+ yyq3615[4] = x.Stderr != false
+ yyq3615[5] = x.TTY != false
+ yyq3615[6] = x.Container != ""
+ var yynn3615 int
+ if yyr3615 || yy2arr3615 {
r.EncodeArrayStart(7)
} else {
- yynn3610 = 0
- for _, b := range yyq3610 {
+ yynn3615 = 0
+ for _, b := range yyq3615 {
if b {
- yynn3610++
+ yynn3615++
}
}
- r.EncodeMapStart(yynn3610)
- yynn3610 = 0
+ r.EncodeMapStart(yynn3615)
+ yynn3615 = 0
}
- if yyr3610 || yy2arr3610 {
+ if yyr3615 || yy2arr3615 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3610[0] {
- yym3612 := z.EncBinary()
- _ = yym3612
+ if yyq3615[0] {
+ yym3617 := z.EncBinary()
+ _ = yym3617
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
@@ -45775,124 +45839,124 @@ func (x *PodAttachOptions) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq3610[0] {
+ if yyq3615[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("kind"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3613 := z.EncBinary()
- _ = yym3613
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
- }
- }
- }
- if yyr3610 || yy2arr3610 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3610[1] {
- yym3615 := z.EncBinary()
- _ = yym3615
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
- }
- } else {
- r.EncodeString(codecSelferC_UTF81234, "")
- }
- } else {
- if yyq3610[1] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3616 := z.EncBinary()
- _ = yym3616
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
- }
- }
- }
- if yyr3610 || yy2arr3610 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3610[2] {
yym3618 := z.EncBinary()
_ = yym3618
if false {
} else {
- r.EncodeBool(bool(x.Stdin))
- }
- } else {
- r.EncodeBool(false)
- }
- } else {
- if yyq3610[2] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("stdin"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3619 := z.EncBinary()
- _ = yym3619
- if false {
- } else {
- r.EncodeBool(bool(x.Stdin))
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
}
}
}
- if yyr3610 || yy2arr3610 {
+ if yyr3615 || yy2arr3615 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3610[3] {
+ if yyq3615[1] {
+ yym3620 := z.EncBinary()
+ _ = yym3620
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq3615[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
yym3621 := z.EncBinary()
_ = yym3621
if false {
} else {
- r.EncodeBool(bool(x.Stdout))
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ }
+ }
+ if yyr3615 || yy2arr3615 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq3615[2] {
+ yym3623 := z.EncBinary()
+ _ = yym3623
+ if false {
+ } else {
+ r.EncodeBool(bool(x.Stdin))
}
} else {
r.EncodeBool(false)
}
} else {
- if yyq3610[3] {
+ if yyq3615[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("stdout"))
+ r.EncodeString(codecSelferC_UTF81234, string("stdin"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3622 := z.EncBinary()
- _ = yym3622
- if false {
- } else {
- r.EncodeBool(bool(x.Stdout))
- }
- }
- }
- if yyr3610 || yy2arr3610 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3610[4] {
yym3624 := z.EncBinary()
_ = yym3624
if false {
} else {
- r.EncodeBool(bool(x.Stderr))
+ r.EncodeBool(bool(x.Stdin))
+ }
+ }
+ }
+ if yyr3615 || yy2arr3615 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq3615[3] {
+ yym3626 := z.EncBinary()
+ _ = yym3626
+ if false {
+ } else {
+ r.EncodeBool(bool(x.Stdout))
}
} else {
r.EncodeBool(false)
}
} else {
- if yyq3610[4] {
+ if yyq3615[3] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("stderr"))
+ r.EncodeString(codecSelferC_UTF81234, string("stdout"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3625 := z.EncBinary()
- _ = yym3625
- if false {
- } else {
- r.EncodeBool(bool(x.Stderr))
- }
- }
- }
- if yyr3610 || yy2arr3610 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3610[5] {
yym3627 := z.EncBinary()
_ = yym3627
if false {
+ } else {
+ r.EncodeBool(bool(x.Stdout))
+ }
+ }
+ }
+ if yyr3615 || yy2arr3615 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq3615[4] {
+ yym3629 := z.EncBinary()
+ _ = yym3629
+ if false {
+ } else {
+ r.EncodeBool(bool(x.Stderr))
+ }
+ } else {
+ r.EncodeBool(false)
+ }
+ } else {
+ if yyq3615[4] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("stderr"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym3630 := z.EncBinary()
+ _ = yym3630
+ if false {
+ } else {
+ r.EncodeBool(bool(x.Stderr))
+ }
+ }
+ }
+ if yyr3615 || yy2arr3615 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq3615[5] {
+ yym3632 := z.EncBinary()
+ _ = yym3632
+ if false {
} else {
r.EncodeBool(bool(x.TTY))
}
@@ -45900,23 +45964,23 @@ func (x *PodAttachOptions) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeBool(false)
}
} else {
- if yyq3610[5] {
+ if yyq3615[5] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("tty"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3628 := z.EncBinary()
- _ = yym3628
+ yym3633 := z.EncBinary()
+ _ = yym3633
if false {
} else {
r.EncodeBool(bool(x.TTY))
}
}
}
- if yyr3610 || yy2arr3610 {
+ if yyr3615 || yy2arr3615 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3610[6] {
- yym3630 := z.EncBinary()
- _ = yym3630
+ if yyq3615[6] {
+ yym3635 := z.EncBinary()
+ _ = yym3635
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Container))
@@ -45925,19 +45989,19 @@ func (x *PodAttachOptions) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq3610[6] {
+ if yyq3615[6] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("container"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3631 := z.EncBinary()
- _ = yym3631
+ yym3636 := z.EncBinary()
+ _ = yym3636
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Container))
}
}
}
- if yyr3610 || yy2arr3610 {
+ if yyr3615 || yy2arr3615 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -45950,25 +46014,25 @@ func (x *PodAttachOptions) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym3632 := z.DecBinary()
- _ = yym3632
+ yym3637 := z.DecBinary()
+ _ = yym3637
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct3633 := r.ContainerType()
- if yyct3633 == codecSelferValueTypeMap1234 {
- yyl3633 := r.ReadMapStart()
- if yyl3633 == 0 {
+ yyct3638 := r.ContainerType()
+ if yyct3638 == codecSelferValueTypeMap1234 {
+ yyl3638 := r.ReadMapStart()
+ if yyl3638 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl3633, d)
+ x.codecDecodeSelfFromMap(yyl3638, d)
}
- } else if yyct3633 == codecSelferValueTypeArray1234 {
- yyl3633 := r.ReadArrayStart()
- if yyl3633 == 0 {
+ } else if yyct3638 == codecSelferValueTypeArray1234 {
+ yyl3638 := r.ReadArrayStart()
+ if yyl3638 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl3633, d)
+ x.codecDecodeSelfFromArray(yyl3638, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -45980,12 +46044,12 @@ func (x *PodAttachOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys3634Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys3634Slc
- var yyhl3634 bool = l >= 0
- for yyj3634 := 0; ; yyj3634++ {
- if yyhl3634 {
- if yyj3634 >= l {
+ var yys3639Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3639Slc
+ var yyhl3639 bool = l >= 0
+ for yyj3639 := 0; ; yyj3639++ {
+ if yyhl3639 {
+ if yyj3639 >= l {
break
}
} else {
@@ -45994,10 +46058,10 @@ func (x *PodAttachOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys3634Slc = r.DecodeBytes(yys3634Slc, true, true)
- yys3634 := string(yys3634Slc)
+ yys3639Slc = r.DecodeBytes(yys3639Slc, true, true)
+ yys3639 := string(yys3639Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys3634 {
+ switch yys3639 {
case "kind":
if r.TryDecodeAsNil() {
x.Kind = ""
@@ -46041,9 +46105,9 @@ func (x *PodAttachOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
x.Container = string(r.DecodeString())
}
default:
- z.DecStructFieldNotFound(-1, yys3634)
- } // end switch yys3634
- } // end for yyj3634
+ z.DecStructFieldNotFound(-1, yys3639)
+ } // end switch yys3639
+ } // end for yyj3639
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -46051,16 +46115,16 @@ func (x *PodAttachOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj3642 int
- var yyb3642 bool
- var yyhl3642 bool = l >= 0
- yyj3642++
- if yyhl3642 {
- yyb3642 = yyj3642 > l
+ var yyj3647 int
+ var yyb3647 bool
+ var yyhl3647 bool = l >= 0
+ yyj3647++
+ if yyhl3647 {
+ yyb3647 = yyj3647 > l
} else {
- yyb3642 = r.CheckBreak()
+ yyb3647 = r.CheckBreak()
}
- if yyb3642 {
+ if yyb3647 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -46070,13 +46134,13 @@ func (x *PodAttachOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
} else {
x.Kind = string(r.DecodeString())
}
- yyj3642++
- if yyhl3642 {
- yyb3642 = yyj3642 > l
+ yyj3647++
+ if yyhl3647 {
+ yyb3647 = yyj3647 > l
} else {
- yyb3642 = r.CheckBreak()
+ yyb3647 = r.CheckBreak()
}
- if yyb3642 {
+ if yyb3647 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -46086,13 +46150,13 @@ func (x *PodAttachOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
} else {
x.APIVersion = string(r.DecodeString())
}
- yyj3642++
- if yyhl3642 {
- yyb3642 = yyj3642 > l
+ yyj3647++
+ if yyhl3647 {
+ yyb3647 = yyj3647 > l
} else {
- yyb3642 = r.CheckBreak()
+ yyb3647 = r.CheckBreak()
}
- if yyb3642 {
+ if yyb3647 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -46102,13 +46166,13 @@ func (x *PodAttachOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
} else {
x.Stdin = bool(r.DecodeBool())
}
- yyj3642++
- if yyhl3642 {
- yyb3642 = yyj3642 > l
+ yyj3647++
+ if yyhl3647 {
+ yyb3647 = yyj3647 > l
} else {
- yyb3642 = r.CheckBreak()
+ yyb3647 = r.CheckBreak()
}
- if yyb3642 {
+ if yyb3647 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -46118,13 +46182,13 @@ func (x *PodAttachOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
} else {
x.Stdout = bool(r.DecodeBool())
}
- yyj3642++
- if yyhl3642 {
- yyb3642 = yyj3642 > l
+ yyj3647++
+ if yyhl3647 {
+ yyb3647 = yyj3647 > l
} else {
- yyb3642 = r.CheckBreak()
+ yyb3647 = r.CheckBreak()
}
- if yyb3642 {
+ if yyb3647 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -46134,13 +46198,13 @@ func (x *PodAttachOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
} else {
x.Stderr = bool(r.DecodeBool())
}
- yyj3642++
- if yyhl3642 {
- yyb3642 = yyj3642 > l
+ yyj3647++
+ if yyhl3647 {
+ yyb3647 = yyj3647 > l
} else {
- yyb3642 = r.CheckBreak()
+ yyb3647 = r.CheckBreak()
}
- if yyb3642 {
+ if yyb3647 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -46150,13 +46214,13 @@ func (x *PodAttachOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
} else {
x.TTY = bool(r.DecodeBool())
}
- yyj3642++
- if yyhl3642 {
- yyb3642 = yyj3642 > l
+ yyj3647++
+ if yyhl3647 {
+ yyb3647 = yyj3647 > l
} else {
- yyb3642 = r.CheckBreak()
+ yyb3647 = r.CheckBreak()
}
- if yyb3642 {
+ if yyb3647 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -46167,17 +46231,17 @@ func (x *PodAttachOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
x.Container = string(r.DecodeString())
}
for {
- yyj3642++
- if yyhl3642 {
- yyb3642 = yyj3642 > l
+ yyj3647++
+ if yyhl3647 {
+ yyb3647 = yyj3647 > l
} else {
- yyb3642 = r.CheckBreak()
+ yyb3647 = r.CheckBreak()
}
- if yyb3642 {
+ if yyb3647 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj3642-1, "")
+ z.DecStructFieldNotFound(yyj3647-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -46189,41 +46253,41 @@ func (x *PodExecOptions) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym3650 := z.EncBinary()
- _ = yym3650
+ yym3655 := z.EncBinary()
+ _ = yym3655
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep3651 := !z.EncBinary()
- yy2arr3651 := z.EncBasicHandle().StructToArray
- var yyq3651 [8]bool
- _, _, _ = yysep3651, yyq3651, yy2arr3651
- const yyr3651 bool = false
- yyq3651[0] = x.Kind != ""
- yyq3651[1] = x.APIVersion != ""
- yyq3651[2] = x.Stdin != false
- yyq3651[3] = x.Stdout != false
- yyq3651[4] = x.Stderr != false
- yyq3651[5] = x.TTY != false
- yyq3651[6] = x.Container != ""
- var yynn3651 int
- if yyr3651 || yy2arr3651 {
+ yysep3656 := !z.EncBinary()
+ yy2arr3656 := z.EncBasicHandle().StructToArray
+ var yyq3656 [8]bool
+ _, _, _ = yysep3656, yyq3656, yy2arr3656
+ const yyr3656 bool = false
+ yyq3656[0] = x.Kind != ""
+ yyq3656[1] = x.APIVersion != ""
+ yyq3656[2] = x.Stdin != false
+ yyq3656[3] = x.Stdout != false
+ yyq3656[4] = x.Stderr != false
+ yyq3656[5] = x.TTY != false
+ yyq3656[6] = x.Container != ""
+ var yynn3656 int
+ if yyr3656 || yy2arr3656 {
r.EncodeArrayStart(8)
} else {
- yynn3651 = 1
- for _, b := range yyq3651 {
+ yynn3656 = 1
+ for _, b := range yyq3656 {
if b {
- yynn3651++
+ yynn3656++
}
}
- r.EncodeMapStart(yynn3651)
- yynn3651 = 0
+ r.EncodeMapStart(yynn3656)
+ yynn3656 = 0
}
- if yyr3651 || yy2arr3651 {
+ if yyr3656 || yy2arr3656 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3651[0] {
- yym3653 := z.EncBinary()
- _ = yym3653
+ if yyq3656[0] {
+ yym3658 := z.EncBinary()
+ _ = yym3658
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
@@ -46232,124 +46296,124 @@ func (x *PodExecOptions) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq3651[0] {
+ if yyq3656[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("kind"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3654 := z.EncBinary()
- _ = yym3654
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
- }
- }
- }
- if yyr3651 || yy2arr3651 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3651[1] {
- yym3656 := z.EncBinary()
- _ = yym3656
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
- }
- } else {
- r.EncodeString(codecSelferC_UTF81234, "")
- }
- } else {
- if yyq3651[1] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3657 := z.EncBinary()
- _ = yym3657
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
- }
- }
- }
- if yyr3651 || yy2arr3651 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3651[2] {
yym3659 := z.EncBinary()
_ = yym3659
if false {
} else {
- r.EncodeBool(bool(x.Stdin))
- }
- } else {
- r.EncodeBool(false)
- }
- } else {
- if yyq3651[2] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("stdin"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3660 := z.EncBinary()
- _ = yym3660
- if false {
- } else {
- r.EncodeBool(bool(x.Stdin))
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
}
}
}
- if yyr3651 || yy2arr3651 {
+ if yyr3656 || yy2arr3656 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3651[3] {
+ if yyq3656[1] {
+ yym3661 := z.EncBinary()
+ _ = yym3661
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq3656[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
yym3662 := z.EncBinary()
_ = yym3662
if false {
} else {
- r.EncodeBool(bool(x.Stdout))
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ }
+ }
+ if yyr3656 || yy2arr3656 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq3656[2] {
+ yym3664 := z.EncBinary()
+ _ = yym3664
+ if false {
+ } else {
+ r.EncodeBool(bool(x.Stdin))
}
} else {
r.EncodeBool(false)
}
} else {
- if yyq3651[3] {
+ if yyq3656[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("stdout"))
+ r.EncodeString(codecSelferC_UTF81234, string("stdin"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3663 := z.EncBinary()
- _ = yym3663
- if false {
- } else {
- r.EncodeBool(bool(x.Stdout))
- }
- }
- }
- if yyr3651 || yy2arr3651 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3651[4] {
yym3665 := z.EncBinary()
_ = yym3665
if false {
} else {
- r.EncodeBool(bool(x.Stderr))
+ r.EncodeBool(bool(x.Stdin))
+ }
+ }
+ }
+ if yyr3656 || yy2arr3656 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq3656[3] {
+ yym3667 := z.EncBinary()
+ _ = yym3667
+ if false {
+ } else {
+ r.EncodeBool(bool(x.Stdout))
}
} else {
r.EncodeBool(false)
}
} else {
- if yyq3651[4] {
+ if yyq3656[3] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("stderr"))
+ r.EncodeString(codecSelferC_UTF81234, string("stdout"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3666 := z.EncBinary()
- _ = yym3666
- if false {
- } else {
- r.EncodeBool(bool(x.Stderr))
- }
- }
- }
- if yyr3651 || yy2arr3651 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3651[5] {
yym3668 := z.EncBinary()
_ = yym3668
if false {
+ } else {
+ r.EncodeBool(bool(x.Stdout))
+ }
+ }
+ }
+ if yyr3656 || yy2arr3656 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq3656[4] {
+ yym3670 := z.EncBinary()
+ _ = yym3670
+ if false {
+ } else {
+ r.EncodeBool(bool(x.Stderr))
+ }
+ } else {
+ r.EncodeBool(false)
+ }
+ } else {
+ if yyq3656[4] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("stderr"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym3671 := z.EncBinary()
+ _ = yym3671
+ if false {
+ } else {
+ r.EncodeBool(bool(x.Stderr))
+ }
+ }
+ }
+ if yyr3656 || yy2arr3656 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq3656[5] {
+ yym3673 := z.EncBinary()
+ _ = yym3673
+ if false {
} else {
r.EncodeBool(bool(x.TTY))
}
@@ -46357,23 +46421,23 @@ func (x *PodExecOptions) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeBool(false)
}
} else {
- if yyq3651[5] {
+ if yyq3656[5] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("tty"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3669 := z.EncBinary()
- _ = yym3669
+ yym3674 := z.EncBinary()
+ _ = yym3674
if false {
} else {
r.EncodeBool(bool(x.TTY))
}
}
}
- if yyr3651 || yy2arr3651 {
+ if yyr3656 || yy2arr3656 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3651[6] {
- yym3671 := z.EncBinary()
- _ = yym3671
+ if yyq3656[6] {
+ yym3676 := z.EncBinary()
+ _ = yym3676
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Container))
@@ -46382,25 +46446,25 @@ func (x *PodExecOptions) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq3651[6] {
+ if yyq3656[6] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("container"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3672 := z.EncBinary()
- _ = yym3672
+ yym3677 := z.EncBinary()
+ _ = yym3677
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Container))
}
}
}
- if yyr3651 || yy2arr3651 {
+ if yyr3656 || yy2arr3656 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if x.Command == nil {
r.EncodeNil()
} else {
- yym3674 := z.EncBinary()
- _ = yym3674
+ yym3679 := z.EncBinary()
+ _ = yym3679
if false {
} else {
z.F.EncSliceStringV(x.Command, false, e)
@@ -46413,15 +46477,15 @@ func (x *PodExecOptions) CodecEncodeSelf(e *codec1978.Encoder) {
if x.Command == nil {
r.EncodeNil()
} else {
- yym3675 := z.EncBinary()
- _ = yym3675
+ yym3680 := z.EncBinary()
+ _ = yym3680
if false {
} else {
z.F.EncSliceStringV(x.Command, false, e)
}
}
}
- if yyr3651 || yy2arr3651 {
+ if yyr3656 || yy2arr3656 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -46434,25 +46498,25 @@ func (x *PodExecOptions) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym3676 := z.DecBinary()
- _ = yym3676
+ yym3681 := z.DecBinary()
+ _ = yym3681
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct3677 := r.ContainerType()
- if yyct3677 == codecSelferValueTypeMap1234 {
- yyl3677 := r.ReadMapStart()
- if yyl3677 == 0 {
+ yyct3682 := r.ContainerType()
+ if yyct3682 == codecSelferValueTypeMap1234 {
+ yyl3682 := r.ReadMapStart()
+ if yyl3682 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl3677, d)
+ x.codecDecodeSelfFromMap(yyl3682, d)
}
- } else if yyct3677 == codecSelferValueTypeArray1234 {
- yyl3677 := r.ReadArrayStart()
- if yyl3677 == 0 {
+ } else if yyct3682 == codecSelferValueTypeArray1234 {
+ yyl3682 := r.ReadArrayStart()
+ if yyl3682 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl3677, d)
+ x.codecDecodeSelfFromArray(yyl3682, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -46464,12 +46528,12 @@ func (x *PodExecOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys3678Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys3678Slc
- var yyhl3678 bool = l >= 0
- for yyj3678 := 0; ; yyj3678++ {
- if yyhl3678 {
- if yyj3678 >= l {
+ var yys3683Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3683Slc
+ var yyhl3683 bool = l >= 0
+ for yyj3683 := 0; ; yyj3683++ {
+ if yyhl3683 {
+ if yyj3683 >= l {
break
}
} else {
@@ -46478,10 +46542,10 @@ func (x *PodExecOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys3678Slc = r.DecodeBytes(yys3678Slc, true, true)
- yys3678 := string(yys3678Slc)
+ yys3683Slc = r.DecodeBytes(yys3683Slc, true, true)
+ yys3683 := string(yys3683Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys3678 {
+ switch yys3683 {
case "kind":
if r.TryDecodeAsNil() {
x.Kind = ""
@@ -46528,18 +46592,18 @@ func (x *PodExecOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Command = nil
} else {
- yyv3686 := &x.Command
- yym3687 := z.DecBinary()
- _ = yym3687
+ yyv3691 := &x.Command
+ yym3692 := z.DecBinary()
+ _ = yym3692
if false {
} else {
- z.F.DecSliceStringX(yyv3686, false, d)
+ z.F.DecSliceStringX(yyv3691, false, d)
}
}
default:
- z.DecStructFieldNotFound(-1, yys3678)
- } // end switch yys3678
- } // end for yyj3678
+ z.DecStructFieldNotFound(-1, yys3683)
+ } // end switch yys3683
+ } // end for yyj3683
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -46547,16 +46611,16 @@ func (x *PodExecOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj3688 int
- var yyb3688 bool
- var yyhl3688 bool = l >= 0
- yyj3688++
- if yyhl3688 {
- yyb3688 = yyj3688 > l
+ var yyj3693 int
+ var yyb3693 bool
+ var yyhl3693 bool = l >= 0
+ yyj3693++
+ if yyhl3693 {
+ yyb3693 = yyj3693 > l
} else {
- yyb3688 = r.CheckBreak()
+ yyb3693 = r.CheckBreak()
}
- if yyb3688 {
+ if yyb3693 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -46566,13 +46630,13 @@ func (x *PodExecOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Kind = string(r.DecodeString())
}
- yyj3688++
- if yyhl3688 {
- yyb3688 = yyj3688 > l
+ yyj3693++
+ if yyhl3693 {
+ yyb3693 = yyj3693 > l
} else {
- yyb3688 = r.CheckBreak()
+ yyb3693 = r.CheckBreak()
}
- if yyb3688 {
+ if yyb3693 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -46582,13 +46646,13 @@ func (x *PodExecOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.APIVersion = string(r.DecodeString())
}
- yyj3688++
- if yyhl3688 {
- yyb3688 = yyj3688 > l
+ yyj3693++
+ if yyhl3693 {
+ yyb3693 = yyj3693 > l
} else {
- yyb3688 = r.CheckBreak()
+ yyb3693 = r.CheckBreak()
}
- if yyb3688 {
+ if yyb3693 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -46598,13 +46662,13 @@ func (x *PodExecOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Stdin = bool(r.DecodeBool())
}
- yyj3688++
- if yyhl3688 {
- yyb3688 = yyj3688 > l
+ yyj3693++
+ if yyhl3693 {
+ yyb3693 = yyj3693 > l
} else {
- yyb3688 = r.CheckBreak()
+ yyb3693 = r.CheckBreak()
}
- if yyb3688 {
+ if yyb3693 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -46614,13 +46678,13 @@ func (x *PodExecOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Stdout = bool(r.DecodeBool())
}
- yyj3688++
- if yyhl3688 {
- yyb3688 = yyj3688 > l
+ yyj3693++
+ if yyhl3693 {
+ yyb3693 = yyj3693 > l
} else {
- yyb3688 = r.CheckBreak()
+ yyb3693 = r.CheckBreak()
}
- if yyb3688 {
+ if yyb3693 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -46630,13 +46694,13 @@ func (x *PodExecOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Stderr = bool(r.DecodeBool())
}
- yyj3688++
- if yyhl3688 {
- yyb3688 = yyj3688 > l
+ yyj3693++
+ if yyhl3693 {
+ yyb3693 = yyj3693 > l
} else {
- yyb3688 = r.CheckBreak()
+ yyb3693 = r.CheckBreak()
}
- if yyb3688 {
+ if yyb3693 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -46646,13 +46710,13 @@ func (x *PodExecOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.TTY = bool(r.DecodeBool())
}
- yyj3688++
- if yyhl3688 {
- yyb3688 = yyj3688 > l
+ yyj3693++
+ if yyhl3693 {
+ yyb3693 = yyj3693 > l
} else {
- yyb3688 = r.CheckBreak()
+ yyb3693 = r.CheckBreak()
}
- if yyb3688 {
+ if yyb3693 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -46662,13 +46726,13 @@ func (x *PodExecOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Container = string(r.DecodeString())
}
- yyj3688++
- if yyhl3688 {
- yyb3688 = yyj3688 > l
+ yyj3693++
+ if yyhl3693 {
+ yyb3693 = yyj3693 > l
} else {
- yyb3688 = r.CheckBreak()
+ yyb3693 = r.CheckBreak()
}
- if yyb3688 {
+ if yyb3693 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -46676,26 +46740,26 @@ func (x *PodExecOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Command = nil
} else {
- yyv3696 := &x.Command
- yym3697 := z.DecBinary()
- _ = yym3697
+ yyv3701 := &x.Command
+ yym3702 := z.DecBinary()
+ _ = yym3702
if false {
} else {
- z.F.DecSliceStringX(yyv3696, false, d)
+ z.F.DecSliceStringX(yyv3701, false, d)
}
}
for {
- yyj3688++
- if yyhl3688 {
- yyb3688 = yyj3688 > l
+ yyj3693++
+ if yyhl3693 {
+ yyb3693 = yyj3693 > l
} else {
- yyb3688 = r.CheckBreak()
+ yyb3693 = r.CheckBreak()
}
- if yyb3688 {
+ if yyb3693 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj3688-1, "")
+ z.DecStructFieldNotFound(yyj3693-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -46707,37 +46771,37 @@ func (x *PodProxyOptions) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym3698 := z.EncBinary()
- _ = yym3698
+ yym3703 := z.EncBinary()
+ _ = yym3703
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep3699 := !z.EncBinary()
- yy2arr3699 := z.EncBasicHandle().StructToArray
- var yyq3699 [3]bool
- _, _, _ = yysep3699, yyq3699, yy2arr3699
- const yyr3699 bool = false
- yyq3699[0] = x.Kind != ""
- yyq3699[1] = x.APIVersion != ""
- yyq3699[2] = x.Path != ""
- var yynn3699 int
- if yyr3699 || yy2arr3699 {
+ yysep3704 := !z.EncBinary()
+ yy2arr3704 := z.EncBasicHandle().StructToArray
+ var yyq3704 [3]bool
+ _, _, _ = yysep3704, yyq3704, yy2arr3704
+ const yyr3704 bool = false
+ yyq3704[0] = x.Kind != ""
+ yyq3704[1] = x.APIVersion != ""
+ yyq3704[2] = x.Path != ""
+ var yynn3704 int
+ if yyr3704 || yy2arr3704 {
r.EncodeArrayStart(3)
} else {
- yynn3699 = 0
- for _, b := range yyq3699 {
+ yynn3704 = 0
+ for _, b := range yyq3704 {
if b {
- yynn3699++
+ yynn3704++
}
}
- r.EncodeMapStart(yynn3699)
- yynn3699 = 0
+ r.EncodeMapStart(yynn3704)
+ yynn3704 = 0
}
- if yyr3699 || yy2arr3699 {
+ if yyr3704 || yy2arr3704 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3699[0] {
- yym3701 := z.EncBinary()
- _ = yym3701
+ if yyq3704[0] {
+ yym3706 := z.EncBinary()
+ _ = yym3706
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
@@ -46746,49 +46810,49 @@ func (x *PodProxyOptions) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq3699[0] {
+ if yyq3704[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("kind"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3702 := z.EncBinary()
- _ = yym3702
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
- }
- }
- }
- if yyr3699 || yy2arr3699 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3699[1] {
- yym3704 := z.EncBinary()
- _ = yym3704
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
- }
- } else {
- r.EncodeString(codecSelferC_UTF81234, "")
- }
- } else {
- if yyq3699[1] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3705 := z.EncBinary()
- _ = yym3705
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
- }
- }
- }
- if yyr3699 || yy2arr3699 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3699[2] {
yym3707 := z.EncBinary()
_ = yym3707
if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ }
+ }
+ if yyr3704 || yy2arr3704 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq3704[1] {
+ yym3709 := z.EncBinary()
+ _ = yym3709
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq3704[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym3710 := z.EncBinary()
+ _ = yym3710
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ }
+ }
+ if yyr3704 || yy2arr3704 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq3704[2] {
+ yym3712 := z.EncBinary()
+ _ = yym3712
+ if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Path))
}
@@ -46796,19 +46860,19 @@ func (x *PodProxyOptions) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq3699[2] {
+ if yyq3704[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("path"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3708 := z.EncBinary()
- _ = yym3708
+ yym3713 := z.EncBinary()
+ _ = yym3713
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Path))
}
}
}
- if yyr3699 || yy2arr3699 {
+ if yyr3704 || yy2arr3704 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -46821,25 +46885,25 @@ func (x *PodProxyOptions) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym3709 := z.DecBinary()
- _ = yym3709
+ yym3714 := z.DecBinary()
+ _ = yym3714
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct3710 := r.ContainerType()
- if yyct3710 == codecSelferValueTypeMap1234 {
- yyl3710 := r.ReadMapStart()
- if yyl3710 == 0 {
+ yyct3715 := r.ContainerType()
+ if yyct3715 == codecSelferValueTypeMap1234 {
+ yyl3715 := r.ReadMapStart()
+ if yyl3715 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl3710, d)
+ x.codecDecodeSelfFromMap(yyl3715, d)
}
- } else if yyct3710 == codecSelferValueTypeArray1234 {
- yyl3710 := r.ReadArrayStart()
- if yyl3710 == 0 {
+ } else if yyct3715 == codecSelferValueTypeArray1234 {
+ yyl3715 := r.ReadArrayStart()
+ if yyl3715 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl3710, d)
+ x.codecDecodeSelfFromArray(yyl3715, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -46851,12 +46915,12 @@ func (x *PodProxyOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys3711Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys3711Slc
- var yyhl3711 bool = l >= 0
- for yyj3711 := 0; ; yyj3711++ {
- if yyhl3711 {
- if yyj3711 >= l {
+ var yys3716Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3716Slc
+ var yyhl3716 bool = l >= 0
+ for yyj3716 := 0; ; yyj3716++ {
+ if yyhl3716 {
+ if yyj3716 >= l {
break
}
} else {
@@ -46865,10 +46929,10 @@ func (x *PodProxyOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys3711Slc = r.DecodeBytes(yys3711Slc, true, true)
- yys3711 := string(yys3711Slc)
+ yys3716Slc = r.DecodeBytes(yys3716Slc, true, true)
+ yys3716 := string(yys3716Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys3711 {
+ switch yys3716 {
case "kind":
if r.TryDecodeAsNil() {
x.Kind = ""
@@ -46888,9 +46952,9 @@ func (x *PodProxyOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
x.Path = string(r.DecodeString())
}
default:
- z.DecStructFieldNotFound(-1, yys3711)
- } // end switch yys3711
- } // end for yyj3711
+ z.DecStructFieldNotFound(-1, yys3716)
+ } // end switch yys3716
+ } // end for yyj3716
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -46898,16 +46962,16 @@ func (x *PodProxyOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj3715 int
- var yyb3715 bool
- var yyhl3715 bool = l >= 0
- yyj3715++
- if yyhl3715 {
- yyb3715 = yyj3715 > l
+ var yyj3720 int
+ var yyb3720 bool
+ var yyhl3720 bool = l >= 0
+ yyj3720++
+ if yyhl3720 {
+ yyb3720 = yyj3720 > l
} else {
- yyb3715 = r.CheckBreak()
+ yyb3720 = r.CheckBreak()
}
- if yyb3715 {
+ if yyb3720 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -46917,13 +46981,13 @@ func (x *PodProxyOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
} else {
x.Kind = string(r.DecodeString())
}
- yyj3715++
- if yyhl3715 {
- yyb3715 = yyj3715 > l
+ yyj3720++
+ if yyhl3720 {
+ yyb3720 = yyj3720 > l
} else {
- yyb3715 = r.CheckBreak()
+ yyb3720 = r.CheckBreak()
}
- if yyb3715 {
+ if yyb3720 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -46933,13 +46997,13 @@ func (x *PodProxyOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
} else {
x.APIVersion = string(r.DecodeString())
}
- yyj3715++
- if yyhl3715 {
- yyb3715 = yyj3715 > l
+ yyj3720++
+ if yyhl3720 {
+ yyb3720 = yyj3720 > l
} else {
- yyb3715 = r.CheckBreak()
+ yyb3720 = r.CheckBreak()
}
- if yyb3715 {
+ if yyb3720 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -46950,17 +47014,17 @@ func (x *PodProxyOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
x.Path = string(r.DecodeString())
}
for {
- yyj3715++
- if yyhl3715 {
- yyb3715 = yyj3715 > l
+ yyj3720++
+ if yyhl3720 {
+ yyb3720 = yyj3720 > l
} else {
- yyb3715 = r.CheckBreak()
+ yyb3720 = r.CheckBreak()
}
- if yyb3715 {
+ if yyb3720 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj3715-1, "")
+ z.DecStructFieldNotFound(yyj3720-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -46972,37 +47036,37 @@ func (x *NodeProxyOptions) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym3719 := z.EncBinary()
- _ = yym3719
+ yym3724 := z.EncBinary()
+ _ = yym3724
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep3720 := !z.EncBinary()
- yy2arr3720 := z.EncBasicHandle().StructToArray
- var yyq3720 [3]bool
- _, _, _ = yysep3720, yyq3720, yy2arr3720
- const yyr3720 bool = false
- yyq3720[0] = x.Kind != ""
- yyq3720[1] = x.APIVersion != ""
- yyq3720[2] = x.Path != ""
- var yynn3720 int
- if yyr3720 || yy2arr3720 {
+ yysep3725 := !z.EncBinary()
+ yy2arr3725 := z.EncBasicHandle().StructToArray
+ var yyq3725 [3]bool
+ _, _, _ = yysep3725, yyq3725, yy2arr3725
+ const yyr3725 bool = false
+ yyq3725[0] = x.Kind != ""
+ yyq3725[1] = x.APIVersion != ""
+ yyq3725[2] = x.Path != ""
+ var yynn3725 int
+ if yyr3725 || yy2arr3725 {
r.EncodeArrayStart(3)
} else {
- yynn3720 = 0
- for _, b := range yyq3720 {
+ yynn3725 = 0
+ for _, b := range yyq3725 {
if b {
- yynn3720++
+ yynn3725++
}
}
- r.EncodeMapStart(yynn3720)
- yynn3720 = 0
+ r.EncodeMapStart(yynn3725)
+ yynn3725 = 0
}
- if yyr3720 || yy2arr3720 {
+ if yyr3725 || yy2arr3725 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3720[0] {
- yym3722 := z.EncBinary()
- _ = yym3722
+ if yyq3725[0] {
+ yym3727 := z.EncBinary()
+ _ = yym3727
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
@@ -47011,49 +47075,49 @@ func (x *NodeProxyOptions) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq3720[0] {
+ if yyq3725[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("kind"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3723 := z.EncBinary()
- _ = yym3723
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
- }
- }
- }
- if yyr3720 || yy2arr3720 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3720[1] {
- yym3725 := z.EncBinary()
- _ = yym3725
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
- }
- } else {
- r.EncodeString(codecSelferC_UTF81234, "")
- }
- } else {
- if yyq3720[1] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3726 := z.EncBinary()
- _ = yym3726
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
- }
- }
- }
- if yyr3720 || yy2arr3720 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3720[2] {
yym3728 := z.EncBinary()
_ = yym3728
if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ }
+ }
+ if yyr3725 || yy2arr3725 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq3725[1] {
+ yym3730 := z.EncBinary()
+ _ = yym3730
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq3725[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym3731 := z.EncBinary()
+ _ = yym3731
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ }
+ }
+ if yyr3725 || yy2arr3725 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq3725[2] {
+ yym3733 := z.EncBinary()
+ _ = yym3733
+ if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Path))
}
@@ -47061,19 +47125,19 @@ func (x *NodeProxyOptions) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq3720[2] {
+ if yyq3725[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("path"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3729 := z.EncBinary()
- _ = yym3729
+ yym3734 := z.EncBinary()
+ _ = yym3734
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Path))
}
}
}
- if yyr3720 || yy2arr3720 {
+ if yyr3725 || yy2arr3725 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -47086,25 +47150,25 @@ func (x *NodeProxyOptions) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym3730 := z.DecBinary()
- _ = yym3730
+ yym3735 := z.DecBinary()
+ _ = yym3735
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct3731 := r.ContainerType()
- if yyct3731 == codecSelferValueTypeMap1234 {
- yyl3731 := r.ReadMapStart()
- if yyl3731 == 0 {
+ yyct3736 := r.ContainerType()
+ if yyct3736 == codecSelferValueTypeMap1234 {
+ yyl3736 := r.ReadMapStart()
+ if yyl3736 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl3731, d)
+ x.codecDecodeSelfFromMap(yyl3736, d)
}
- } else if yyct3731 == codecSelferValueTypeArray1234 {
- yyl3731 := r.ReadArrayStart()
- if yyl3731 == 0 {
+ } else if yyct3736 == codecSelferValueTypeArray1234 {
+ yyl3736 := r.ReadArrayStart()
+ if yyl3736 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl3731, d)
+ x.codecDecodeSelfFromArray(yyl3736, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -47116,12 +47180,12 @@ func (x *NodeProxyOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys3732Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys3732Slc
- var yyhl3732 bool = l >= 0
- for yyj3732 := 0; ; yyj3732++ {
- if yyhl3732 {
- if yyj3732 >= l {
+ var yys3737Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3737Slc
+ var yyhl3737 bool = l >= 0
+ for yyj3737 := 0; ; yyj3737++ {
+ if yyhl3737 {
+ if yyj3737 >= l {
break
}
} else {
@@ -47130,10 +47194,10 @@ func (x *NodeProxyOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys3732Slc = r.DecodeBytes(yys3732Slc, true, true)
- yys3732 := string(yys3732Slc)
+ yys3737Slc = r.DecodeBytes(yys3737Slc, true, true)
+ yys3737 := string(yys3737Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys3732 {
+ switch yys3737 {
case "kind":
if r.TryDecodeAsNil() {
x.Kind = ""
@@ -47153,9 +47217,9 @@ func (x *NodeProxyOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
x.Path = string(r.DecodeString())
}
default:
- z.DecStructFieldNotFound(-1, yys3732)
- } // end switch yys3732
- } // end for yyj3732
+ z.DecStructFieldNotFound(-1, yys3737)
+ } // end switch yys3737
+ } // end for yyj3737
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -47163,16 +47227,16 @@ func (x *NodeProxyOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj3736 int
- var yyb3736 bool
- var yyhl3736 bool = l >= 0
- yyj3736++
- if yyhl3736 {
- yyb3736 = yyj3736 > l
+ var yyj3741 int
+ var yyb3741 bool
+ var yyhl3741 bool = l >= 0
+ yyj3741++
+ if yyhl3741 {
+ yyb3741 = yyj3741 > l
} else {
- yyb3736 = r.CheckBreak()
+ yyb3741 = r.CheckBreak()
}
- if yyb3736 {
+ if yyb3741 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -47182,13 +47246,13 @@ func (x *NodeProxyOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
} else {
x.Kind = string(r.DecodeString())
}
- yyj3736++
- if yyhl3736 {
- yyb3736 = yyj3736 > l
+ yyj3741++
+ if yyhl3741 {
+ yyb3741 = yyj3741 > l
} else {
- yyb3736 = r.CheckBreak()
+ yyb3741 = r.CheckBreak()
}
- if yyb3736 {
+ if yyb3741 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -47198,13 +47262,13 @@ func (x *NodeProxyOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
} else {
x.APIVersion = string(r.DecodeString())
}
- yyj3736++
- if yyhl3736 {
- yyb3736 = yyj3736 > l
+ yyj3741++
+ if yyhl3741 {
+ yyb3741 = yyj3741 > l
} else {
- yyb3736 = r.CheckBreak()
+ yyb3741 = r.CheckBreak()
}
- if yyb3736 {
+ if yyb3741 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -47215,17 +47279,17 @@ func (x *NodeProxyOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
x.Path = string(r.DecodeString())
}
for {
- yyj3736++
- if yyhl3736 {
- yyb3736 = yyj3736 > l
+ yyj3741++
+ if yyhl3741 {
+ yyb3741 = yyj3741 > l
} else {
- yyb3736 = r.CheckBreak()
+ yyb3741 = r.CheckBreak()
}
- if yyb3736 {
+ if yyb3741 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj3736-1, "")
+ z.DecStructFieldNotFound(yyj3741-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -47237,37 +47301,37 @@ func (x *ServiceProxyOptions) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym3740 := z.EncBinary()
- _ = yym3740
+ yym3745 := z.EncBinary()
+ _ = yym3745
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep3741 := !z.EncBinary()
- yy2arr3741 := z.EncBasicHandle().StructToArray
- var yyq3741 [3]bool
- _, _, _ = yysep3741, yyq3741, yy2arr3741
- const yyr3741 bool = false
- yyq3741[0] = x.Kind != ""
- yyq3741[1] = x.APIVersion != ""
- yyq3741[2] = x.Path != ""
- var yynn3741 int
- if yyr3741 || yy2arr3741 {
+ yysep3746 := !z.EncBinary()
+ yy2arr3746 := z.EncBasicHandle().StructToArray
+ var yyq3746 [3]bool
+ _, _, _ = yysep3746, yyq3746, yy2arr3746
+ const yyr3746 bool = false
+ yyq3746[0] = x.Kind != ""
+ yyq3746[1] = x.APIVersion != ""
+ yyq3746[2] = x.Path != ""
+ var yynn3746 int
+ if yyr3746 || yy2arr3746 {
r.EncodeArrayStart(3)
} else {
- yynn3741 = 0
- for _, b := range yyq3741 {
+ yynn3746 = 0
+ for _, b := range yyq3746 {
if b {
- yynn3741++
+ yynn3746++
}
}
- r.EncodeMapStart(yynn3741)
- yynn3741 = 0
+ r.EncodeMapStart(yynn3746)
+ yynn3746 = 0
}
- if yyr3741 || yy2arr3741 {
+ if yyr3746 || yy2arr3746 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3741[0] {
- yym3743 := z.EncBinary()
- _ = yym3743
+ if yyq3746[0] {
+ yym3748 := z.EncBinary()
+ _ = yym3748
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
@@ -47276,49 +47340,49 @@ func (x *ServiceProxyOptions) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq3741[0] {
+ if yyq3746[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("kind"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3744 := z.EncBinary()
- _ = yym3744
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
- }
- }
- }
- if yyr3741 || yy2arr3741 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3741[1] {
- yym3746 := z.EncBinary()
- _ = yym3746
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
- }
- } else {
- r.EncodeString(codecSelferC_UTF81234, "")
- }
- } else {
- if yyq3741[1] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3747 := z.EncBinary()
- _ = yym3747
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
- }
- }
- }
- if yyr3741 || yy2arr3741 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3741[2] {
yym3749 := z.EncBinary()
_ = yym3749
if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ }
+ }
+ if yyr3746 || yy2arr3746 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq3746[1] {
+ yym3751 := z.EncBinary()
+ _ = yym3751
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq3746[1] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym3752 := z.EncBinary()
+ _ = yym3752
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ }
+ }
+ if yyr3746 || yy2arr3746 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq3746[2] {
+ yym3754 := z.EncBinary()
+ _ = yym3754
+ if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Path))
}
@@ -47326,19 +47390,19 @@ func (x *ServiceProxyOptions) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq3741[2] {
+ if yyq3746[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("path"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3750 := z.EncBinary()
- _ = yym3750
+ yym3755 := z.EncBinary()
+ _ = yym3755
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Path))
}
}
}
- if yyr3741 || yy2arr3741 {
+ if yyr3746 || yy2arr3746 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -47351,25 +47415,25 @@ func (x *ServiceProxyOptions) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym3751 := z.DecBinary()
- _ = yym3751
+ yym3756 := z.DecBinary()
+ _ = yym3756
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct3752 := r.ContainerType()
- if yyct3752 == codecSelferValueTypeMap1234 {
- yyl3752 := r.ReadMapStart()
- if yyl3752 == 0 {
+ yyct3757 := r.ContainerType()
+ if yyct3757 == codecSelferValueTypeMap1234 {
+ yyl3757 := r.ReadMapStart()
+ if yyl3757 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl3752, d)
+ x.codecDecodeSelfFromMap(yyl3757, d)
}
- } else if yyct3752 == codecSelferValueTypeArray1234 {
- yyl3752 := r.ReadArrayStart()
- if yyl3752 == 0 {
+ } else if yyct3757 == codecSelferValueTypeArray1234 {
+ yyl3757 := r.ReadArrayStart()
+ if yyl3757 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl3752, d)
+ x.codecDecodeSelfFromArray(yyl3757, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -47381,12 +47445,12 @@ func (x *ServiceProxyOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys3753Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys3753Slc
- var yyhl3753 bool = l >= 0
- for yyj3753 := 0; ; yyj3753++ {
- if yyhl3753 {
- if yyj3753 >= l {
+ var yys3758Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3758Slc
+ var yyhl3758 bool = l >= 0
+ for yyj3758 := 0; ; yyj3758++ {
+ if yyhl3758 {
+ if yyj3758 >= l {
break
}
} else {
@@ -47395,10 +47459,10 @@ func (x *ServiceProxyOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys3753Slc = r.DecodeBytes(yys3753Slc, true, true)
- yys3753 := string(yys3753Slc)
+ yys3758Slc = r.DecodeBytes(yys3758Slc, true, true)
+ yys3758 := string(yys3758Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys3753 {
+ switch yys3758 {
case "kind":
if r.TryDecodeAsNil() {
x.Kind = ""
@@ -47418,9 +47482,9 @@ func (x *ServiceProxyOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder
x.Path = string(r.DecodeString())
}
default:
- z.DecStructFieldNotFound(-1, yys3753)
- } // end switch yys3753
- } // end for yyj3753
+ z.DecStructFieldNotFound(-1, yys3758)
+ } // end switch yys3758
+ } // end for yyj3758
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -47428,16 +47492,16 @@ func (x *ServiceProxyOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decod
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj3757 int
- var yyb3757 bool
- var yyhl3757 bool = l >= 0
- yyj3757++
- if yyhl3757 {
- yyb3757 = yyj3757 > l
+ var yyj3762 int
+ var yyb3762 bool
+ var yyhl3762 bool = l >= 0
+ yyj3762++
+ if yyhl3762 {
+ yyb3762 = yyj3762 > l
} else {
- yyb3757 = r.CheckBreak()
+ yyb3762 = r.CheckBreak()
}
- if yyb3757 {
+ if yyb3762 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -47447,13 +47511,13 @@ func (x *ServiceProxyOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decod
} else {
x.Kind = string(r.DecodeString())
}
- yyj3757++
- if yyhl3757 {
- yyb3757 = yyj3757 > l
+ yyj3762++
+ if yyhl3762 {
+ yyb3762 = yyj3762 > l
} else {
- yyb3757 = r.CheckBreak()
+ yyb3762 = r.CheckBreak()
}
- if yyb3757 {
+ if yyb3762 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -47463,13 +47527,13 @@ func (x *ServiceProxyOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decod
} else {
x.APIVersion = string(r.DecodeString())
}
- yyj3757++
- if yyhl3757 {
- yyb3757 = yyj3757 > l
+ yyj3762++
+ if yyhl3762 {
+ yyb3762 = yyj3762 > l
} else {
- yyb3757 = r.CheckBreak()
+ yyb3762 = r.CheckBreak()
}
- if yyb3757 {
+ if yyb3762 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -47480,17 +47544,17 @@ func (x *ServiceProxyOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decod
x.Path = string(r.DecodeString())
}
for {
- yyj3757++
- if yyhl3757 {
- yyb3757 = yyj3757 > l
+ yyj3762++
+ if yyhl3762 {
+ yyb3762 = yyj3762 > l
} else {
- yyb3757 = r.CheckBreak()
+ yyb3762 = r.CheckBreak()
}
- if yyb3757 {
+ if yyb3762 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj3757-1, "")
+ z.DecStructFieldNotFound(yyj3762-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -47502,41 +47566,41 @@ func (x *ObjectReference) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym3761 := z.EncBinary()
- _ = yym3761
+ yym3766 := z.EncBinary()
+ _ = yym3766
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep3762 := !z.EncBinary()
- yy2arr3762 := z.EncBasicHandle().StructToArray
- var yyq3762 [7]bool
- _, _, _ = yysep3762, yyq3762, yy2arr3762
- const yyr3762 bool = false
- yyq3762[0] = x.Kind != ""
- yyq3762[1] = x.Namespace != ""
- yyq3762[2] = x.Name != ""
- yyq3762[3] = x.UID != ""
- yyq3762[4] = x.APIVersion != ""
- yyq3762[5] = x.ResourceVersion != ""
- yyq3762[6] = x.FieldPath != ""
- var yynn3762 int
- if yyr3762 || yy2arr3762 {
+ yysep3767 := !z.EncBinary()
+ yy2arr3767 := z.EncBasicHandle().StructToArray
+ var yyq3767 [7]bool
+ _, _, _ = yysep3767, yyq3767, yy2arr3767
+ const yyr3767 bool = false
+ yyq3767[0] = x.Kind != ""
+ yyq3767[1] = x.Namespace != ""
+ yyq3767[2] = x.Name != ""
+ yyq3767[3] = x.UID != ""
+ yyq3767[4] = x.APIVersion != ""
+ yyq3767[5] = x.ResourceVersion != ""
+ yyq3767[6] = x.FieldPath != ""
+ var yynn3767 int
+ if yyr3767 || yy2arr3767 {
r.EncodeArrayStart(7)
} else {
- yynn3762 = 0
- for _, b := range yyq3762 {
+ yynn3767 = 0
+ for _, b := range yyq3767 {
if b {
- yynn3762++
+ yynn3767++
}
}
- r.EncodeMapStart(yynn3762)
- yynn3762 = 0
+ r.EncodeMapStart(yynn3767)
+ yynn3767 = 0
}
- if yyr3762 || yy2arr3762 {
+ if yyr3767 || yy2arr3767 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3762[0] {
- yym3764 := z.EncBinary()
- _ = yym3764
+ if yyq3767[0] {
+ yym3769 := z.EncBinary()
+ _ = yym3769
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
@@ -47545,151 +47609,151 @@ func (x *ObjectReference) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq3762[0] {
+ if yyq3767[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("kind"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3765 := z.EncBinary()
- _ = yym3765
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
- }
- }
- }
- if yyr3762 || yy2arr3762 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3762[1] {
- yym3767 := z.EncBinary()
- _ = yym3767
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Namespace))
- }
- } else {
- r.EncodeString(codecSelferC_UTF81234, "")
- }
- } else {
- if yyq3762[1] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("namespace"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3768 := z.EncBinary()
- _ = yym3768
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Namespace))
- }
- }
- }
- if yyr3762 || yy2arr3762 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3762[2] {
yym3770 := z.EncBinary()
_ = yym3770
if false {
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Name))
+ r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
+ }
+ }
+ }
+ if yyr3767 || yy2arr3767 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq3767[1] {
+ yym3772 := z.EncBinary()
+ _ = yym3772
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Namespace))
}
} else {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq3762[2] {
+ if yyq3767[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("name"))
+ r.EncodeString(codecSelferC_UTF81234, string("namespace"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3771 := z.EncBinary()
- _ = yym3771
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Name))
- }
- }
- }
- if yyr3762 || yy2arr3762 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3762[3] {
yym3773 := z.EncBinary()
_ = yym3773
if false {
- } else if z.HasExtensions() && z.EncExt(x.UID) {
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.UID))
+ r.EncodeString(codecSelferC_UTF81234, string(x.Namespace))
+ }
+ }
+ }
+ if yyr3767 || yy2arr3767 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq3767[2] {
+ yym3775 := z.EncBinary()
+ _ = yym3775
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Name))
}
} else {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq3762[3] {
+ if yyq3767[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("uid"))
+ r.EncodeString(codecSelferC_UTF81234, string("name"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3774 := z.EncBinary()
- _ = yym3774
- if false {
- } else if z.HasExtensions() && z.EncExt(x.UID) {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.UID))
- }
- }
- }
- if yyr3762 || yy2arr3762 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3762[4] {
yym3776 := z.EncBinary()
_ = yym3776
if false {
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ r.EncodeString(codecSelferC_UTF81234, string(x.Name))
+ }
+ }
+ }
+ if yyr3767 || yy2arr3767 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq3767[3] {
+ yym3778 := z.EncBinary()
+ _ = yym3778
+ if false {
+ } else if z.HasExtensions() && z.EncExt(x.UID) {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.UID))
}
} else {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq3762[4] {
+ if yyq3767[3] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
+ r.EncodeString(codecSelferC_UTF81234, string("uid"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3777 := z.EncBinary()
- _ = yym3777
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
- }
- }
- }
- if yyr3762 || yy2arr3762 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3762[5] {
yym3779 := z.EncBinary()
_ = yym3779
if false {
+ } else if z.HasExtensions() && z.EncExt(x.UID) {
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.ResourceVersion))
+ r.EncodeString(codecSelferC_UTF81234, string(x.UID))
+ }
+ }
+ }
+ if yyr3767 || yy2arr3767 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq3767[4] {
+ yym3781 := z.EncBinary()
+ _ = yym3781
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
}
} else {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq3762[5] {
+ if yyq3767[4] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("resourceVersion"))
+ r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3780 := z.EncBinary()
- _ = yym3780
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.ResourceVersion))
- }
- }
- }
- if yyr3762 || yy2arr3762 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3762[6] {
yym3782 := z.EncBinary()
_ = yym3782
if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
+ }
+ }
+ }
+ if yyr3767 || yy2arr3767 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq3767[5] {
+ yym3784 := z.EncBinary()
+ _ = yym3784
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.ResourceVersion))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq3767[5] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("resourceVersion"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym3785 := z.EncBinary()
+ _ = yym3785
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.ResourceVersion))
+ }
+ }
+ }
+ if yyr3767 || yy2arr3767 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq3767[6] {
+ yym3787 := z.EncBinary()
+ _ = yym3787
+ if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.FieldPath))
}
@@ -47697,19 +47761,19 @@ func (x *ObjectReference) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq3762[6] {
+ if yyq3767[6] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("fieldPath"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3783 := z.EncBinary()
- _ = yym3783
+ yym3788 := z.EncBinary()
+ _ = yym3788
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.FieldPath))
}
}
}
- if yyr3762 || yy2arr3762 {
+ if yyr3767 || yy2arr3767 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -47722,25 +47786,25 @@ func (x *ObjectReference) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym3784 := z.DecBinary()
- _ = yym3784
+ yym3789 := z.DecBinary()
+ _ = yym3789
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct3785 := r.ContainerType()
- if yyct3785 == codecSelferValueTypeMap1234 {
- yyl3785 := r.ReadMapStart()
- if yyl3785 == 0 {
+ yyct3790 := r.ContainerType()
+ if yyct3790 == codecSelferValueTypeMap1234 {
+ yyl3790 := r.ReadMapStart()
+ if yyl3790 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl3785, d)
+ x.codecDecodeSelfFromMap(yyl3790, d)
}
- } else if yyct3785 == codecSelferValueTypeArray1234 {
- yyl3785 := r.ReadArrayStart()
- if yyl3785 == 0 {
+ } else if yyct3790 == codecSelferValueTypeArray1234 {
+ yyl3790 := r.ReadArrayStart()
+ if yyl3790 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl3785, d)
+ x.codecDecodeSelfFromArray(yyl3790, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -47752,12 +47816,12 @@ func (x *ObjectReference) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys3786Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys3786Slc
- var yyhl3786 bool = l >= 0
- for yyj3786 := 0; ; yyj3786++ {
- if yyhl3786 {
- if yyj3786 >= l {
+ var yys3791Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3791Slc
+ var yyhl3791 bool = l >= 0
+ for yyj3791 := 0; ; yyj3791++ {
+ if yyhl3791 {
+ if yyj3791 >= l {
break
}
} else {
@@ -47766,10 +47830,10 @@ func (x *ObjectReference) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys3786Slc = r.DecodeBytes(yys3786Slc, true, true)
- yys3786 := string(yys3786Slc)
+ yys3791Slc = r.DecodeBytes(yys3791Slc, true, true)
+ yys3791 := string(yys3791Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys3786 {
+ switch yys3791 {
case "kind":
if r.TryDecodeAsNil() {
x.Kind = ""
@@ -47813,9 +47877,9 @@ func (x *ObjectReference) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
x.FieldPath = string(r.DecodeString())
}
default:
- z.DecStructFieldNotFound(-1, yys3786)
- } // end switch yys3786
- } // end for yyj3786
+ z.DecStructFieldNotFound(-1, yys3791)
+ } // end switch yys3791
+ } // end for yyj3791
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -47823,16 +47887,16 @@ func (x *ObjectReference) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj3794 int
- var yyb3794 bool
- var yyhl3794 bool = l >= 0
- yyj3794++
- if yyhl3794 {
- yyb3794 = yyj3794 > l
+ var yyj3799 int
+ var yyb3799 bool
+ var yyhl3799 bool = l >= 0
+ yyj3799++
+ if yyhl3799 {
+ yyb3799 = yyj3799 > l
} else {
- yyb3794 = r.CheckBreak()
+ yyb3799 = r.CheckBreak()
}
- if yyb3794 {
+ if yyb3799 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -47842,13 +47906,13 @@ func (x *ObjectReference) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
} else {
x.Kind = string(r.DecodeString())
}
- yyj3794++
- if yyhl3794 {
- yyb3794 = yyj3794 > l
+ yyj3799++
+ if yyhl3799 {
+ yyb3799 = yyj3799 > l
} else {
- yyb3794 = r.CheckBreak()
+ yyb3799 = r.CheckBreak()
}
- if yyb3794 {
+ if yyb3799 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -47858,13 +47922,13 @@ func (x *ObjectReference) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
} else {
x.Namespace = string(r.DecodeString())
}
- yyj3794++
- if yyhl3794 {
- yyb3794 = yyj3794 > l
+ yyj3799++
+ if yyhl3799 {
+ yyb3799 = yyj3799 > l
} else {
- yyb3794 = r.CheckBreak()
+ yyb3799 = r.CheckBreak()
}
- if yyb3794 {
+ if yyb3799 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -47874,13 +47938,13 @@ func (x *ObjectReference) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
} else {
x.Name = string(r.DecodeString())
}
- yyj3794++
- if yyhl3794 {
- yyb3794 = yyj3794 > l
+ yyj3799++
+ if yyhl3799 {
+ yyb3799 = yyj3799 > l
} else {
- yyb3794 = r.CheckBreak()
+ yyb3799 = r.CheckBreak()
}
- if yyb3794 {
+ if yyb3799 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -47890,13 +47954,13 @@ func (x *ObjectReference) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
} else {
x.UID = pkg1_types.UID(r.DecodeString())
}
- yyj3794++
- if yyhl3794 {
- yyb3794 = yyj3794 > l
+ yyj3799++
+ if yyhl3799 {
+ yyb3799 = yyj3799 > l
} else {
- yyb3794 = r.CheckBreak()
+ yyb3799 = r.CheckBreak()
}
- if yyb3794 {
+ if yyb3799 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -47906,13 +47970,13 @@ func (x *ObjectReference) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
} else {
x.APIVersion = string(r.DecodeString())
}
- yyj3794++
- if yyhl3794 {
- yyb3794 = yyj3794 > l
+ yyj3799++
+ if yyhl3799 {
+ yyb3799 = yyj3799 > l
} else {
- yyb3794 = r.CheckBreak()
+ yyb3799 = r.CheckBreak()
}
- if yyb3794 {
+ if yyb3799 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -47922,13 +47986,13 @@ func (x *ObjectReference) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
} else {
x.ResourceVersion = string(r.DecodeString())
}
- yyj3794++
- if yyhl3794 {
- yyb3794 = yyj3794 > l
+ yyj3799++
+ if yyhl3799 {
+ yyb3799 = yyj3799 > l
} else {
- yyb3794 = r.CheckBreak()
+ yyb3799 = r.CheckBreak()
}
- if yyb3794 {
+ if yyb3799 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -47939,17 +48003,17 @@ func (x *ObjectReference) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
x.FieldPath = string(r.DecodeString())
}
for {
- yyj3794++
- if yyhl3794 {
- yyb3794 = yyj3794 > l
+ yyj3799++
+ if yyhl3799 {
+ yyb3799 = yyj3799 > l
} else {
- yyb3794 = r.CheckBreak()
+ yyb3799 = r.CheckBreak()
}
- if yyb3794 {
+ if yyb3799 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj3794-1, "")
+ z.DecStructFieldNotFound(yyj3799-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -47961,35 +48025,35 @@ func (x *LocalObjectReference) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym3802 := z.EncBinary()
- _ = yym3802
+ yym3807 := z.EncBinary()
+ _ = yym3807
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep3803 := !z.EncBinary()
- yy2arr3803 := z.EncBasicHandle().StructToArray
- var yyq3803 [1]bool
- _, _, _ = yysep3803, yyq3803, yy2arr3803
- const yyr3803 bool = false
- yyq3803[0] = x.Name != ""
- var yynn3803 int
- if yyr3803 || yy2arr3803 {
+ yysep3808 := !z.EncBinary()
+ yy2arr3808 := z.EncBasicHandle().StructToArray
+ var yyq3808 [1]bool
+ _, _, _ = yysep3808, yyq3808, yy2arr3808
+ const yyr3808 bool = false
+ yyq3808[0] = x.Name != ""
+ var yynn3808 int
+ if yyr3808 || yy2arr3808 {
r.EncodeArrayStart(1)
} else {
- yynn3803 = 0
- for _, b := range yyq3803 {
+ yynn3808 = 0
+ for _, b := range yyq3808 {
if b {
- yynn3803++
+ yynn3808++
}
}
- r.EncodeMapStart(yynn3803)
- yynn3803 = 0
+ r.EncodeMapStart(yynn3808)
+ yynn3808 = 0
}
- if yyr3803 || yy2arr3803 {
+ if yyr3808 || yy2arr3808 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3803[0] {
- yym3805 := z.EncBinary()
- _ = yym3805
+ if yyq3808[0] {
+ yym3810 := z.EncBinary()
+ _ = yym3810
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Name))
@@ -47998,19 +48062,19 @@ func (x *LocalObjectReference) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq3803[0] {
+ if yyq3808[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("name"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3806 := z.EncBinary()
- _ = yym3806
+ yym3811 := z.EncBinary()
+ _ = yym3811
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Name))
}
}
}
- if yyr3803 || yy2arr3803 {
+ if yyr3808 || yy2arr3808 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -48023,25 +48087,25 @@ func (x *LocalObjectReference) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym3807 := z.DecBinary()
- _ = yym3807
+ yym3812 := z.DecBinary()
+ _ = yym3812
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct3808 := r.ContainerType()
- if yyct3808 == codecSelferValueTypeMap1234 {
- yyl3808 := r.ReadMapStart()
- if yyl3808 == 0 {
+ yyct3813 := r.ContainerType()
+ if yyct3813 == codecSelferValueTypeMap1234 {
+ yyl3813 := r.ReadMapStart()
+ if yyl3813 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl3808, d)
+ x.codecDecodeSelfFromMap(yyl3813, d)
}
- } else if yyct3808 == codecSelferValueTypeArray1234 {
- yyl3808 := r.ReadArrayStart()
- if yyl3808 == 0 {
+ } else if yyct3813 == codecSelferValueTypeArray1234 {
+ yyl3813 := r.ReadArrayStart()
+ if yyl3813 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl3808, d)
+ x.codecDecodeSelfFromArray(yyl3813, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -48053,12 +48117,12 @@ func (x *LocalObjectReference) codecDecodeSelfFromMap(l int, d *codec1978.Decode
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys3809Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys3809Slc
- var yyhl3809 bool = l >= 0
- for yyj3809 := 0; ; yyj3809++ {
- if yyhl3809 {
- if yyj3809 >= l {
+ var yys3814Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3814Slc
+ var yyhl3814 bool = l >= 0
+ for yyj3814 := 0; ; yyj3814++ {
+ if yyhl3814 {
+ if yyj3814 >= l {
break
}
} else {
@@ -48067,10 +48131,10 @@ func (x *LocalObjectReference) codecDecodeSelfFromMap(l int, d *codec1978.Decode
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys3809Slc = r.DecodeBytes(yys3809Slc, true, true)
- yys3809 := string(yys3809Slc)
+ yys3814Slc = r.DecodeBytes(yys3814Slc, true, true)
+ yys3814 := string(yys3814Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys3809 {
+ switch yys3814 {
case "name":
if r.TryDecodeAsNil() {
x.Name = ""
@@ -48078,9 +48142,9 @@ func (x *LocalObjectReference) codecDecodeSelfFromMap(l int, d *codec1978.Decode
x.Name = string(r.DecodeString())
}
default:
- z.DecStructFieldNotFound(-1, yys3809)
- } // end switch yys3809
- } // end for yyj3809
+ z.DecStructFieldNotFound(-1, yys3814)
+ } // end switch yys3814
+ } // end for yyj3814
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -48088,16 +48152,16 @@ func (x *LocalObjectReference) codecDecodeSelfFromArray(l int, d *codec1978.Deco
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj3811 int
- var yyb3811 bool
- var yyhl3811 bool = l >= 0
- yyj3811++
- if yyhl3811 {
- yyb3811 = yyj3811 > l
+ var yyj3816 int
+ var yyb3816 bool
+ var yyhl3816 bool = l >= 0
+ yyj3816++
+ if yyhl3816 {
+ yyb3816 = yyj3816 > l
} else {
- yyb3811 = r.CheckBreak()
+ yyb3816 = r.CheckBreak()
}
- if yyb3811 {
+ if yyb3816 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -48108,17 +48172,17 @@ func (x *LocalObjectReference) codecDecodeSelfFromArray(l int, d *codec1978.Deco
x.Name = string(r.DecodeString())
}
for {
- yyj3811++
- if yyhl3811 {
- yyb3811 = yyj3811 > l
+ yyj3816++
+ if yyhl3816 {
+ yyb3816 = yyj3816 > l
} else {
- yyb3811 = r.CheckBreak()
+ yyb3816 = r.CheckBreak()
}
- if yyb3811 {
+ if yyb3816 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj3811-1, "")
+ z.DecStructFieldNotFound(yyj3816-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -48130,37 +48194,37 @@ func (x *SerializedReference) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym3813 := z.EncBinary()
- _ = yym3813
+ yym3818 := z.EncBinary()
+ _ = yym3818
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep3814 := !z.EncBinary()
- yy2arr3814 := z.EncBasicHandle().StructToArray
- var yyq3814 [3]bool
- _, _, _ = yysep3814, yyq3814, yy2arr3814
- const yyr3814 bool = false
- yyq3814[0] = x.Kind != ""
- yyq3814[1] = x.APIVersion != ""
- yyq3814[2] = true
- var yynn3814 int
- if yyr3814 || yy2arr3814 {
+ yysep3819 := !z.EncBinary()
+ yy2arr3819 := z.EncBasicHandle().StructToArray
+ var yyq3819 [3]bool
+ _, _, _ = yysep3819, yyq3819, yy2arr3819
+ const yyr3819 bool = false
+ yyq3819[0] = x.Kind != ""
+ yyq3819[1] = x.APIVersion != ""
+ yyq3819[2] = true
+ var yynn3819 int
+ if yyr3819 || yy2arr3819 {
r.EncodeArrayStart(3)
} else {
- yynn3814 = 0
- for _, b := range yyq3814 {
+ yynn3819 = 0
+ for _, b := range yyq3819 {
if b {
- yynn3814++
+ yynn3819++
}
}
- r.EncodeMapStart(yynn3814)
- yynn3814 = 0
+ r.EncodeMapStart(yynn3819)
+ yynn3819 = 0
}
- if yyr3814 || yy2arr3814 {
+ if yyr3819 || yy2arr3819 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3814[0] {
- yym3816 := z.EncBinary()
- _ = yym3816
+ if yyq3819[0] {
+ yym3821 := z.EncBinary()
+ _ = yym3821
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
@@ -48169,23 +48233,23 @@ func (x *SerializedReference) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq3814[0] {
+ if yyq3819[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("kind"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3817 := z.EncBinary()
- _ = yym3817
+ yym3822 := z.EncBinary()
+ _ = yym3822
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
}
}
}
- if yyr3814 || yy2arr3814 {
+ if yyr3819 || yy2arr3819 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3814[1] {
- yym3819 := z.EncBinary()
- _ = yym3819
+ if yyq3819[1] {
+ yym3824 := z.EncBinary()
+ _ = yym3824
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
@@ -48194,36 +48258,36 @@ func (x *SerializedReference) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq3814[1] {
+ if yyq3819[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3820 := z.EncBinary()
- _ = yym3820
+ yym3825 := z.EncBinary()
+ _ = yym3825
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
}
}
}
- if yyr3814 || yy2arr3814 {
+ if yyr3819 || yy2arr3819 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3814[2] {
- yy3822 := &x.Reference
- yy3822.CodecEncodeSelf(e)
+ if yyq3819[2] {
+ yy3827 := &x.Reference
+ yy3827.CodecEncodeSelf(e)
} else {
r.EncodeNil()
}
} else {
- if yyq3814[2] {
+ if yyq3819[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("reference"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy3823 := &x.Reference
- yy3823.CodecEncodeSelf(e)
+ yy3828 := &x.Reference
+ yy3828.CodecEncodeSelf(e)
}
}
- if yyr3814 || yy2arr3814 {
+ if yyr3819 || yy2arr3819 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -48236,25 +48300,25 @@ func (x *SerializedReference) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym3824 := z.DecBinary()
- _ = yym3824
+ yym3829 := z.DecBinary()
+ _ = yym3829
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct3825 := r.ContainerType()
- if yyct3825 == codecSelferValueTypeMap1234 {
- yyl3825 := r.ReadMapStart()
- if yyl3825 == 0 {
+ yyct3830 := r.ContainerType()
+ if yyct3830 == codecSelferValueTypeMap1234 {
+ yyl3830 := r.ReadMapStart()
+ if yyl3830 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl3825, d)
+ x.codecDecodeSelfFromMap(yyl3830, d)
}
- } else if yyct3825 == codecSelferValueTypeArray1234 {
- yyl3825 := r.ReadArrayStart()
- if yyl3825 == 0 {
+ } else if yyct3830 == codecSelferValueTypeArray1234 {
+ yyl3830 := r.ReadArrayStart()
+ if yyl3830 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl3825, d)
+ x.codecDecodeSelfFromArray(yyl3830, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -48266,12 +48330,12 @@ func (x *SerializedReference) codecDecodeSelfFromMap(l int, d *codec1978.Decoder
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys3826Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys3826Slc
- var yyhl3826 bool = l >= 0
- for yyj3826 := 0; ; yyj3826++ {
- if yyhl3826 {
- if yyj3826 >= l {
+ var yys3831Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3831Slc
+ var yyhl3831 bool = l >= 0
+ for yyj3831 := 0; ; yyj3831++ {
+ if yyhl3831 {
+ if yyj3831 >= l {
break
}
} else {
@@ -48280,10 +48344,10 @@ func (x *SerializedReference) codecDecodeSelfFromMap(l int, d *codec1978.Decoder
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys3826Slc = r.DecodeBytes(yys3826Slc, true, true)
- yys3826 := string(yys3826Slc)
+ yys3831Slc = r.DecodeBytes(yys3831Slc, true, true)
+ yys3831 := string(yys3831Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys3826 {
+ switch yys3831 {
case "kind":
if r.TryDecodeAsNil() {
x.Kind = ""
@@ -48300,13 +48364,13 @@ func (x *SerializedReference) codecDecodeSelfFromMap(l int, d *codec1978.Decoder
if r.TryDecodeAsNil() {
x.Reference = ObjectReference{}
} else {
- yyv3829 := &x.Reference
- yyv3829.CodecDecodeSelf(d)
+ yyv3834 := &x.Reference
+ yyv3834.CodecDecodeSelf(d)
}
default:
- z.DecStructFieldNotFound(-1, yys3826)
- } // end switch yys3826
- } // end for yyj3826
+ z.DecStructFieldNotFound(-1, yys3831)
+ } // end switch yys3831
+ } // end for yyj3831
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -48314,16 +48378,16 @@ func (x *SerializedReference) codecDecodeSelfFromArray(l int, d *codec1978.Decod
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj3830 int
- var yyb3830 bool
- var yyhl3830 bool = l >= 0
- yyj3830++
- if yyhl3830 {
- yyb3830 = yyj3830 > l
+ var yyj3835 int
+ var yyb3835 bool
+ var yyhl3835 bool = l >= 0
+ yyj3835++
+ if yyhl3835 {
+ yyb3835 = yyj3835 > l
} else {
- yyb3830 = r.CheckBreak()
+ yyb3835 = r.CheckBreak()
}
- if yyb3830 {
+ if yyb3835 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -48333,13 +48397,13 @@ func (x *SerializedReference) codecDecodeSelfFromArray(l int, d *codec1978.Decod
} else {
x.Kind = string(r.DecodeString())
}
- yyj3830++
- if yyhl3830 {
- yyb3830 = yyj3830 > l
+ yyj3835++
+ if yyhl3835 {
+ yyb3835 = yyj3835 > l
} else {
- yyb3830 = r.CheckBreak()
+ yyb3835 = r.CheckBreak()
}
- if yyb3830 {
+ if yyb3835 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -48349,13 +48413,13 @@ func (x *SerializedReference) codecDecodeSelfFromArray(l int, d *codec1978.Decod
} else {
x.APIVersion = string(r.DecodeString())
}
- yyj3830++
- if yyhl3830 {
- yyb3830 = yyj3830 > l
+ yyj3835++
+ if yyhl3835 {
+ yyb3835 = yyj3835 > l
} else {
- yyb3830 = r.CheckBreak()
+ yyb3835 = r.CheckBreak()
}
- if yyb3830 {
+ if yyb3835 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -48363,21 +48427,21 @@ func (x *SerializedReference) codecDecodeSelfFromArray(l int, d *codec1978.Decod
if r.TryDecodeAsNil() {
x.Reference = ObjectReference{}
} else {
- yyv3833 := &x.Reference
- yyv3833.CodecDecodeSelf(d)
+ yyv3838 := &x.Reference
+ yyv3838.CodecDecodeSelf(d)
}
for {
- yyj3830++
- if yyhl3830 {
- yyb3830 = yyj3830 > l
+ yyj3835++
+ if yyhl3835 {
+ yyb3835 = yyj3835 > l
} else {
- yyb3830 = r.CheckBreak()
+ yyb3835 = r.CheckBreak()
}
- if yyb3830 {
+ if yyb3835 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj3830-1, "")
+ z.DecStructFieldNotFound(yyj3835-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -48389,36 +48453,36 @@ func (x *EventSource) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym3834 := z.EncBinary()
- _ = yym3834
+ yym3839 := z.EncBinary()
+ _ = yym3839
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep3835 := !z.EncBinary()
- yy2arr3835 := z.EncBasicHandle().StructToArray
- var yyq3835 [2]bool
- _, _, _ = yysep3835, yyq3835, yy2arr3835
- const yyr3835 bool = false
- yyq3835[0] = x.Component != ""
- yyq3835[1] = x.Host != ""
- var yynn3835 int
- if yyr3835 || yy2arr3835 {
+ yysep3840 := !z.EncBinary()
+ yy2arr3840 := z.EncBasicHandle().StructToArray
+ var yyq3840 [2]bool
+ _, _, _ = yysep3840, yyq3840, yy2arr3840
+ const yyr3840 bool = false
+ yyq3840[0] = x.Component != ""
+ yyq3840[1] = x.Host != ""
+ var yynn3840 int
+ if yyr3840 || yy2arr3840 {
r.EncodeArrayStart(2)
} else {
- yynn3835 = 0
- for _, b := range yyq3835 {
+ yynn3840 = 0
+ for _, b := range yyq3840 {
if b {
- yynn3835++
+ yynn3840++
}
}
- r.EncodeMapStart(yynn3835)
- yynn3835 = 0
+ r.EncodeMapStart(yynn3840)
+ yynn3840 = 0
}
- if yyr3835 || yy2arr3835 {
+ if yyr3840 || yy2arr3840 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3835[0] {
- yym3837 := z.EncBinary()
- _ = yym3837
+ if yyq3840[0] {
+ yym3842 := z.EncBinary()
+ _ = yym3842
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Component))
@@ -48427,23 +48491,23 @@ func (x *EventSource) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq3835[0] {
+ if yyq3840[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("component"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3838 := z.EncBinary()
- _ = yym3838
+ yym3843 := z.EncBinary()
+ _ = yym3843
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Component))
}
}
}
- if yyr3835 || yy2arr3835 {
+ if yyr3840 || yy2arr3840 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3835[1] {
- yym3840 := z.EncBinary()
- _ = yym3840
+ if yyq3840[1] {
+ yym3845 := z.EncBinary()
+ _ = yym3845
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Host))
@@ -48452,19 +48516,19 @@ func (x *EventSource) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq3835[1] {
+ if yyq3840[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("host"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3841 := z.EncBinary()
- _ = yym3841
+ yym3846 := z.EncBinary()
+ _ = yym3846
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Host))
}
}
}
- if yyr3835 || yy2arr3835 {
+ if yyr3840 || yy2arr3840 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -48477,25 +48541,25 @@ func (x *EventSource) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym3842 := z.DecBinary()
- _ = yym3842
+ yym3847 := z.DecBinary()
+ _ = yym3847
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct3843 := r.ContainerType()
- if yyct3843 == codecSelferValueTypeMap1234 {
- yyl3843 := r.ReadMapStart()
- if yyl3843 == 0 {
+ yyct3848 := r.ContainerType()
+ if yyct3848 == codecSelferValueTypeMap1234 {
+ yyl3848 := r.ReadMapStart()
+ if yyl3848 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl3843, d)
+ x.codecDecodeSelfFromMap(yyl3848, d)
}
- } else if yyct3843 == codecSelferValueTypeArray1234 {
- yyl3843 := r.ReadArrayStart()
- if yyl3843 == 0 {
+ } else if yyct3848 == codecSelferValueTypeArray1234 {
+ yyl3848 := r.ReadArrayStart()
+ if yyl3848 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl3843, d)
+ x.codecDecodeSelfFromArray(yyl3848, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -48507,12 +48571,12 @@ func (x *EventSource) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys3844Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys3844Slc
- var yyhl3844 bool = l >= 0
- for yyj3844 := 0; ; yyj3844++ {
- if yyhl3844 {
- if yyj3844 >= l {
+ var yys3849Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3849Slc
+ var yyhl3849 bool = l >= 0
+ for yyj3849 := 0; ; yyj3849++ {
+ if yyhl3849 {
+ if yyj3849 >= l {
break
}
} else {
@@ -48521,10 +48585,10 @@ func (x *EventSource) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys3844Slc = r.DecodeBytes(yys3844Slc, true, true)
- yys3844 := string(yys3844Slc)
+ yys3849Slc = r.DecodeBytes(yys3849Slc, true, true)
+ yys3849 := string(yys3849Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys3844 {
+ switch yys3849 {
case "component":
if r.TryDecodeAsNil() {
x.Component = ""
@@ -48538,9 +48602,9 @@ func (x *EventSource) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
x.Host = string(r.DecodeString())
}
default:
- z.DecStructFieldNotFound(-1, yys3844)
- } // end switch yys3844
- } // end for yyj3844
+ z.DecStructFieldNotFound(-1, yys3849)
+ } // end switch yys3849
+ } // end for yyj3849
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -48548,16 +48612,16 @@ func (x *EventSource) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj3847 int
- var yyb3847 bool
- var yyhl3847 bool = l >= 0
- yyj3847++
- if yyhl3847 {
- yyb3847 = yyj3847 > l
+ var yyj3852 int
+ var yyb3852 bool
+ var yyhl3852 bool = l >= 0
+ yyj3852++
+ if yyhl3852 {
+ yyb3852 = yyj3852 > l
} else {
- yyb3847 = r.CheckBreak()
+ yyb3852 = r.CheckBreak()
}
- if yyb3847 {
+ if yyb3852 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -48567,13 +48631,13 @@ func (x *EventSource) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Component = string(r.DecodeString())
}
- yyj3847++
- if yyhl3847 {
- yyb3847 = yyj3847 > l
+ yyj3852++
+ if yyhl3852 {
+ yyb3852 = yyj3852 > l
} else {
- yyb3847 = r.CheckBreak()
+ yyb3852 = r.CheckBreak()
}
- if yyb3847 {
+ if yyb3852 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -48584,17 +48648,17 @@ func (x *EventSource) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
x.Host = string(r.DecodeString())
}
for {
- yyj3847++
- if yyhl3847 {
- yyb3847 = yyj3847 > l
+ yyj3852++
+ if yyhl3852 {
+ yyb3852 = yyj3852 > l
} else {
- yyb3847 = r.CheckBreak()
+ yyb3852 = r.CheckBreak()
}
- if yyb3847 {
+ if yyb3852 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj3847-1, "")
+ z.DecStructFieldNotFound(yyj3852-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -48606,43 +48670,43 @@ func (x *Event) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym3850 := z.EncBinary()
- _ = yym3850
+ yym3855 := z.EncBinary()
+ _ = yym3855
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep3851 := !z.EncBinary()
- yy2arr3851 := z.EncBasicHandle().StructToArray
- var yyq3851 [11]bool
- _, _, _ = yysep3851, yyq3851, yy2arr3851
- const yyr3851 bool = false
- yyq3851[0] = x.Kind != ""
- yyq3851[1] = x.APIVersion != ""
- yyq3851[4] = x.Reason != ""
- yyq3851[5] = x.Message != ""
- yyq3851[6] = true
- yyq3851[7] = true
- yyq3851[8] = true
- yyq3851[9] = x.Count != 0
- yyq3851[10] = x.Type != ""
- var yynn3851 int
- if yyr3851 || yy2arr3851 {
+ yysep3856 := !z.EncBinary()
+ yy2arr3856 := z.EncBasicHandle().StructToArray
+ var yyq3856 [11]bool
+ _, _, _ = yysep3856, yyq3856, yy2arr3856
+ const yyr3856 bool = false
+ yyq3856[0] = x.Kind != ""
+ yyq3856[1] = x.APIVersion != ""
+ yyq3856[4] = x.Reason != ""
+ yyq3856[5] = x.Message != ""
+ yyq3856[6] = true
+ yyq3856[7] = true
+ yyq3856[8] = true
+ yyq3856[9] = x.Count != 0
+ yyq3856[10] = x.Type != ""
+ var yynn3856 int
+ if yyr3856 || yy2arr3856 {
r.EncodeArrayStart(11)
} else {
- yynn3851 = 2
- for _, b := range yyq3851 {
+ yynn3856 = 2
+ for _, b := range yyq3856 {
if b {
- yynn3851++
+ yynn3856++
}
}
- r.EncodeMapStart(yynn3851)
- yynn3851 = 0
+ r.EncodeMapStart(yynn3856)
+ yynn3856 = 0
}
- if yyr3851 || yy2arr3851 {
+ if yyr3856 || yy2arr3856 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3851[0] {
- yym3853 := z.EncBinary()
- _ = yym3853
+ if yyq3856[0] {
+ yym3858 := z.EncBinary()
+ _ = yym3858
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
@@ -48651,23 +48715,23 @@ func (x *Event) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq3851[0] {
+ if yyq3856[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("kind"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3854 := z.EncBinary()
- _ = yym3854
+ yym3859 := z.EncBinary()
+ _ = yym3859
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
}
}
}
- if yyr3851 || yy2arr3851 {
+ if yyr3856 || yy2arr3856 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3851[1] {
- yym3856 := z.EncBinary()
- _ = yym3856
+ if yyq3856[1] {
+ yym3861 := z.EncBinary()
+ _ = yym3861
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
@@ -48676,45 +48740,45 @@ func (x *Event) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq3851[1] {
+ if yyq3856[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3857 := z.EncBinary()
- _ = yym3857
+ yym3862 := z.EncBinary()
+ _ = yym3862
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
}
}
}
- if yyr3851 || yy2arr3851 {
+ if yyr3856 || yy2arr3856 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy3859 := &x.ObjectMeta
- yy3859.CodecEncodeSelf(e)
+ yy3864 := &x.ObjectMeta
+ yy3864.CodecEncodeSelf(e)
} else {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("metadata"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy3860 := &x.ObjectMeta
- yy3860.CodecEncodeSelf(e)
+ yy3865 := &x.ObjectMeta
+ yy3865.CodecEncodeSelf(e)
}
- if yyr3851 || yy2arr3851 {
+ if yyr3856 || yy2arr3856 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy3862 := &x.InvolvedObject
- yy3862.CodecEncodeSelf(e)
+ yy3867 := &x.InvolvedObject
+ yy3867.CodecEncodeSelf(e)
} else {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("involvedObject"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy3863 := &x.InvolvedObject
- yy3863.CodecEncodeSelf(e)
+ yy3868 := &x.InvolvedObject
+ yy3868.CodecEncodeSelf(e)
}
- if yyr3851 || yy2arr3851 {
+ if yyr3856 || yy2arr3856 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3851[4] {
- yym3865 := z.EncBinary()
- _ = yym3865
+ if yyq3856[4] {
+ yym3870 := z.EncBinary()
+ _ = yym3870
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Reason))
@@ -48723,23 +48787,23 @@ func (x *Event) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq3851[4] {
+ if yyq3856[4] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("reason"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3866 := z.EncBinary()
- _ = yym3866
+ yym3871 := z.EncBinary()
+ _ = yym3871
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Reason))
}
}
}
- if yyr3851 || yy2arr3851 {
+ if yyr3856 || yy2arr3856 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3851[5] {
- yym3868 := z.EncBinary()
- _ = yym3868
+ if yyq3856[5] {
+ yym3873 := z.EncBinary()
+ _ = yym3873
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Message))
@@ -48748,76 +48812,39 @@ func (x *Event) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq3851[5] {
+ if yyq3856[5] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("message"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3869 := z.EncBinary()
- _ = yym3869
+ yym3874 := z.EncBinary()
+ _ = yym3874
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Message))
}
}
}
- if yyr3851 || yy2arr3851 {
+ if yyr3856 || yy2arr3856 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3851[6] {
- yy3871 := &x.Source
- yy3871.CodecEncodeSelf(e)
+ if yyq3856[6] {
+ yy3876 := &x.Source
+ yy3876.CodecEncodeSelf(e)
} else {
r.EncodeNil()
}
} else {
- if yyq3851[6] {
+ if yyq3856[6] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("source"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy3872 := &x.Source
- yy3872.CodecEncodeSelf(e)
+ yy3877 := &x.Source
+ yy3877.CodecEncodeSelf(e)
}
}
- if yyr3851 || yy2arr3851 {
+ if yyr3856 || yy2arr3856 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3851[7] {
- yy3874 := &x.FirstTimestamp
- yym3875 := z.EncBinary()
- _ = yym3875
- if false {
- } else if z.HasExtensions() && z.EncExt(yy3874) {
- } else if yym3875 {
- z.EncBinaryMarshal(yy3874)
- } else if !yym3875 && z.IsJSONHandle() {
- z.EncJSONMarshal(yy3874)
- } else {
- z.EncFallback(yy3874)
- }
- } else {
- r.EncodeNil()
- }
- } else {
- if yyq3851[7] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("firstTimestamp"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy3876 := &x.FirstTimestamp
- yym3877 := z.EncBinary()
- _ = yym3877
- if false {
- } else if z.HasExtensions() && z.EncExt(yy3876) {
- } else if yym3877 {
- z.EncBinaryMarshal(yy3876)
- } else if !yym3877 && z.IsJSONHandle() {
- z.EncJSONMarshal(yy3876)
- } else {
- z.EncFallback(yy3876)
- }
- }
- }
- if yyr3851 || yy2arr3851 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3851[8] {
- yy3879 := &x.LastTimestamp
+ if yyq3856[7] {
+ yy3879 := &x.FirstTimestamp
yym3880 := z.EncBinary()
_ = yym3880
if false {
@@ -48833,11 +48860,11 @@ func (x *Event) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeNil()
}
} else {
- if yyq3851[8] {
+ if yyq3856[7] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("lastTimestamp"))
+ r.EncodeString(codecSelferC_UTF81234, string("firstTimestamp"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy3881 := &x.LastTimestamp
+ yy3881 := &x.FirstTimestamp
yym3882 := z.EncBinary()
_ = yym3882
if false {
@@ -48851,11 +48878,48 @@ func (x *Event) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
- if yyr3851 || yy2arr3851 {
+ if yyr3856 || yy2arr3856 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3851[9] {
- yym3884 := z.EncBinary()
- _ = yym3884
+ if yyq3856[8] {
+ yy3884 := &x.LastTimestamp
+ yym3885 := z.EncBinary()
+ _ = yym3885
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy3884) {
+ } else if yym3885 {
+ z.EncBinaryMarshal(yy3884)
+ } else if !yym3885 && z.IsJSONHandle() {
+ z.EncJSONMarshal(yy3884)
+ } else {
+ z.EncFallback(yy3884)
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq3856[8] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("lastTimestamp"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yy3886 := &x.LastTimestamp
+ yym3887 := z.EncBinary()
+ _ = yym3887
+ if false {
+ } else if z.HasExtensions() && z.EncExt(yy3886) {
+ } else if yym3887 {
+ z.EncBinaryMarshal(yy3886)
+ } else if !yym3887 && z.IsJSONHandle() {
+ z.EncJSONMarshal(yy3886)
+ } else {
+ z.EncFallback(yy3886)
+ }
+ }
+ }
+ if yyr3856 || yy2arr3856 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq3856[9] {
+ yym3889 := z.EncBinary()
+ _ = yym3889
if false {
} else {
r.EncodeInt(int64(x.Count))
@@ -48864,23 +48928,23 @@ func (x *Event) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeInt(0)
}
} else {
- if yyq3851[9] {
+ if yyq3856[9] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("count"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3885 := z.EncBinary()
- _ = yym3885
+ yym3890 := z.EncBinary()
+ _ = yym3890
if false {
} else {
r.EncodeInt(int64(x.Count))
}
}
}
- if yyr3851 || yy2arr3851 {
+ if yyr3856 || yy2arr3856 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3851[10] {
- yym3887 := z.EncBinary()
- _ = yym3887
+ if yyq3856[10] {
+ yym3892 := z.EncBinary()
+ _ = yym3892
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Type))
@@ -48889,19 +48953,19 @@ func (x *Event) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq3851[10] {
+ if yyq3856[10] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("type"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3888 := z.EncBinary()
- _ = yym3888
+ yym3893 := z.EncBinary()
+ _ = yym3893
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Type))
}
}
}
- if yyr3851 || yy2arr3851 {
+ if yyr3856 || yy2arr3856 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -48914,25 +48978,25 @@ func (x *Event) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym3889 := z.DecBinary()
- _ = yym3889
+ yym3894 := z.DecBinary()
+ _ = yym3894
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct3890 := r.ContainerType()
- if yyct3890 == codecSelferValueTypeMap1234 {
- yyl3890 := r.ReadMapStart()
- if yyl3890 == 0 {
+ yyct3895 := r.ContainerType()
+ if yyct3895 == codecSelferValueTypeMap1234 {
+ yyl3895 := r.ReadMapStart()
+ if yyl3895 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl3890, d)
+ x.codecDecodeSelfFromMap(yyl3895, d)
}
- } else if yyct3890 == codecSelferValueTypeArray1234 {
- yyl3890 := r.ReadArrayStart()
- if yyl3890 == 0 {
+ } else if yyct3895 == codecSelferValueTypeArray1234 {
+ yyl3895 := r.ReadArrayStart()
+ if yyl3895 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl3890, d)
+ x.codecDecodeSelfFromArray(yyl3895, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -48944,12 +49008,12 @@ func (x *Event) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys3891Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys3891Slc
- var yyhl3891 bool = l >= 0
- for yyj3891 := 0; ; yyj3891++ {
- if yyhl3891 {
- if yyj3891 >= l {
+ var yys3896Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3896Slc
+ var yyhl3896 bool = l >= 0
+ for yyj3896 := 0; ; yyj3896++ {
+ if yyhl3896 {
+ if yyj3896 >= l {
break
}
} else {
@@ -48958,10 +49022,10 @@ func (x *Event) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys3891Slc = r.DecodeBytes(yys3891Slc, true, true)
- yys3891 := string(yys3891Slc)
+ yys3896Slc = r.DecodeBytes(yys3896Slc, true, true)
+ yys3896 := string(yys3896Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys3891 {
+ switch yys3896 {
case "kind":
if r.TryDecodeAsNil() {
x.Kind = ""
@@ -48978,15 +49042,15 @@ func (x *Event) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.ObjectMeta = ObjectMeta{}
} else {
- yyv3894 := &x.ObjectMeta
- yyv3894.CodecDecodeSelf(d)
+ yyv3899 := &x.ObjectMeta
+ yyv3899.CodecDecodeSelf(d)
}
case "involvedObject":
if r.TryDecodeAsNil() {
x.InvolvedObject = ObjectReference{}
} else {
- yyv3895 := &x.InvolvedObject
- yyv3895.CodecDecodeSelf(d)
+ yyv3900 := &x.InvolvedObject
+ yyv3900.CodecDecodeSelf(d)
}
case "reason":
if r.TryDecodeAsNil() {
@@ -49004,41 +49068,41 @@ func (x *Event) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Source = EventSource{}
} else {
- yyv3898 := &x.Source
- yyv3898.CodecDecodeSelf(d)
+ yyv3903 := &x.Source
+ yyv3903.CodecDecodeSelf(d)
}
case "firstTimestamp":
if r.TryDecodeAsNil() {
x.FirstTimestamp = pkg2_v1.Time{}
} else {
- yyv3899 := &x.FirstTimestamp
- yym3900 := z.DecBinary()
- _ = yym3900
+ yyv3904 := &x.FirstTimestamp
+ yym3905 := z.DecBinary()
+ _ = yym3905
if false {
- } else if z.HasExtensions() && z.DecExt(yyv3899) {
- } else if yym3900 {
- z.DecBinaryUnmarshal(yyv3899)
- } else if !yym3900 && z.IsJSONHandle() {
- z.DecJSONUnmarshal(yyv3899)
+ } else if z.HasExtensions() && z.DecExt(yyv3904) {
+ } else if yym3905 {
+ z.DecBinaryUnmarshal(yyv3904)
+ } else if !yym3905 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv3904)
} else {
- z.DecFallback(yyv3899, false)
+ z.DecFallback(yyv3904, false)
}
}
case "lastTimestamp":
if r.TryDecodeAsNil() {
x.LastTimestamp = pkg2_v1.Time{}
} else {
- yyv3901 := &x.LastTimestamp
- yym3902 := z.DecBinary()
- _ = yym3902
+ yyv3906 := &x.LastTimestamp
+ yym3907 := z.DecBinary()
+ _ = yym3907
if false {
- } else if z.HasExtensions() && z.DecExt(yyv3901) {
- } else if yym3902 {
- z.DecBinaryUnmarshal(yyv3901)
- } else if !yym3902 && z.IsJSONHandle() {
- z.DecJSONUnmarshal(yyv3901)
+ } else if z.HasExtensions() && z.DecExt(yyv3906) {
+ } else if yym3907 {
+ z.DecBinaryUnmarshal(yyv3906)
+ } else if !yym3907 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv3906)
} else {
- z.DecFallback(yyv3901, false)
+ z.DecFallback(yyv3906, false)
}
}
case "count":
@@ -49054,9 +49118,9 @@ func (x *Event) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
x.Type = string(r.DecodeString())
}
default:
- z.DecStructFieldNotFound(-1, yys3891)
- } // end switch yys3891
- } // end for yyj3891
+ z.DecStructFieldNotFound(-1, yys3896)
+ } // end switch yys3896
+ } // end for yyj3896
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -49064,16 +49128,16 @@ func (x *Event) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj3905 int
- var yyb3905 bool
- var yyhl3905 bool = l >= 0
- yyj3905++
- if yyhl3905 {
- yyb3905 = yyj3905 > l
+ var yyj3910 int
+ var yyb3910 bool
+ var yyhl3910 bool = l >= 0
+ yyj3910++
+ if yyhl3910 {
+ yyb3910 = yyj3910 > l
} else {
- yyb3905 = r.CheckBreak()
+ yyb3910 = r.CheckBreak()
}
- if yyb3905 {
+ if yyb3910 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -49083,13 +49147,13 @@ func (x *Event) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Kind = string(r.DecodeString())
}
- yyj3905++
- if yyhl3905 {
- yyb3905 = yyj3905 > l
+ yyj3910++
+ if yyhl3910 {
+ yyb3910 = yyj3910 > l
} else {
- yyb3905 = r.CheckBreak()
+ yyb3910 = r.CheckBreak()
}
- if yyb3905 {
+ if yyb3910 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -49099,13 +49163,13 @@ func (x *Event) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.APIVersion = string(r.DecodeString())
}
- yyj3905++
- if yyhl3905 {
- yyb3905 = yyj3905 > l
+ yyj3910++
+ if yyhl3910 {
+ yyb3910 = yyj3910 > l
} else {
- yyb3905 = r.CheckBreak()
+ yyb3910 = r.CheckBreak()
}
- if yyb3905 {
+ if yyb3910 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -49113,16 +49177,16 @@ func (x *Event) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.ObjectMeta = ObjectMeta{}
} else {
- yyv3908 := &x.ObjectMeta
- yyv3908.CodecDecodeSelf(d)
+ yyv3913 := &x.ObjectMeta
+ yyv3913.CodecDecodeSelf(d)
}
- yyj3905++
- if yyhl3905 {
- yyb3905 = yyj3905 > l
+ yyj3910++
+ if yyhl3910 {
+ yyb3910 = yyj3910 > l
} else {
- yyb3905 = r.CheckBreak()
+ yyb3910 = r.CheckBreak()
}
- if yyb3905 {
+ if yyb3910 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -49130,16 +49194,16 @@ func (x *Event) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.InvolvedObject = ObjectReference{}
} else {
- yyv3909 := &x.InvolvedObject
- yyv3909.CodecDecodeSelf(d)
+ yyv3914 := &x.InvolvedObject
+ yyv3914.CodecDecodeSelf(d)
}
- yyj3905++
- if yyhl3905 {
- yyb3905 = yyj3905 > l
+ yyj3910++
+ if yyhl3910 {
+ yyb3910 = yyj3910 > l
} else {
- yyb3905 = r.CheckBreak()
+ yyb3910 = r.CheckBreak()
}
- if yyb3905 {
+ if yyb3910 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -49149,13 +49213,13 @@ func (x *Event) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Reason = string(r.DecodeString())
}
- yyj3905++
- if yyhl3905 {
- yyb3905 = yyj3905 > l
+ yyj3910++
+ if yyhl3910 {
+ yyb3910 = yyj3910 > l
} else {
- yyb3905 = r.CheckBreak()
+ yyb3910 = r.CheckBreak()
}
- if yyb3905 {
+ if yyb3910 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -49165,13 +49229,13 @@ func (x *Event) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Message = string(r.DecodeString())
}
- yyj3905++
- if yyhl3905 {
- yyb3905 = yyj3905 > l
+ yyj3910++
+ if yyhl3910 {
+ yyb3910 = yyj3910 > l
} else {
- yyb3905 = r.CheckBreak()
+ yyb3910 = r.CheckBreak()
}
- if yyb3905 {
+ if yyb3910 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -49179,16 +49243,16 @@ func (x *Event) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Source = EventSource{}
} else {
- yyv3912 := &x.Source
- yyv3912.CodecDecodeSelf(d)
+ yyv3917 := &x.Source
+ yyv3917.CodecDecodeSelf(d)
}
- yyj3905++
- if yyhl3905 {
- yyb3905 = yyj3905 > l
+ yyj3910++
+ if yyhl3910 {
+ yyb3910 = yyj3910 > l
} else {
- yyb3905 = r.CheckBreak()
+ yyb3910 = r.CheckBreak()
}
- if yyb3905 {
+ if yyb3910 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -49196,26 +49260,26 @@ func (x *Event) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.FirstTimestamp = pkg2_v1.Time{}
} else {
- yyv3913 := &x.FirstTimestamp
- yym3914 := z.DecBinary()
- _ = yym3914
+ yyv3918 := &x.FirstTimestamp
+ yym3919 := z.DecBinary()
+ _ = yym3919
if false {
- } else if z.HasExtensions() && z.DecExt(yyv3913) {
- } else if yym3914 {
- z.DecBinaryUnmarshal(yyv3913)
- } else if !yym3914 && z.IsJSONHandle() {
- z.DecJSONUnmarshal(yyv3913)
+ } else if z.HasExtensions() && z.DecExt(yyv3918) {
+ } else if yym3919 {
+ z.DecBinaryUnmarshal(yyv3918)
+ } else if !yym3919 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv3918)
} else {
- z.DecFallback(yyv3913, false)
+ z.DecFallback(yyv3918, false)
}
}
- yyj3905++
- if yyhl3905 {
- yyb3905 = yyj3905 > l
+ yyj3910++
+ if yyhl3910 {
+ yyb3910 = yyj3910 > l
} else {
- yyb3905 = r.CheckBreak()
+ yyb3910 = r.CheckBreak()
}
- if yyb3905 {
+ if yyb3910 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -49223,26 +49287,26 @@ func (x *Event) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.LastTimestamp = pkg2_v1.Time{}
} else {
- yyv3915 := &x.LastTimestamp
- yym3916 := z.DecBinary()
- _ = yym3916
+ yyv3920 := &x.LastTimestamp
+ yym3921 := z.DecBinary()
+ _ = yym3921
if false {
- } else if z.HasExtensions() && z.DecExt(yyv3915) {
- } else if yym3916 {
- z.DecBinaryUnmarshal(yyv3915)
- } else if !yym3916 && z.IsJSONHandle() {
- z.DecJSONUnmarshal(yyv3915)
+ } else if z.HasExtensions() && z.DecExt(yyv3920) {
+ } else if yym3921 {
+ z.DecBinaryUnmarshal(yyv3920)
+ } else if !yym3921 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv3920)
} else {
- z.DecFallback(yyv3915, false)
+ z.DecFallback(yyv3920, false)
}
}
- yyj3905++
- if yyhl3905 {
- yyb3905 = yyj3905 > l
+ yyj3910++
+ if yyhl3910 {
+ yyb3910 = yyj3910 > l
} else {
- yyb3905 = r.CheckBreak()
+ yyb3910 = r.CheckBreak()
}
- if yyb3905 {
+ if yyb3910 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -49252,13 +49316,13 @@ func (x *Event) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Count = int32(r.DecodeInt(32))
}
- yyj3905++
- if yyhl3905 {
- yyb3905 = yyj3905 > l
+ yyj3910++
+ if yyhl3910 {
+ yyb3910 = yyj3910 > l
} else {
- yyb3905 = r.CheckBreak()
+ yyb3910 = r.CheckBreak()
}
- if yyb3905 {
+ if yyb3910 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -49269,17 +49333,17 @@ func (x *Event) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
x.Type = string(r.DecodeString())
}
for {
- yyj3905++
- if yyhl3905 {
- yyb3905 = yyj3905 > l
+ yyj3910++
+ if yyhl3910 {
+ yyb3910 = yyj3910 > l
} else {
- yyb3905 = r.CheckBreak()
+ yyb3910 = r.CheckBreak()
}
- if yyb3905 {
+ if yyb3910 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj3905-1, "")
+ z.DecStructFieldNotFound(yyj3910-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -49291,37 +49355,37 @@ func (x *EventList) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym3919 := z.EncBinary()
- _ = yym3919
+ yym3924 := z.EncBinary()
+ _ = yym3924
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep3920 := !z.EncBinary()
- yy2arr3920 := z.EncBasicHandle().StructToArray
- var yyq3920 [4]bool
- _, _, _ = yysep3920, yyq3920, yy2arr3920
- const yyr3920 bool = false
- yyq3920[0] = x.Kind != ""
- yyq3920[1] = x.APIVersion != ""
- yyq3920[2] = true
- var yynn3920 int
- if yyr3920 || yy2arr3920 {
+ yysep3925 := !z.EncBinary()
+ yy2arr3925 := z.EncBasicHandle().StructToArray
+ var yyq3925 [4]bool
+ _, _, _ = yysep3925, yyq3925, yy2arr3925
+ const yyr3925 bool = false
+ yyq3925[0] = x.Kind != ""
+ yyq3925[1] = x.APIVersion != ""
+ yyq3925[2] = true
+ var yynn3925 int
+ if yyr3925 || yy2arr3925 {
r.EncodeArrayStart(4)
} else {
- yynn3920 = 1
- for _, b := range yyq3920 {
+ yynn3925 = 1
+ for _, b := range yyq3925 {
if b {
- yynn3920++
+ yynn3925++
}
}
- r.EncodeMapStart(yynn3920)
- yynn3920 = 0
+ r.EncodeMapStart(yynn3925)
+ yynn3925 = 0
}
- if yyr3920 || yy2arr3920 {
+ if yyr3925 || yy2arr3925 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3920[0] {
- yym3922 := z.EncBinary()
- _ = yym3922
+ if yyq3925[0] {
+ yym3927 := z.EncBinary()
+ _ = yym3927
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
@@ -49330,23 +49394,23 @@ func (x *EventList) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq3920[0] {
+ if yyq3925[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("kind"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3923 := z.EncBinary()
- _ = yym3923
+ yym3928 := z.EncBinary()
+ _ = yym3928
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
}
}
}
- if yyr3920 || yy2arr3920 {
+ if yyr3925 || yy2arr3925 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3920[1] {
- yym3925 := z.EncBinary()
- _ = yym3925
+ if yyq3925[1] {
+ yym3930 := z.EncBinary()
+ _ = yym3930
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
@@ -49355,54 +49419,54 @@ func (x *EventList) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq3920[1] {
+ if yyq3925[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3926 := z.EncBinary()
- _ = yym3926
+ yym3931 := z.EncBinary()
+ _ = yym3931
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
}
}
}
- if yyr3920 || yy2arr3920 {
+ if yyr3925 || yy2arr3925 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3920[2] {
- yy3928 := &x.ListMeta
- yym3929 := z.EncBinary()
- _ = yym3929
+ if yyq3925[2] {
+ yy3933 := &x.ListMeta
+ yym3934 := z.EncBinary()
+ _ = yym3934
if false {
- } else if z.HasExtensions() && z.EncExt(yy3928) {
+ } else if z.HasExtensions() && z.EncExt(yy3933) {
} else {
- z.EncFallback(yy3928)
+ z.EncFallback(yy3933)
}
} else {
r.EncodeNil()
}
} else {
- if yyq3920[2] {
+ if yyq3925[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("metadata"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy3930 := &x.ListMeta
- yym3931 := z.EncBinary()
- _ = yym3931
+ yy3935 := &x.ListMeta
+ yym3936 := z.EncBinary()
+ _ = yym3936
if false {
- } else if z.HasExtensions() && z.EncExt(yy3930) {
+ } else if z.HasExtensions() && z.EncExt(yy3935) {
} else {
- z.EncFallback(yy3930)
+ z.EncFallback(yy3935)
}
}
}
- if yyr3920 || yy2arr3920 {
+ if yyr3925 || yy2arr3925 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if x.Items == nil {
r.EncodeNil()
} else {
- yym3933 := z.EncBinary()
- _ = yym3933
+ yym3938 := z.EncBinary()
+ _ = yym3938
if false {
} else {
h.encSliceEvent(([]Event)(x.Items), e)
@@ -49415,15 +49479,15 @@ func (x *EventList) CodecEncodeSelf(e *codec1978.Encoder) {
if x.Items == nil {
r.EncodeNil()
} else {
- yym3934 := z.EncBinary()
- _ = yym3934
+ yym3939 := z.EncBinary()
+ _ = yym3939
if false {
} else {
h.encSliceEvent(([]Event)(x.Items), e)
}
}
}
- if yyr3920 || yy2arr3920 {
+ if yyr3925 || yy2arr3925 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -49436,25 +49500,25 @@ func (x *EventList) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym3935 := z.DecBinary()
- _ = yym3935
+ yym3940 := z.DecBinary()
+ _ = yym3940
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct3936 := r.ContainerType()
- if yyct3936 == codecSelferValueTypeMap1234 {
- yyl3936 := r.ReadMapStart()
- if yyl3936 == 0 {
+ yyct3941 := r.ContainerType()
+ if yyct3941 == codecSelferValueTypeMap1234 {
+ yyl3941 := r.ReadMapStart()
+ if yyl3941 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl3936, d)
+ x.codecDecodeSelfFromMap(yyl3941, d)
}
- } else if yyct3936 == codecSelferValueTypeArray1234 {
- yyl3936 := r.ReadArrayStart()
- if yyl3936 == 0 {
+ } else if yyct3941 == codecSelferValueTypeArray1234 {
+ yyl3941 := r.ReadArrayStart()
+ if yyl3941 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl3936, d)
+ x.codecDecodeSelfFromArray(yyl3941, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -49466,12 +49530,12 @@ func (x *EventList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys3937Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys3937Slc
- var yyhl3937 bool = l >= 0
- for yyj3937 := 0; ; yyj3937++ {
- if yyhl3937 {
- if yyj3937 >= l {
+ var yys3942Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3942Slc
+ var yyhl3942 bool = l >= 0
+ for yyj3942 := 0; ; yyj3942++ {
+ if yyhl3942 {
+ if yyj3942 >= l {
break
}
} else {
@@ -49480,10 +49544,10 @@ func (x *EventList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys3937Slc = r.DecodeBytes(yys3937Slc, true, true)
- yys3937 := string(yys3937Slc)
+ yys3942Slc = r.DecodeBytes(yys3942Slc, true, true)
+ yys3942 := string(yys3942Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys3937 {
+ switch yys3942 {
case "kind":
if r.TryDecodeAsNil() {
x.Kind = ""
@@ -49500,31 +49564,31 @@ func (x *EventList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.ListMeta = pkg2_v1.ListMeta{}
} else {
- yyv3940 := &x.ListMeta
- yym3941 := z.DecBinary()
- _ = yym3941
+ yyv3945 := &x.ListMeta
+ yym3946 := z.DecBinary()
+ _ = yym3946
if false {
- } else if z.HasExtensions() && z.DecExt(yyv3940) {
+ } else if z.HasExtensions() && z.DecExt(yyv3945) {
} else {
- z.DecFallback(yyv3940, false)
+ z.DecFallback(yyv3945, false)
}
}
case "items":
if r.TryDecodeAsNil() {
x.Items = nil
} else {
- yyv3942 := &x.Items
- yym3943 := z.DecBinary()
- _ = yym3943
+ yyv3947 := &x.Items
+ yym3948 := z.DecBinary()
+ _ = yym3948
if false {
} else {
- h.decSliceEvent((*[]Event)(yyv3942), d)
+ h.decSliceEvent((*[]Event)(yyv3947), d)
}
}
default:
- z.DecStructFieldNotFound(-1, yys3937)
- } // end switch yys3937
- } // end for yyj3937
+ z.DecStructFieldNotFound(-1, yys3942)
+ } // end switch yys3942
+ } // end for yyj3942
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -49532,16 +49596,16 @@ func (x *EventList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj3944 int
- var yyb3944 bool
- var yyhl3944 bool = l >= 0
- yyj3944++
- if yyhl3944 {
- yyb3944 = yyj3944 > l
+ var yyj3949 int
+ var yyb3949 bool
+ var yyhl3949 bool = l >= 0
+ yyj3949++
+ if yyhl3949 {
+ yyb3949 = yyj3949 > l
} else {
- yyb3944 = r.CheckBreak()
+ yyb3949 = r.CheckBreak()
}
- if yyb3944 {
+ if yyb3949 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -49551,13 +49615,13 @@ func (x *EventList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Kind = string(r.DecodeString())
}
- yyj3944++
- if yyhl3944 {
- yyb3944 = yyj3944 > l
+ yyj3949++
+ if yyhl3949 {
+ yyb3949 = yyj3949 > l
} else {
- yyb3944 = r.CheckBreak()
+ yyb3949 = r.CheckBreak()
}
- if yyb3944 {
+ if yyb3949 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -49567,13 +49631,13 @@ func (x *EventList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.APIVersion = string(r.DecodeString())
}
- yyj3944++
- if yyhl3944 {
- yyb3944 = yyj3944 > l
+ yyj3949++
+ if yyhl3949 {
+ yyb3949 = yyj3949 > l
} else {
- yyb3944 = r.CheckBreak()
+ yyb3949 = r.CheckBreak()
}
- if yyb3944 {
+ if yyb3949 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -49581,22 +49645,22 @@ func (x *EventList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.ListMeta = pkg2_v1.ListMeta{}
} else {
- yyv3947 := &x.ListMeta
- yym3948 := z.DecBinary()
- _ = yym3948
+ yyv3952 := &x.ListMeta
+ yym3953 := z.DecBinary()
+ _ = yym3953
if false {
- } else if z.HasExtensions() && z.DecExt(yyv3947) {
+ } else if z.HasExtensions() && z.DecExt(yyv3952) {
} else {
- z.DecFallback(yyv3947, false)
+ z.DecFallback(yyv3952, false)
}
}
- yyj3944++
- if yyhl3944 {
- yyb3944 = yyj3944 > l
+ yyj3949++
+ if yyhl3949 {
+ yyb3949 = yyj3949 > l
} else {
- yyb3944 = r.CheckBreak()
+ yyb3949 = r.CheckBreak()
}
- if yyb3944 {
+ if yyb3949 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -49604,26 +49668,26 @@ func (x *EventList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Items = nil
} else {
- yyv3949 := &x.Items
- yym3950 := z.DecBinary()
- _ = yym3950
+ yyv3954 := &x.Items
+ yym3955 := z.DecBinary()
+ _ = yym3955
if false {
} else {
- h.decSliceEvent((*[]Event)(yyv3949), d)
+ h.decSliceEvent((*[]Event)(yyv3954), d)
}
}
for {
- yyj3944++
- if yyhl3944 {
- yyb3944 = yyj3944 > l
+ yyj3949++
+ if yyhl3949 {
+ yyb3949 = yyj3949 > l
} else {
- yyb3944 = r.CheckBreak()
+ yyb3949 = r.CheckBreak()
}
- if yyb3944 {
+ if yyb3949 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj3944-1, "")
+ z.DecStructFieldNotFound(yyj3949-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -49635,37 +49699,37 @@ func (x *List) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym3951 := z.EncBinary()
- _ = yym3951
+ yym3956 := z.EncBinary()
+ _ = yym3956
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep3952 := !z.EncBinary()
- yy2arr3952 := z.EncBasicHandle().StructToArray
- var yyq3952 [4]bool
- _, _, _ = yysep3952, yyq3952, yy2arr3952
- const yyr3952 bool = false
- yyq3952[0] = x.Kind != ""
- yyq3952[1] = x.APIVersion != ""
- yyq3952[2] = true
- var yynn3952 int
- if yyr3952 || yy2arr3952 {
+ yysep3957 := !z.EncBinary()
+ yy2arr3957 := z.EncBasicHandle().StructToArray
+ var yyq3957 [4]bool
+ _, _, _ = yysep3957, yyq3957, yy2arr3957
+ const yyr3957 bool = false
+ yyq3957[0] = x.Kind != ""
+ yyq3957[1] = x.APIVersion != ""
+ yyq3957[2] = true
+ var yynn3957 int
+ if yyr3957 || yy2arr3957 {
r.EncodeArrayStart(4)
} else {
- yynn3952 = 1
- for _, b := range yyq3952 {
+ yynn3957 = 1
+ for _, b := range yyq3957 {
if b {
- yynn3952++
+ yynn3957++
}
}
- r.EncodeMapStart(yynn3952)
- yynn3952 = 0
+ r.EncodeMapStart(yynn3957)
+ yynn3957 = 0
}
- if yyr3952 || yy2arr3952 {
+ if yyr3957 || yy2arr3957 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3952[0] {
- yym3954 := z.EncBinary()
- _ = yym3954
+ if yyq3957[0] {
+ yym3959 := z.EncBinary()
+ _ = yym3959
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
@@ -49674,23 +49738,23 @@ func (x *List) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq3952[0] {
+ if yyq3957[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("kind"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3955 := z.EncBinary()
- _ = yym3955
+ yym3960 := z.EncBinary()
+ _ = yym3960
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
}
}
}
- if yyr3952 || yy2arr3952 {
+ if yyr3957 || yy2arr3957 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3952[1] {
- yym3957 := z.EncBinary()
- _ = yym3957
+ if yyq3957[1] {
+ yym3962 := z.EncBinary()
+ _ = yym3962
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
@@ -49699,54 +49763,54 @@ func (x *List) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq3952[1] {
+ if yyq3957[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym3958 := z.EncBinary()
- _ = yym3958
+ yym3963 := z.EncBinary()
+ _ = yym3963
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
}
}
}
- if yyr3952 || yy2arr3952 {
+ if yyr3957 || yy2arr3957 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3952[2] {
- yy3960 := &x.ListMeta
- yym3961 := z.EncBinary()
- _ = yym3961
+ if yyq3957[2] {
+ yy3965 := &x.ListMeta
+ yym3966 := z.EncBinary()
+ _ = yym3966
if false {
- } else if z.HasExtensions() && z.EncExt(yy3960) {
+ } else if z.HasExtensions() && z.EncExt(yy3965) {
} else {
- z.EncFallback(yy3960)
+ z.EncFallback(yy3965)
}
} else {
r.EncodeNil()
}
} else {
- if yyq3952[2] {
+ if yyq3957[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("metadata"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy3962 := &x.ListMeta
- yym3963 := z.EncBinary()
- _ = yym3963
+ yy3967 := &x.ListMeta
+ yym3968 := z.EncBinary()
+ _ = yym3968
if false {
- } else if z.HasExtensions() && z.EncExt(yy3962) {
+ } else if z.HasExtensions() && z.EncExt(yy3967) {
} else {
- z.EncFallback(yy3962)
+ z.EncFallback(yy3967)
}
}
}
- if yyr3952 || yy2arr3952 {
+ if yyr3957 || yy2arr3957 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if x.Items == nil {
r.EncodeNil()
} else {
- yym3965 := z.EncBinary()
- _ = yym3965
+ yym3970 := z.EncBinary()
+ _ = yym3970
if false {
} else {
h.encSliceruntime_RawExtension(([]pkg5_runtime.RawExtension)(x.Items), e)
@@ -49759,15 +49823,15 @@ func (x *List) CodecEncodeSelf(e *codec1978.Encoder) {
if x.Items == nil {
r.EncodeNil()
} else {
- yym3966 := z.EncBinary()
- _ = yym3966
+ yym3971 := z.EncBinary()
+ _ = yym3971
if false {
} else {
h.encSliceruntime_RawExtension(([]pkg5_runtime.RawExtension)(x.Items), e)
}
}
}
- if yyr3952 || yy2arr3952 {
+ if yyr3957 || yy2arr3957 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -49780,25 +49844,25 @@ func (x *List) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym3967 := z.DecBinary()
- _ = yym3967
+ yym3972 := z.DecBinary()
+ _ = yym3972
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct3968 := r.ContainerType()
- if yyct3968 == codecSelferValueTypeMap1234 {
- yyl3968 := r.ReadMapStart()
- if yyl3968 == 0 {
+ yyct3973 := r.ContainerType()
+ if yyct3973 == codecSelferValueTypeMap1234 {
+ yyl3973 := r.ReadMapStart()
+ if yyl3973 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl3968, d)
+ x.codecDecodeSelfFromMap(yyl3973, d)
}
- } else if yyct3968 == codecSelferValueTypeArray1234 {
- yyl3968 := r.ReadArrayStart()
- if yyl3968 == 0 {
+ } else if yyct3973 == codecSelferValueTypeArray1234 {
+ yyl3973 := r.ReadArrayStart()
+ if yyl3973 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl3968, d)
+ x.codecDecodeSelfFromArray(yyl3973, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -49810,12 +49874,12 @@ func (x *List) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys3969Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys3969Slc
- var yyhl3969 bool = l >= 0
- for yyj3969 := 0; ; yyj3969++ {
- if yyhl3969 {
- if yyj3969 >= l {
+ var yys3974Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys3974Slc
+ var yyhl3974 bool = l >= 0
+ for yyj3974 := 0; ; yyj3974++ {
+ if yyhl3974 {
+ if yyj3974 >= l {
break
}
} else {
@@ -49824,10 +49888,10 @@ func (x *List) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys3969Slc = r.DecodeBytes(yys3969Slc, true, true)
- yys3969 := string(yys3969Slc)
+ yys3974Slc = r.DecodeBytes(yys3974Slc, true, true)
+ yys3974 := string(yys3974Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys3969 {
+ switch yys3974 {
case "kind":
if r.TryDecodeAsNil() {
x.Kind = ""
@@ -49844,31 +49908,31 @@ func (x *List) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.ListMeta = pkg2_v1.ListMeta{}
} else {
- yyv3972 := &x.ListMeta
- yym3973 := z.DecBinary()
- _ = yym3973
+ yyv3977 := &x.ListMeta
+ yym3978 := z.DecBinary()
+ _ = yym3978
if false {
- } else if z.HasExtensions() && z.DecExt(yyv3972) {
+ } else if z.HasExtensions() && z.DecExt(yyv3977) {
} else {
- z.DecFallback(yyv3972, false)
+ z.DecFallback(yyv3977, false)
}
}
case "items":
if r.TryDecodeAsNil() {
x.Items = nil
} else {
- yyv3974 := &x.Items
- yym3975 := z.DecBinary()
- _ = yym3975
+ yyv3979 := &x.Items
+ yym3980 := z.DecBinary()
+ _ = yym3980
if false {
} else {
- h.decSliceruntime_RawExtension((*[]pkg5_runtime.RawExtension)(yyv3974), d)
+ h.decSliceruntime_RawExtension((*[]pkg5_runtime.RawExtension)(yyv3979), d)
}
}
default:
- z.DecStructFieldNotFound(-1, yys3969)
- } // end switch yys3969
- } // end for yyj3969
+ z.DecStructFieldNotFound(-1, yys3974)
+ } // end switch yys3974
+ } // end for yyj3974
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -49876,16 +49940,16 @@ func (x *List) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj3976 int
- var yyb3976 bool
- var yyhl3976 bool = l >= 0
- yyj3976++
- if yyhl3976 {
- yyb3976 = yyj3976 > l
+ var yyj3981 int
+ var yyb3981 bool
+ var yyhl3981 bool = l >= 0
+ yyj3981++
+ if yyhl3981 {
+ yyb3981 = yyj3981 > l
} else {
- yyb3976 = r.CheckBreak()
+ yyb3981 = r.CheckBreak()
}
- if yyb3976 {
+ if yyb3981 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -49895,13 +49959,13 @@ func (x *List) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Kind = string(r.DecodeString())
}
- yyj3976++
- if yyhl3976 {
- yyb3976 = yyj3976 > l
+ yyj3981++
+ if yyhl3981 {
+ yyb3981 = yyj3981 > l
} else {
- yyb3976 = r.CheckBreak()
+ yyb3981 = r.CheckBreak()
}
- if yyb3976 {
+ if yyb3981 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -49911,13 +49975,13 @@ func (x *List) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.APIVersion = string(r.DecodeString())
}
- yyj3976++
- if yyhl3976 {
- yyb3976 = yyj3976 > l
+ yyj3981++
+ if yyhl3981 {
+ yyb3981 = yyj3981 > l
} else {
- yyb3976 = r.CheckBreak()
+ yyb3981 = r.CheckBreak()
}
- if yyb3976 {
+ if yyb3981 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -49925,22 +49989,22 @@ func (x *List) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.ListMeta = pkg2_v1.ListMeta{}
} else {
- yyv3979 := &x.ListMeta
- yym3980 := z.DecBinary()
- _ = yym3980
+ yyv3984 := &x.ListMeta
+ yym3985 := z.DecBinary()
+ _ = yym3985
if false {
- } else if z.HasExtensions() && z.DecExt(yyv3979) {
+ } else if z.HasExtensions() && z.DecExt(yyv3984) {
} else {
- z.DecFallback(yyv3979, false)
+ z.DecFallback(yyv3984, false)
}
}
- yyj3976++
- if yyhl3976 {
- yyb3976 = yyj3976 > l
+ yyj3981++
+ if yyhl3981 {
+ yyb3981 = yyj3981 > l
} else {
- yyb3976 = r.CheckBreak()
+ yyb3981 = r.CheckBreak()
}
- if yyb3976 {
+ if yyb3981 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -49948,26 +50012,26 @@ func (x *List) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Items = nil
} else {
- yyv3981 := &x.Items
- yym3982 := z.DecBinary()
- _ = yym3982
+ yyv3986 := &x.Items
+ yym3987 := z.DecBinary()
+ _ = yym3987
if false {
} else {
- h.decSliceruntime_RawExtension((*[]pkg5_runtime.RawExtension)(yyv3981), d)
+ h.decSliceruntime_RawExtension((*[]pkg5_runtime.RawExtension)(yyv3986), d)
}
}
for {
- yyj3976++
- if yyhl3976 {
- yyb3976 = yyj3976 > l
+ yyj3981++
+ if yyhl3981 {
+ yyb3981 = yyj3981 > l
} else {
- yyb3976 = r.CheckBreak()
+ yyb3981 = r.CheckBreak()
}
- if yyb3976 {
+ if yyb3981 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj3976-1, "")
+ z.DecStructFieldNotFound(yyj3981-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -49976,8 +50040,8 @@ func (x LimitType) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
- yym3983 := z.EncBinary()
- _ = yym3983
+ yym3988 := z.EncBinary()
+ _ = yym3988
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
@@ -49989,8 +50053,8 @@ func (x *LimitType) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym3984 := z.DecBinary()
- _ = yym3984
+ yym3989 := z.DecBinary()
+ _ = yym3989
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
@@ -50005,53 +50069,53 @@ func (x *LimitRangeItem) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym3985 := z.EncBinary()
- _ = yym3985
+ yym3990 := z.EncBinary()
+ _ = yym3990
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep3986 := !z.EncBinary()
- yy2arr3986 := z.EncBasicHandle().StructToArray
- var yyq3986 [6]bool
- _, _, _ = yysep3986, yyq3986, yy2arr3986
- const yyr3986 bool = false
- yyq3986[0] = x.Type != ""
- yyq3986[1] = len(x.Max) != 0
- yyq3986[2] = len(x.Min) != 0
- yyq3986[3] = len(x.Default) != 0
- yyq3986[4] = len(x.DefaultRequest) != 0
- yyq3986[5] = len(x.MaxLimitRequestRatio) != 0
- var yynn3986 int
- if yyr3986 || yy2arr3986 {
+ yysep3991 := !z.EncBinary()
+ yy2arr3991 := z.EncBasicHandle().StructToArray
+ var yyq3991 [6]bool
+ _, _, _ = yysep3991, yyq3991, yy2arr3991
+ const yyr3991 bool = false
+ yyq3991[0] = x.Type != ""
+ yyq3991[1] = len(x.Max) != 0
+ yyq3991[2] = len(x.Min) != 0
+ yyq3991[3] = len(x.Default) != 0
+ yyq3991[4] = len(x.DefaultRequest) != 0
+ yyq3991[5] = len(x.MaxLimitRequestRatio) != 0
+ var yynn3991 int
+ if yyr3991 || yy2arr3991 {
r.EncodeArrayStart(6)
} else {
- yynn3986 = 0
- for _, b := range yyq3986 {
+ yynn3991 = 0
+ for _, b := range yyq3991 {
if b {
- yynn3986++
+ yynn3991++
}
}
- r.EncodeMapStart(yynn3986)
- yynn3986 = 0
+ r.EncodeMapStart(yynn3991)
+ yynn3991 = 0
}
- if yyr3986 || yy2arr3986 {
+ if yyr3991 || yy2arr3991 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3986[0] {
+ if yyq3991[0] {
x.Type.CodecEncodeSelf(e)
} else {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq3986[0] {
+ if yyq3991[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("type"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
x.Type.CodecEncodeSelf(e)
}
}
- if yyr3986 || yy2arr3986 {
+ if yyr3991 || yy2arr3991 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3986[1] {
+ if yyq3991[1] {
if x.Max == nil {
r.EncodeNil()
} else {
@@ -50061,7 +50125,7 @@ func (x *LimitRangeItem) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeNil()
}
} else {
- if yyq3986[1] {
+ if yyq3991[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("max"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
@@ -50072,9 +50136,9 @@ func (x *LimitRangeItem) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
- if yyr3986 || yy2arr3986 {
+ if yyr3991 || yy2arr3991 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3986[2] {
+ if yyq3991[2] {
if x.Min == nil {
r.EncodeNil()
} else {
@@ -50084,7 +50148,7 @@ func (x *LimitRangeItem) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeNil()
}
} else {
- if yyq3986[2] {
+ if yyq3991[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("min"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
@@ -50095,9 +50159,9 @@ func (x *LimitRangeItem) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
- if yyr3986 || yy2arr3986 {
+ if yyr3991 || yy2arr3991 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3986[3] {
+ if yyq3991[3] {
if x.Default == nil {
r.EncodeNil()
} else {
@@ -50107,7 +50171,7 @@ func (x *LimitRangeItem) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeNil()
}
} else {
- if yyq3986[3] {
+ if yyq3991[3] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("default"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
@@ -50118,9 +50182,9 @@ func (x *LimitRangeItem) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
- if yyr3986 || yy2arr3986 {
+ if yyr3991 || yy2arr3991 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3986[4] {
+ if yyq3991[4] {
if x.DefaultRequest == nil {
r.EncodeNil()
} else {
@@ -50130,7 +50194,7 @@ func (x *LimitRangeItem) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeNil()
}
} else {
- if yyq3986[4] {
+ if yyq3991[4] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("defaultRequest"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
@@ -50141,9 +50205,9 @@ func (x *LimitRangeItem) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
- if yyr3986 || yy2arr3986 {
+ if yyr3991 || yy2arr3991 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq3986[5] {
+ if yyq3991[5] {
if x.MaxLimitRequestRatio == nil {
r.EncodeNil()
} else {
@@ -50153,7 +50217,7 @@ func (x *LimitRangeItem) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeNil()
}
} else {
- if yyq3986[5] {
+ if yyq3991[5] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("maxLimitRequestRatio"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
@@ -50164,7 +50228,7 @@ func (x *LimitRangeItem) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
- if yyr3986 || yy2arr3986 {
+ if yyr3991 || yy2arr3991 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -50177,25 +50241,25 @@ func (x *LimitRangeItem) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym3993 := z.DecBinary()
- _ = yym3993
+ yym3998 := z.DecBinary()
+ _ = yym3998
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct3994 := r.ContainerType()
- if yyct3994 == codecSelferValueTypeMap1234 {
- yyl3994 := r.ReadMapStart()
- if yyl3994 == 0 {
+ yyct3999 := r.ContainerType()
+ if yyct3999 == codecSelferValueTypeMap1234 {
+ yyl3999 := r.ReadMapStart()
+ if yyl3999 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl3994, d)
+ x.codecDecodeSelfFromMap(yyl3999, d)
}
- } else if yyct3994 == codecSelferValueTypeArray1234 {
- yyl3994 := r.ReadArrayStart()
- if yyl3994 == 0 {
+ } else if yyct3999 == codecSelferValueTypeArray1234 {
+ yyl3999 := r.ReadArrayStart()
+ if yyl3999 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl3994, d)
+ x.codecDecodeSelfFromArray(yyl3999, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -50207,12 +50271,12 @@ func (x *LimitRangeItem) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys3995Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys3995Slc
- var yyhl3995 bool = l >= 0
- for yyj3995 := 0; ; yyj3995++ {
- if yyhl3995 {
- if yyj3995 >= l {
+ var yys4000Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys4000Slc
+ var yyhl4000 bool = l >= 0
+ for yyj4000 := 0; ; yyj4000++ {
+ if yyhl4000 {
+ if yyj4000 >= l {
break
}
} else {
@@ -50221,10 +50285,10 @@ func (x *LimitRangeItem) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys3995Slc = r.DecodeBytes(yys3995Slc, true, true)
- yys3995 := string(yys3995Slc)
+ yys4000Slc = r.DecodeBytes(yys4000Slc, true, true)
+ yys4000 := string(yys4000Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys3995 {
+ switch yys4000 {
case "type":
if r.TryDecodeAsNil() {
x.Type = ""
@@ -50235,41 +50299,41 @@ func (x *LimitRangeItem) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Max = nil
} else {
- yyv3997 := &x.Max
- yyv3997.CodecDecodeSelf(d)
+ yyv4002 := &x.Max
+ yyv4002.CodecDecodeSelf(d)
}
case "min":
if r.TryDecodeAsNil() {
x.Min = nil
} else {
- yyv3998 := &x.Min
- yyv3998.CodecDecodeSelf(d)
+ yyv4003 := &x.Min
+ yyv4003.CodecDecodeSelf(d)
}
case "default":
if r.TryDecodeAsNil() {
x.Default = nil
} else {
- yyv3999 := &x.Default
- yyv3999.CodecDecodeSelf(d)
+ yyv4004 := &x.Default
+ yyv4004.CodecDecodeSelf(d)
}
case "defaultRequest":
if r.TryDecodeAsNil() {
x.DefaultRequest = nil
} else {
- yyv4000 := &x.DefaultRequest
- yyv4000.CodecDecodeSelf(d)
+ yyv4005 := &x.DefaultRequest
+ yyv4005.CodecDecodeSelf(d)
}
case "maxLimitRequestRatio":
if r.TryDecodeAsNil() {
x.MaxLimitRequestRatio = nil
} else {
- yyv4001 := &x.MaxLimitRequestRatio
- yyv4001.CodecDecodeSelf(d)
+ yyv4006 := &x.MaxLimitRequestRatio
+ yyv4006.CodecDecodeSelf(d)
}
default:
- z.DecStructFieldNotFound(-1, yys3995)
- } // end switch yys3995
- } // end for yyj3995
+ z.DecStructFieldNotFound(-1, yys4000)
+ } // end switch yys4000
+ } // end for yyj4000
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -50277,16 +50341,16 @@ func (x *LimitRangeItem) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj4002 int
- var yyb4002 bool
- var yyhl4002 bool = l >= 0
- yyj4002++
- if yyhl4002 {
- yyb4002 = yyj4002 > l
+ var yyj4007 int
+ var yyb4007 bool
+ var yyhl4007 bool = l >= 0
+ yyj4007++
+ if yyhl4007 {
+ yyb4007 = yyj4007 > l
} else {
- yyb4002 = r.CheckBreak()
+ yyb4007 = r.CheckBreak()
}
- if yyb4002 {
+ if yyb4007 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -50296,13 +50360,13 @@ func (x *LimitRangeItem) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Type = LimitType(r.DecodeString())
}
- yyj4002++
- if yyhl4002 {
- yyb4002 = yyj4002 > l
+ yyj4007++
+ if yyhl4007 {
+ yyb4007 = yyj4007 > l
} else {
- yyb4002 = r.CheckBreak()
+ yyb4007 = r.CheckBreak()
}
- if yyb4002 {
+ if yyb4007 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -50310,16 +50374,16 @@ func (x *LimitRangeItem) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Max = nil
} else {
- yyv4004 := &x.Max
- yyv4004.CodecDecodeSelf(d)
+ yyv4009 := &x.Max
+ yyv4009.CodecDecodeSelf(d)
}
- yyj4002++
- if yyhl4002 {
- yyb4002 = yyj4002 > l
+ yyj4007++
+ if yyhl4007 {
+ yyb4007 = yyj4007 > l
} else {
- yyb4002 = r.CheckBreak()
+ yyb4007 = r.CheckBreak()
}
- if yyb4002 {
+ if yyb4007 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -50327,16 +50391,16 @@ func (x *LimitRangeItem) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Min = nil
} else {
- yyv4005 := &x.Min
- yyv4005.CodecDecodeSelf(d)
+ yyv4010 := &x.Min
+ yyv4010.CodecDecodeSelf(d)
}
- yyj4002++
- if yyhl4002 {
- yyb4002 = yyj4002 > l
+ yyj4007++
+ if yyhl4007 {
+ yyb4007 = yyj4007 > l
} else {
- yyb4002 = r.CheckBreak()
+ yyb4007 = r.CheckBreak()
}
- if yyb4002 {
+ if yyb4007 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -50344,16 +50408,16 @@ func (x *LimitRangeItem) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Default = nil
} else {
- yyv4006 := &x.Default
- yyv4006.CodecDecodeSelf(d)
+ yyv4011 := &x.Default
+ yyv4011.CodecDecodeSelf(d)
}
- yyj4002++
- if yyhl4002 {
- yyb4002 = yyj4002 > l
+ yyj4007++
+ if yyhl4007 {
+ yyb4007 = yyj4007 > l
} else {
- yyb4002 = r.CheckBreak()
+ yyb4007 = r.CheckBreak()
}
- if yyb4002 {
+ if yyb4007 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -50361,16 +50425,16 @@ func (x *LimitRangeItem) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.DefaultRequest = nil
} else {
- yyv4007 := &x.DefaultRequest
- yyv4007.CodecDecodeSelf(d)
+ yyv4012 := &x.DefaultRequest
+ yyv4012.CodecDecodeSelf(d)
}
- yyj4002++
- if yyhl4002 {
- yyb4002 = yyj4002 > l
+ yyj4007++
+ if yyhl4007 {
+ yyb4007 = yyj4007 > l
} else {
- yyb4002 = r.CheckBreak()
+ yyb4007 = r.CheckBreak()
}
- if yyb4002 {
+ if yyb4007 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -50378,21 +50442,21 @@ func (x *LimitRangeItem) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.MaxLimitRequestRatio = nil
} else {
- yyv4008 := &x.MaxLimitRequestRatio
- yyv4008.CodecDecodeSelf(d)
+ yyv4013 := &x.MaxLimitRequestRatio
+ yyv4013.CodecDecodeSelf(d)
}
for {
- yyj4002++
- if yyhl4002 {
- yyb4002 = yyj4002 > l
+ yyj4007++
+ if yyhl4007 {
+ yyb4007 = yyj4007 > l
} else {
- yyb4002 = r.CheckBreak()
+ yyb4007 = r.CheckBreak()
}
- if yyb4002 {
+ if yyb4007 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj4002-1, "")
+ z.DecStructFieldNotFound(yyj4007-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -50404,36 +50468,36 @@ func (x *LimitRangeSpec) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym4009 := z.EncBinary()
- _ = yym4009
+ yym4014 := z.EncBinary()
+ _ = yym4014
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep4010 := !z.EncBinary()
- yy2arr4010 := z.EncBasicHandle().StructToArray
- var yyq4010 [1]bool
- _, _, _ = yysep4010, yyq4010, yy2arr4010
- const yyr4010 bool = false
- var yynn4010 int
- if yyr4010 || yy2arr4010 {
+ yysep4015 := !z.EncBinary()
+ yy2arr4015 := z.EncBasicHandle().StructToArray
+ var yyq4015 [1]bool
+ _, _, _ = yysep4015, yyq4015, yy2arr4015
+ const yyr4015 bool = false
+ var yynn4015 int
+ if yyr4015 || yy2arr4015 {
r.EncodeArrayStart(1)
} else {
- yynn4010 = 1
- for _, b := range yyq4010 {
+ yynn4015 = 1
+ for _, b := range yyq4015 {
if b {
- yynn4010++
+ yynn4015++
}
}
- r.EncodeMapStart(yynn4010)
- yynn4010 = 0
+ r.EncodeMapStart(yynn4015)
+ yynn4015 = 0
}
- if yyr4010 || yy2arr4010 {
+ if yyr4015 || yy2arr4015 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if x.Limits == nil {
r.EncodeNil()
} else {
- yym4012 := z.EncBinary()
- _ = yym4012
+ yym4017 := z.EncBinary()
+ _ = yym4017
if false {
} else {
h.encSliceLimitRangeItem(([]LimitRangeItem)(x.Limits), e)
@@ -50446,15 +50510,15 @@ func (x *LimitRangeSpec) CodecEncodeSelf(e *codec1978.Encoder) {
if x.Limits == nil {
r.EncodeNil()
} else {
- yym4013 := z.EncBinary()
- _ = yym4013
+ yym4018 := z.EncBinary()
+ _ = yym4018
if false {
} else {
h.encSliceLimitRangeItem(([]LimitRangeItem)(x.Limits), e)
}
}
}
- if yyr4010 || yy2arr4010 {
+ if yyr4015 || yy2arr4015 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -50467,25 +50531,25 @@ func (x *LimitRangeSpec) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym4014 := z.DecBinary()
- _ = yym4014
+ yym4019 := z.DecBinary()
+ _ = yym4019
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct4015 := r.ContainerType()
- if yyct4015 == codecSelferValueTypeMap1234 {
- yyl4015 := r.ReadMapStart()
- if yyl4015 == 0 {
+ yyct4020 := r.ContainerType()
+ if yyct4020 == codecSelferValueTypeMap1234 {
+ yyl4020 := r.ReadMapStart()
+ if yyl4020 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl4015, d)
+ x.codecDecodeSelfFromMap(yyl4020, d)
}
- } else if yyct4015 == codecSelferValueTypeArray1234 {
- yyl4015 := r.ReadArrayStart()
- if yyl4015 == 0 {
+ } else if yyct4020 == codecSelferValueTypeArray1234 {
+ yyl4020 := r.ReadArrayStart()
+ if yyl4020 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl4015, d)
+ x.codecDecodeSelfFromArray(yyl4020, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -50497,12 +50561,12 @@ func (x *LimitRangeSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys4016Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys4016Slc
- var yyhl4016 bool = l >= 0
- for yyj4016 := 0; ; yyj4016++ {
- if yyhl4016 {
- if yyj4016 >= l {
+ var yys4021Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys4021Slc
+ var yyhl4021 bool = l >= 0
+ for yyj4021 := 0; ; yyj4021++ {
+ if yyhl4021 {
+ if yyj4021 >= l {
break
}
} else {
@@ -50511,26 +50575,26 @@ func (x *LimitRangeSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys4016Slc = r.DecodeBytes(yys4016Slc, true, true)
- yys4016 := string(yys4016Slc)
+ yys4021Slc = r.DecodeBytes(yys4021Slc, true, true)
+ yys4021 := string(yys4021Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys4016 {
+ switch yys4021 {
case "limits":
if r.TryDecodeAsNil() {
x.Limits = nil
} else {
- yyv4017 := &x.Limits
- yym4018 := z.DecBinary()
- _ = yym4018
+ yyv4022 := &x.Limits
+ yym4023 := z.DecBinary()
+ _ = yym4023
if false {
} else {
- h.decSliceLimitRangeItem((*[]LimitRangeItem)(yyv4017), d)
+ h.decSliceLimitRangeItem((*[]LimitRangeItem)(yyv4022), d)
}
}
default:
- z.DecStructFieldNotFound(-1, yys4016)
- } // end switch yys4016
- } // end for yyj4016
+ z.DecStructFieldNotFound(-1, yys4021)
+ } // end switch yys4021
+ } // end for yyj4021
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -50538,16 +50602,16 @@ func (x *LimitRangeSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj4019 int
- var yyb4019 bool
- var yyhl4019 bool = l >= 0
- yyj4019++
- if yyhl4019 {
- yyb4019 = yyj4019 > l
+ var yyj4024 int
+ var yyb4024 bool
+ var yyhl4024 bool = l >= 0
+ yyj4024++
+ if yyhl4024 {
+ yyb4024 = yyj4024 > l
} else {
- yyb4019 = r.CheckBreak()
+ yyb4024 = r.CheckBreak()
}
- if yyb4019 {
+ if yyb4024 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -50555,26 +50619,26 @@ func (x *LimitRangeSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Limits = nil
} else {
- yyv4020 := &x.Limits
- yym4021 := z.DecBinary()
- _ = yym4021
+ yyv4025 := &x.Limits
+ yym4026 := z.DecBinary()
+ _ = yym4026
if false {
} else {
- h.decSliceLimitRangeItem((*[]LimitRangeItem)(yyv4020), d)
+ h.decSliceLimitRangeItem((*[]LimitRangeItem)(yyv4025), d)
}
}
for {
- yyj4019++
- if yyhl4019 {
- yyb4019 = yyj4019 > l
+ yyj4024++
+ if yyhl4024 {
+ yyb4024 = yyj4024 > l
} else {
- yyb4019 = r.CheckBreak()
+ yyb4024 = r.CheckBreak()
}
- if yyb4019 {
+ if yyb4024 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj4019-1, "")
+ z.DecStructFieldNotFound(yyj4024-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -50586,38 +50650,38 @@ func (x *LimitRange) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym4022 := z.EncBinary()
- _ = yym4022
+ yym4027 := z.EncBinary()
+ _ = yym4027
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep4023 := !z.EncBinary()
- yy2arr4023 := z.EncBasicHandle().StructToArray
- var yyq4023 [4]bool
- _, _, _ = yysep4023, yyq4023, yy2arr4023
- const yyr4023 bool = false
- yyq4023[0] = x.Kind != ""
- yyq4023[1] = x.APIVersion != ""
- yyq4023[2] = true
- yyq4023[3] = true
- var yynn4023 int
- if yyr4023 || yy2arr4023 {
+ yysep4028 := !z.EncBinary()
+ yy2arr4028 := z.EncBasicHandle().StructToArray
+ var yyq4028 [4]bool
+ _, _, _ = yysep4028, yyq4028, yy2arr4028
+ const yyr4028 bool = false
+ yyq4028[0] = x.Kind != ""
+ yyq4028[1] = x.APIVersion != ""
+ yyq4028[2] = true
+ yyq4028[3] = true
+ var yynn4028 int
+ if yyr4028 || yy2arr4028 {
r.EncodeArrayStart(4)
} else {
- yynn4023 = 0
- for _, b := range yyq4023 {
+ yynn4028 = 0
+ for _, b := range yyq4028 {
if b {
- yynn4023++
+ yynn4028++
}
}
- r.EncodeMapStart(yynn4023)
- yynn4023 = 0
+ r.EncodeMapStart(yynn4028)
+ yynn4028 = 0
}
- if yyr4023 || yy2arr4023 {
+ if yyr4028 || yy2arr4028 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq4023[0] {
- yym4025 := z.EncBinary()
- _ = yym4025
+ if yyq4028[0] {
+ yym4030 := z.EncBinary()
+ _ = yym4030
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
@@ -50626,23 +50690,23 @@ func (x *LimitRange) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq4023[0] {
+ if yyq4028[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("kind"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym4026 := z.EncBinary()
- _ = yym4026
+ yym4031 := z.EncBinary()
+ _ = yym4031
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
}
}
}
- if yyr4023 || yy2arr4023 {
+ if yyr4028 || yy2arr4028 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq4023[1] {
- yym4028 := z.EncBinary()
- _ = yym4028
+ if yyq4028[1] {
+ yym4033 := z.EncBinary()
+ _ = yym4033
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
@@ -50651,53 +50715,53 @@ func (x *LimitRange) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq4023[1] {
+ if yyq4028[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym4029 := z.EncBinary()
- _ = yym4029
+ yym4034 := z.EncBinary()
+ _ = yym4034
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
}
}
}
- if yyr4023 || yy2arr4023 {
+ if yyr4028 || yy2arr4028 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq4023[2] {
- yy4031 := &x.ObjectMeta
- yy4031.CodecEncodeSelf(e)
+ if yyq4028[2] {
+ yy4036 := &x.ObjectMeta
+ yy4036.CodecEncodeSelf(e)
} else {
r.EncodeNil()
}
} else {
- if yyq4023[2] {
+ if yyq4028[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("metadata"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy4032 := &x.ObjectMeta
- yy4032.CodecEncodeSelf(e)
+ yy4037 := &x.ObjectMeta
+ yy4037.CodecEncodeSelf(e)
}
}
- if yyr4023 || yy2arr4023 {
+ if yyr4028 || yy2arr4028 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq4023[3] {
- yy4034 := &x.Spec
- yy4034.CodecEncodeSelf(e)
+ if yyq4028[3] {
+ yy4039 := &x.Spec
+ yy4039.CodecEncodeSelf(e)
} else {
r.EncodeNil()
}
} else {
- if yyq4023[3] {
+ if yyq4028[3] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("spec"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy4035 := &x.Spec
- yy4035.CodecEncodeSelf(e)
+ yy4040 := &x.Spec
+ yy4040.CodecEncodeSelf(e)
}
}
- if yyr4023 || yy2arr4023 {
+ if yyr4028 || yy2arr4028 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -50710,25 +50774,25 @@ func (x *LimitRange) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym4036 := z.DecBinary()
- _ = yym4036
+ yym4041 := z.DecBinary()
+ _ = yym4041
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct4037 := r.ContainerType()
- if yyct4037 == codecSelferValueTypeMap1234 {
- yyl4037 := r.ReadMapStart()
- if yyl4037 == 0 {
+ yyct4042 := r.ContainerType()
+ if yyct4042 == codecSelferValueTypeMap1234 {
+ yyl4042 := r.ReadMapStart()
+ if yyl4042 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl4037, d)
+ x.codecDecodeSelfFromMap(yyl4042, d)
}
- } else if yyct4037 == codecSelferValueTypeArray1234 {
- yyl4037 := r.ReadArrayStart()
- if yyl4037 == 0 {
+ } else if yyct4042 == codecSelferValueTypeArray1234 {
+ yyl4042 := r.ReadArrayStart()
+ if yyl4042 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl4037, d)
+ x.codecDecodeSelfFromArray(yyl4042, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -50740,12 +50804,12 @@ func (x *LimitRange) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys4038Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys4038Slc
- var yyhl4038 bool = l >= 0
- for yyj4038 := 0; ; yyj4038++ {
- if yyhl4038 {
- if yyj4038 >= l {
+ var yys4043Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys4043Slc
+ var yyhl4043 bool = l >= 0
+ for yyj4043 := 0; ; yyj4043++ {
+ if yyhl4043 {
+ if yyj4043 >= l {
break
}
} else {
@@ -50754,10 +50818,10 @@ func (x *LimitRange) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys4038Slc = r.DecodeBytes(yys4038Slc, true, true)
- yys4038 := string(yys4038Slc)
+ yys4043Slc = r.DecodeBytes(yys4043Slc, true, true)
+ yys4043 := string(yys4043Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys4038 {
+ switch yys4043 {
case "kind":
if r.TryDecodeAsNil() {
x.Kind = ""
@@ -50774,20 +50838,20 @@ func (x *LimitRange) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.ObjectMeta = ObjectMeta{}
} else {
- yyv4041 := &x.ObjectMeta
- yyv4041.CodecDecodeSelf(d)
+ yyv4046 := &x.ObjectMeta
+ yyv4046.CodecDecodeSelf(d)
}
case "spec":
if r.TryDecodeAsNil() {
x.Spec = LimitRangeSpec{}
} else {
- yyv4042 := &x.Spec
- yyv4042.CodecDecodeSelf(d)
+ yyv4047 := &x.Spec
+ yyv4047.CodecDecodeSelf(d)
}
default:
- z.DecStructFieldNotFound(-1, yys4038)
- } // end switch yys4038
- } // end for yyj4038
+ z.DecStructFieldNotFound(-1, yys4043)
+ } // end switch yys4043
+ } // end for yyj4043
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -50795,16 +50859,16 @@ func (x *LimitRange) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj4043 int
- var yyb4043 bool
- var yyhl4043 bool = l >= 0
- yyj4043++
- if yyhl4043 {
- yyb4043 = yyj4043 > l
+ var yyj4048 int
+ var yyb4048 bool
+ var yyhl4048 bool = l >= 0
+ yyj4048++
+ if yyhl4048 {
+ yyb4048 = yyj4048 > l
} else {
- yyb4043 = r.CheckBreak()
+ yyb4048 = r.CheckBreak()
}
- if yyb4043 {
+ if yyb4048 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -50814,13 +50878,13 @@ func (x *LimitRange) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Kind = string(r.DecodeString())
}
- yyj4043++
- if yyhl4043 {
- yyb4043 = yyj4043 > l
+ yyj4048++
+ if yyhl4048 {
+ yyb4048 = yyj4048 > l
} else {
- yyb4043 = r.CheckBreak()
+ yyb4048 = r.CheckBreak()
}
- if yyb4043 {
+ if yyb4048 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -50830,13 +50894,13 @@ func (x *LimitRange) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.APIVersion = string(r.DecodeString())
}
- yyj4043++
- if yyhl4043 {
- yyb4043 = yyj4043 > l
+ yyj4048++
+ if yyhl4048 {
+ yyb4048 = yyj4048 > l
} else {
- yyb4043 = r.CheckBreak()
+ yyb4048 = r.CheckBreak()
}
- if yyb4043 {
+ if yyb4048 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -50844,16 +50908,16 @@ func (x *LimitRange) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.ObjectMeta = ObjectMeta{}
} else {
- yyv4046 := &x.ObjectMeta
- yyv4046.CodecDecodeSelf(d)
+ yyv4051 := &x.ObjectMeta
+ yyv4051.CodecDecodeSelf(d)
}
- yyj4043++
- if yyhl4043 {
- yyb4043 = yyj4043 > l
+ yyj4048++
+ if yyhl4048 {
+ yyb4048 = yyj4048 > l
} else {
- yyb4043 = r.CheckBreak()
+ yyb4048 = r.CheckBreak()
}
- if yyb4043 {
+ if yyb4048 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -50861,21 +50925,21 @@ func (x *LimitRange) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Spec = LimitRangeSpec{}
} else {
- yyv4047 := &x.Spec
- yyv4047.CodecDecodeSelf(d)
+ yyv4052 := &x.Spec
+ yyv4052.CodecDecodeSelf(d)
}
for {
- yyj4043++
- if yyhl4043 {
- yyb4043 = yyj4043 > l
+ yyj4048++
+ if yyhl4048 {
+ yyb4048 = yyj4048 > l
} else {
- yyb4043 = r.CheckBreak()
+ yyb4048 = r.CheckBreak()
}
- if yyb4043 {
+ if yyb4048 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj4043-1, "")
+ z.DecStructFieldNotFound(yyj4048-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -50887,37 +50951,37 @@ func (x *LimitRangeList) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym4048 := z.EncBinary()
- _ = yym4048
+ yym4053 := z.EncBinary()
+ _ = yym4053
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep4049 := !z.EncBinary()
- yy2arr4049 := z.EncBasicHandle().StructToArray
- var yyq4049 [4]bool
- _, _, _ = yysep4049, yyq4049, yy2arr4049
- const yyr4049 bool = false
- yyq4049[0] = x.Kind != ""
- yyq4049[1] = x.APIVersion != ""
- yyq4049[2] = true
- var yynn4049 int
- if yyr4049 || yy2arr4049 {
+ yysep4054 := !z.EncBinary()
+ yy2arr4054 := z.EncBasicHandle().StructToArray
+ var yyq4054 [4]bool
+ _, _, _ = yysep4054, yyq4054, yy2arr4054
+ const yyr4054 bool = false
+ yyq4054[0] = x.Kind != ""
+ yyq4054[1] = x.APIVersion != ""
+ yyq4054[2] = true
+ var yynn4054 int
+ if yyr4054 || yy2arr4054 {
r.EncodeArrayStart(4)
} else {
- yynn4049 = 1
- for _, b := range yyq4049 {
+ yynn4054 = 1
+ for _, b := range yyq4054 {
if b {
- yynn4049++
+ yynn4054++
}
}
- r.EncodeMapStart(yynn4049)
- yynn4049 = 0
+ r.EncodeMapStart(yynn4054)
+ yynn4054 = 0
}
- if yyr4049 || yy2arr4049 {
+ if yyr4054 || yy2arr4054 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq4049[0] {
- yym4051 := z.EncBinary()
- _ = yym4051
+ if yyq4054[0] {
+ yym4056 := z.EncBinary()
+ _ = yym4056
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
@@ -50926,23 +50990,23 @@ func (x *LimitRangeList) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq4049[0] {
+ if yyq4054[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("kind"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym4052 := z.EncBinary()
- _ = yym4052
+ yym4057 := z.EncBinary()
+ _ = yym4057
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
}
}
}
- if yyr4049 || yy2arr4049 {
+ if yyr4054 || yy2arr4054 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq4049[1] {
- yym4054 := z.EncBinary()
- _ = yym4054
+ if yyq4054[1] {
+ yym4059 := z.EncBinary()
+ _ = yym4059
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
@@ -50951,54 +51015,54 @@ func (x *LimitRangeList) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq4049[1] {
+ if yyq4054[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym4055 := z.EncBinary()
- _ = yym4055
+ yym4060 := z.EncBinary()
+ _ = yym4060
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
}
}
}
- if yyr4049 || yy2arr4049 {
+ if yyr4054 || yy2arr4054 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq4049[2] {
- yy4057 := &x.ListMeta
- yym4058 := z.EncBinary()
- _ = yym4058
+ if yyq4054[2] {
+ yy4062 := &x.ListMeta
+ yym4063 := z.EncBinary()
+ _ = yym4063
if false {
- } else if z.HasExtensions() && z.EncExt(yy4057) {
+ } else if z.HasExtensions() && z.EncExt(yy4062) {
} else {
- z.EncFallback(yy4057)
+ z.EncFallback(yy4062)
}
} else {
r.EncodeNil()
}
} else {
- if yyq4049[2] {
+ if yyq4054[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("metadata"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy4059 := &x.ListMeta
- yym4060 := z.EncBinary()
- _ = yym4060
+ yy4064 := &x.ListMeta
+ yym4065 := z.EncBinary()
+ _ = yym4065
if false {
- } else if z.HasExtensions() && z.EncExt(yy4059) {
+ } else if z.HasExtensions() && z.EncExt(yy4064) {
} else {
- z.EncFallback(yy4059)
+ z.EncFallback(yy4064)
}
}
}
- if yyr4049 || yy2arr4049 {
+ if yyr4054 || yy2arr4054 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if x.Items == nil {
r.EncodeNil()
} else {
- yym4062 := z.EncBinary()
- _ = yym4062
+ yym4067 := z.EncBinary()
+ _ = yym4067
if false {
} else {
h.encSliceLimitRange(([]LimitRange)(x.Items), e)
@@ -51011,15 +51075,15 @@ func (x *LimitRangeList) CodecEncodeSelf(e *codec1978.Encoder) {
if x.Items == nil {
r.EncodeNil()
} else {
- yym4063 := z.EncBinary()
- _ = yym4063
+ yym4068 := z.EncBinary()
+ _ = yym4068
if false {
} else {
h.encSliceLimitRange(([]LimitRange)(x.Items), e)
}
}
}
- if yyr4049 || yy2arr4049 {
+ if yyr4054 || yy2arr4054 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -51032,25 +51096,25 @@ func (x *LimitRangeList) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym4064 := z.DecBinary()
- _ = yym4064
+ yym4069 := z.DecBinary()
+ _ = yym4069
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct4065 := r.ContainerType()
- if yyct4065 == codecSelferValueTypeMap1234 {
- yyl4065 := r.ReadMapStart()
- if yyl4065 == 0 {
+ yyct4070 := r.ContainerType()
+ if yyct4070 == codecSelferValueTypeMap1234 {
+ yyl4070 := r.ReadMapStart()
+ if yyl4070 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl4065, d)
+ x.codecDecodeSelfFromMap(yyl4070, d)
}
- } else if yyct4065 == codecSelferValueTypeArray1234 {
- yyl4065 := r.ReadArrayStart()
- if yyl4065 == 0 {
+ } else if yyct4070 == codecSelferValueTypeArray1234 {
+ yyl4070 := r.ReadArrayStart()
+ if yyl4070 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl4065, d)
+ x.codecDecodeSelfFromArray(yyl4070, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -51062,12 +51126,12 @@ func (x *LimitRangeList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys4066Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys4066Slc
- var yyhl4066 bool = l >= 0
- for yyj4066 := 0; ; yyj4066++ {
- if yyhl4066 {
- if yyj4066 >= l {
+ var yys4071Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys4071Slc
+ var yyhl4071 bool = l >= 0
+ for yyj4071 := 0; ; yyj4071++ {
+ if yyhl4071 {
+ if yyj4071 >= l {
break
}
} else {
@@ -51076,10 +51140,10 @@ func (x *LimitRangeList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys4066Slc = r.DecodeBytes(yys4066Slc, true, true)
- yys4066 := string(yys4066Slc)
+ yys4071Slc = r.DecodeBytes(yys4071Slc, true, true)
+ yys4071 := string(yys4071Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys4066 {
+ switch yys4071 {
case "kind":
if r.TryDecodeAsNil() {
x.Kind = ""
@@ -51096,31 +51160,31 @@ func (x *LimitRangeList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.ListMeta = pkg2_v1.ListMeta{}
} else {
- yyv4069 := &x.ListMeta
- yym4070 := z.DecBinary()
- _ = yym4070
+ yyv4074 := &x.ListMeta
+ yym4075 := z.DecBinary()
+ _ = yym4075
if false {
- } else if z.HasExtensions() && z.DecExt(yyv4069) {
+ } else if z.HasExtensions() && z.DecExt(yyv4074) {
} else {
- z.DecFallback(yyv4069, false)
+ z.DecFallback(yyv4074, false)
}
}
case "items":
if r.TryDecodeAsNil() {
x.Items = nil
} else {
- yyv4071 := &x.Items
- yym4072 := z.DecBinary()
- _ = yym4072
+ yyv4076 := &x.Items
+ yym4077 := z.DecBinary()
+ _ = yym4077
if false {
} else {
- h.decSliceLimitRange((*[]LimitRange)(yyv4071), d)
+ h.decSliceLimitRange((*[]LimitRange)(yyv4076), d)
}
}
default:
- z.DecStructFieldNotFound(-1, yys4066)
- } // end switch yys4066
- } // end for yyj4066
+ z.DecStructFieldNotFound(-1, yys4071)
+ } // end switch yys4071
+ } // end for yyj4071
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -51128,16 +51192,16 @@ func (x *LimitRangeList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj4073 int
- var yyb4073 bool
- var yyhl4073 bool = l >= 0
- yyj4073++
- if yyhl4073 {
- yyb4073 = yyj4073 > l
+ var yyj4078 int
+ var yyb4078 bool
+ var yyhl4078 bool = l >= 0
+ yyj4078++
+ if yyhl4078 {
+ yyb4078 = yyj4078 > l
} else {
- yyb4073 = r.CheckBreak()
+ yyb4078 = r.CheckBreak()
}
- if yyb4073 {
+ if yyb4078 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -51147,13 +51211,13 @@ func (x *LimitRangeList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Kind = string(r.DecodeString())
}
- yyj4073++
- if yyhl4073 {
- yyb4073 = yyj4073 > l
+ yyj4078++
+ if yyhl4078 {
+ yyb4078 = yyj4078 > l
} else {
- yyb4073 = r.CheckBreak()
+ yyb4078 = r.CheckBreak()
}
- if yyb4073 {
+ if yyb4078 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -51163,13 +51227,13 @@ func (x *LimitRangeList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.APIVersion = string(r.DecodeString())
}
- yyj4073++
- if yyhl4073 {
- yyb4073 = yyj4073 > l
+ yyj4078++
+ if yyhl4078 {
+ yyb4078 = yyj4078 > l
} else {
- yyb4073 = r.CheckBreak()
+ yyb4078 = r.CheckBreak()
}
- if yyb4073 {
+ if yyb4078 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -51177,22 +51241,22 @@ func (x *LimitRangeList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.ListMeta = pkg2_v1.ListMeta{}
} else {
- yyv4076 := &x.ListMeta
- yym4077 := z.DecBinary()
- _ = yym4077
+ yyv4081 := &x.ListMeta
+ yym4082 := z.DecBinary()
+ _ = yym4082
if false {
- } else if z.HasExtensions() && z.DecExt(yyv4076) {
+ } else if z.HasExtensions() && z.DecExt(yyv4081) {
} else {
- z.DecFallback(yyv4076, false)
+ z.DecFallback(yyv4081, false)
}
}
- yyj4073++
- if yyhl4073 {
- yyb4073 = yyj4073 > l
+ yyj4078++
+ if yyhl4078 {
+ yyb4078 = yyj4078 > l
} else {
- yyb4073 = r.CheckBreak()
+ yyb4078 = r.CheckBreak()
}
- if yyb4073 {
+ if yyb4078 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -51200,26 +51264,26 @@ func (x *LimitRangeList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Items = nil
} else {
- yyv4078 := &x.Items
- yym4079 := z.DecBinary()
- _ = yym4079
+ yyv4083 := &x.Items
+ yym4084 := z.DecBinary()
+ _ = yym4084
if false {
} else {
- h.decSliceLimitRange((*[]LimitRange)(yyv4078), d)
+ h.decSliceLimitRange((*[]LimitRange)(yyv4083), d)
}
}
for {
- yyj4073++
- if yyhl4073 {
- yyb4073 = yyj4073 > l
+ yyj4078++
+ if yyhl4078 {
+ yyb4078 = yyj4078 > l
} else {
- yyb4073 = r.CheckBreak()
+ yyb4078 = r.CheckBreak()
}
- if yyb4073 {
+ if yyb4078 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj4073-1, "")
+ z.DecStructFieldNotFound(yyj4078-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -51228,8 +51292,8 @@ func (x ResourceQuotaScope) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
- yym4080 := z.EncBinary()
- _ = yym4080
+ yym4085 := z.EncBinary()
+ _ = yym4085
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
@@ -51241,8 +51305,8 @@ func (x *ResourceQuotaScope) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym4081 := z.DecBinary()
- _ = yym4081
+ yym4086 := z.DecBinary()
+ _ = yym4086
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
@@ -51257,34 +51321,34 @@ func (x *ResourceQuotaSpec) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym4082 := z.EncBinary()
- _ = yym4082
+ yym4087 := z.EncBinary()
+ _ = yym4087
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep4083 := !z.EncBinary()
- yy2arr4083 := z.EncBasicHandle().StructToArray
- var yyq4083 [2]bool
- _, _, _ = yysep4083, yyq4083, yy2arr4083
- const yyr4083 bool = false
- yyq4083[0] = len(x.Hard) != 0
- yyq4083[1] = len(x.Scopes) != 0
- var yynn4083 int
- if yyr4083 || yy2arr4083 {
+ yysep4088 := !z.EncBinary()
+ yy2arr4088 := z.EncBasicHandle().StructToArray
+ var yyq4088 [2]bool
+ _, _, _ = yysep4088, yyq4088, yy2arr4088
+ const yyr4088 bool = false
+ yyq4088[0] = len(x.Hard) != 0
+ yyq4088[1] = len(x.Scopes) != 0
+ var yynn4088 int
+ if yyr4088 || yy2arr4088 {
r.EncodeArrayStart(2)
} else {
- yynn4083 = 0
- for _, b := range yyq4083 {
+ yynn4088 = 0
+ for _, b := range yyq4088 {
if b {
- yynn4083++
+ yynn4088++
}
}
- r.EncodeMapStart(yynn4083)
- yynn4083 = 0
+ r.EncodeMapStart(yynn4088)
+ yynn4088 = 0
}
- if yyr4083 || yy2arr4083 {
+ if yyr4088 || yy2arr4088 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq4083[0] {
+ if yyq4088[0] {
if x.Hard == nil {
r.EncodeNil()
} else {
@@ -51294,7 +51358,7 @@ func (x *ResourceQuotaSpec) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeNil()
}
} else {
- if yyq4083[0] {
+ if yyq4088[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("hard"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
@@ -51305,14 +51369,14 @@ func (x *ResourceQuotaSpec) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
- if yyr4083 || yy2arr4083 {
+ if yyr4088 || yy2arr4088 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq4083[1] {
+ if yyq4088[1] {
if x.Scopes == nil {
r.EncodeNil()
} else {
- yym4086 := z.EncBinary()
- _ = yym4086
+ yym4091 := z.EncBinary()
+ _ = yym4091
if false {
} else {
h.encSliceResourceQuotaScope(([]ResourceQuotaScope)(x.Scopes), e)
@@ -51322,15 +51386,15 @@ func (x *ResourceQuotaSpec) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeNil()
}
} else {
- if yyq4083[1] {
+ if yyq4088[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("scopes"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
if x.Scopes == nil {
r.EncodeNil()
} else {
- yym4087 := z.EncBinary()
- _ = yym4087
+ yym4092 := z.EncBinary()
+ _ = yym4092
if false {
} else {
h.encSliceResourceQuotaScope(([]ResourceQuotaScope)(x.Scopes), e)
@@ -51338,7 +51402,7 @@ func (x *ResourceQuotaSpec) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
- if yyr4083 || yy2arr4083 {
+ if yyr4088 || yy2arr4088 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -51351,25 +51415,25 @@ func (x *ResourceQuotaSpec) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym4088 := z.DecBinary()
- _ = yym4088
+ yym4093 := z.DecBinary()
+ _ = yym4093
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct4089 := r.ContainerType()
- if yyct4089 == codecSelferValueTypeMap1234 {
- yyl4089 := r.ReadMapStart()
- if yyl4089 == 0 {
+ yyct4094 := r.ContainerType()
+ if yyct4094 == codecSelferValueTypeMap1234 {
+ yyl4094 := r.ReadMapStart()
+ if yyl4094 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl4089, d)
+ x.codecDecodeSelfFromMap(yyl4094, d)
}
- } else if yyct4089 == codecSelferValueTypeArray1234 {
- yyl4089 := r.ReadArrayStart()
- if yyl4089 == 0 {
+ } else if yyct4094 == codecSelferValueTypeArray1234 {
+ yyl4094 := r.ReadArrayStart()
+ if yyl4094 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl4089, d)
+ x.codecDecodeSelfFromArray(yyl4094, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -51381,12 +51445,12 @@ func (x *ResourceQuotaSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder)
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys4090Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys4090Slc
- var yyhl4090 bool = l >= 0
- for yyj4090 := 0; ; yyj4090++ {
- if yyhl4090 {
- if yyj4090 >= l {
+ var yys4095Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys4095Slc
+ var yyhl4095 bool = l >= 0
+ for yyj4095 := 0; ; yyj4095++ {
+ if yyhl4095 {
+ if yyj4095 >= l {
break
}
} else {
@@ -51395,33 +51459,33 @@ func (x *ResourceQuotaSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder)
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys4090Slc = r.DecodeBytes(yys4090Slc, true, true)
- yys4090 := string(yys4090Slc)
+ yys4095Slc = r.DecodeBytes(yys4095Slc, true, true)
+ yys4095 := string(yys4095Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys4090 {
+ switch yys4095 {
case "hard":
if r.TryDecodeAsNil() {
x.Hard = nil
} else {
- yyv4091 := &x.Hard
- yyv4091.CodecDecodeSelf(d)
+ yyv4096 := &x.Hard
+ yyv4096.CodecDecodeSelf(d)
}
case "scopes":
if r.TryDecodeAsNil() {
x.Scopes = nil
} else {
- yyv4092 := &x.Scopes
- yym4093 := z.DecBinary()
- _ = yym4093
+ yyv4097 := &x.Scopes
+ yym4098 := z.DecBinary()
+ _ = yym4098
if false {
} else {
- h.decSliceResourceQuotaScope((*[]ResourceQuotaScope)(yyv4092), d)
+ h.decSliceResourceQuotaScope((*[]ResourceQuotaScope)(yyv4097), d)
}
}
default:
- z.DecStructFieldNotFound(-1, yys4090)
- } // end switch yys4090
- } // end for yyj4090
+ z.DecStructFieldNotFound(-1, yys4095)
+ } // end switch yys4095
+ } // end for yyj4095
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -51429,16 +51493,16 @@ func (x *ResourceQuotaSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj4094 int
- var yyb4094 bool
- var yyhl4094 bool = l >= 0
- yyj4094++
- if yyhl4094 {
- yyb4094 = yyj4094 > l
+ var yyj4099 int
+ var yyb4099 bool
+ var yyhl4099 bool = l >= 0
+ yyj4099++
+ if yyhl4099 {
+ yyb4099 = yyj4099 > l
} else {
- yyb4094 = r.CheckBreak()
+ yyb4099 = r.CheckBreak()
}
- if yyb4094 {
+ if yyb4099 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -51446,16 +51510,16 @@ func (x *ResourceQuotaSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder
if r.TryDecodeAsNil() {
x.Hard = nil
} else {
- yyv4095 := &x.Hard
- yyv4095.CodecDecodeSelf(d)
+ yyv4100 := &x.Hard
+ yyv4100.CodecDecodeSelf(d)
}
- yyj4094++
- if yyhl4094 {
- yyb4094 = yyj4094 > l
+ yyj4099++
+ if yyhl4099 {
+ yyb4099 = yyj4099 > l
} else {
- yyb4094 = r.CheckBreak()
+ yyb4099 = r.CheckBreak()
}
- if yyb4094 {
+ if yyb4099 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -51463,26 +51527,26 @@ func (x *ResourceQuotaSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder
if r.TryDecodeAsNil() {
x.Scopes = nil
} else {
- yyv4096 := &x.Scopes
- yym4097 := z.DecBinary()
- _ = yym4097
+ yyv4101 := &x.Scopes
+ yym4102 := z.DecBinary()
+ _ = yym4102
if false {
} else {
- h.decSliceResourceQuotaScope((*[]ResourceQuotaScope)(yyv4096), d)
+ h.decSliceResourceQuotaScope((*[]ResourceQuotaScope)(yyv4101), d)
}
}
for {
- yyj4094++
- if yyhl4094 {
- yyb4094 = yyj4094 > l
+ yyj4099++
+ if yyhl4099 {
+ yyb4099 = yyj4099 > l
} else {
- yyb4094 = r.CheckBreak()
+ yyb4099 = r.CheckBreak()
}
- if yyb4094 {
+ if yyb4099 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj4094-1, "")
+ z.DecStructFieldNotFound(yyj4099-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -51494,34 +51558,34 @@ func (x *ResourceQuotaStatus) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym4098 := z.EncBinary()
- _ = yym4098
+ yym4103 := z.EncBinary()
+ _ = yym4103
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep4099 := !z.EncBinary()
- yy2arr4099 := z.EncBasicHandle().StructToArray
- var yyq4099 [2]bool
- _, _, _ = yysep4099, yyq4099, yy2arr4099
- const yyr4099 bool = false
- yyq4099[0] = len(x.Hard) != 0
- yyq4099[1] = len(x.Used) != 0
- var yynn4099 int
- if yyr4099 || yy2arr4099 {
+ yysep4104 := !z.EncBinary()
+ yy2arr4104 := z.EncBasicHandle().StructToArray
+ var yyq4104 [2]bool
+ _, _, _ = yysep4104, yyq4104, yy2arr4104
+ const yyr4104 bool = false
+ yyq4104[0] = len(x.Hard) != 0
+ yyq4104[1] = len(x.Used) != 0
+ var yynn4104 int
+ if yyr4104 || yy2arr4104 {
r.EncodeArrayStart(2)
} else {
- yynn4099 = 0
- for _, b := range yyq4099 {
+ yynn4104 = 0
+ for _, b := range yyq4104 {
if b {
- yynn4099++
+ yynn4104++
}
}
- r.EncodeMapStart(yynn4099)
- yynn4099 = 0
+ r.EncodeMapStart(yynn4104)
+ yynn4104 = 0
}
- if yyr4099 || yy2arr4099 {
+ if yyr4104 || yy2arr4104 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq4099[0] {
+ if yyq4104[0] {
if x.Hard == nil {
r.EncodeNil()
} else {
@@ -51531,7 +51595,7 @@ func (x *ResourceQuotaStatus) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeNil()
}
} else {
- if yyq4099[0] {
+ if yyq4104[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("hard"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
@@ -51542,9 +51606,9 @@ func (x *ResourceQuotaStatus) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
- if yyr4099 || yy2arr4099 {
+ if yyr4104 || yy2arr4104 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq4099[1] {
+ if yyq4104[1] {
if x.Used == nil {
r.EncodeNil()
} else {
@@ -51554,7 +51618,7 @@ func (x *ResourceQuotaStatus) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeNil()
}
} else {
- if yyq4099[1] {
+ if yyq4104[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("used"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
@@ -51565,7 +51629,7 @@ func (x *ResourceQuotaStatus) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
- if yyr4099 || yy2arr4099 {
+ if yyr4104 || yy2arr4104 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -51578,25 +51642,25 @@ func (x *ResourceQuotaStatus) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym4102 := z.DecBinary()
- _ = yym4102
+ yym4107 := z.DecBinary()
+ _ = yym4107
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct4103 := r.ContainerType()
- if yyct4103 == codecSelferValueTypeMap1234 {
- yyl4103 := r.ReadMapStart()
- if yyl4103 == 0 {
+ yyct4108 := r.ContainerType()
+ if yyct4108 == codecSelferValueTypeMap1234 {
+ yyl4108 := r.ReadMapStart()
+ if yyl4108 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl4103, d)
+ x.codecDecodeSelfFromMap(yyl4108, d)
}
- } else if yyct4103 == codecSelferValueTypeArray1234 {
- yyl4103 := r.ReadArrayStart()
- if yyl4103 == 0 {
+ } else if yyct4108 == codecSelferValueTypeArray1234 {
+ yyl4108 := r.ReadArrayStart()
+ if yyl4108 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl4103, d)
+ x.codecDecodeSelfFromArray(yyl4108, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -51608,12 +51672,12 @@ func (x *ResourceQuotaStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys4104Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys4104Slc
- var yyhl4104 bool = l >= 0
- for yyj4104 := 0; ; yyj4104++ {
- if yyhl4104 {
- if yyj4104 >= l {
+ var yys4109Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys4109Slc
+ var yyhl4109 bool = l >= 0
+ for yyj4109 := 0; ; yyj4109++ {
+ if yyhl4109 {
+ if yyj4109 >= l {
break
}
} else {
@@ -51622,28 +51686,28 @@ func (x *ResourceQuotaStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys4104Slc = r.DecodeBytes(yys4104Slc, true, true)
- yys4104 := string(yys4104Slc)
+ yys4109Slc = r.DecodeBytes(yys4109Slc, true, true)
+ yys4109 := string(yys4109Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys4104 {
+ switch yys4109 {
case "hard":
if r.TryDecodeAsNil() {
x.Hard = nil
} else {
- yyv4105 := &x.Hard
- yyv4105.CodecDecodeSelf(d)
+ yyv4110 := &x.Hard
+ yyv4110.CodecDecodeSelf(d)
}
case "used":
if r.TryDecodeAsNil() {
x.Used = nil
} else {
- yyv4106 := &x.Used
- yyv4106.CodecDecodeSelf(d)
+ yyv4111 := &x.Used
+ yyv4111.CodecDecodeSelf(d)
}
default:
- z.DecStructFieldNotFound(-1, yys4104)
- } // end switch yys4104
- } // end for yyj4104
+ z.DecStructFieldNotFound(-1, yys4109)
+ } // end switch yys4109
+ } // end for yyj4109
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -51651,16 +51715,16 @@ func (x *ResourceQuotaStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decod
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj4107 int
- var yyb4107 bool
- var yyhl4107 bool = l >= 0
- yyj4107++
- if yyhl4107 {
- yyb4107 = yyj4107 > l
+ var yyj4112 int
+ var yyb4112 bool
+ var yyhl4112 bool = l >= 0
+ yyj4112++
+ if yyhl4112 {
+ yyb4112 = yyj4112 > l
} else {
- yyb4107 = r.CheckBreak()
+ yyb4112 = r.CheckBreak()
}
- if yyb4107 {
+ if yyb4112 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -51668,16 +51732,16 @@ func (x *ResourceQuotaStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decod
if r.TryDecodeAsNil() {
x.Hard = nil
} else {
- yyv4108 := &x.Hard
- yyv4108.CodecDecodeSelf(d)
+ yyv4113 := &x.Hard
+ yyv4113.CodecDecodeSelf(d)
}
- yyj4107++
- if yyhl4107 {
- yyb4107 = yyj4107 > l
+ yyj4112++
+ if yyhl4112 {
+ yyb4112 = yyj4112 > l
} else {
- yyb4107 = r.CheckBreak()
+ yyb4112 = r.CheckBreak()
}
- if yyb4107 {
+ if yyb4112 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -51685,21 +51749,21 @@ func (x *ResourceQuotaStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decod
if r.TryDecodeAsNil() {
x.Used = nil
} else {
- yyv4109 := &x.Used
- yyv4109.CodecDecodeSelf(d)
+ yyv4114 := &x.Used
+ yyv4114.CodecDecodeSelf(d)
}
for {
- yyj4107++
- if yyhl4107 {
- yyb4107 = yyj4107 > l
+ yyj4112++
+ if yyhl4112 {
+ yyb4112 = yyj4112 > l
} else {
- yyb4107 = r.CheckBreak()
+ yyb4112 = r.CheckBreak()
}
- if yyb4107 {
+ if yyb4112 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj4107-1, "")
+ z.DecStructFieldNotFound(yyj4112-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -51711,39 +51775,39 @@ func (x *ResourceQuota) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym4110 := z.EncBinary()
- _ = yym4110
+ yym4115 := z.EncBinary()
+ _ = yym4115
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep4111 := !z.EncBinary()
- yy2arr4111 := z.EncBasicHandle().StructToArray
- var yyq4111 [5]bool
- _, _, _ = yysep4111, yyq4111, yy2arr4111
- const yyr4111 bool = false
- yyq4111[0] = x.Kind != ""
- yyq4111[1] = x.APIVersion != ""
- yyq4111[2] = true
- yyq4111[3] = true
- yyq4111[4] = true
- var yynn4111 int
- if yyr4111 || yy2arr4111 {
+ yysep4116 := !z.EncBinary()
+ yy2arr4116 := z.EncBasicHandle().StructToArray
+ var yyq4116 [5]bool
+ _, _, _ = yysep4116, yyq4116, yy2arr4116
+ const yyr4116 bool = false
+ yyq4116[0] = x.Kind != ""
+ yyq4116[1] = x.APIVersion != ""
+ yyq4116[2] = true
+ yyq4116[3] = true
+ yyq4116[4] = true
+ var yynn4116 int
+ if yyr4116 || yy2arr4116 {
r.EncodeArrayStart(5)
} else {
- yynn4111 = 0
- for _, b := range yyq4111 {
+ yynn4116 = 0
+ for _, b := range yyq4116 {
if b {
- yynn4111++
+ yynn4116++
}
}
- r.EncodeMapStart(yynn4111)
- yynn4111 = 0
+ r.EncodeMapStart(yynn4116)
+ yynn4116 = 0
}
- if yyr4111 || yy2arr4111 {
+ if yyr4116 || yy2arr4116 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq4111[0] {
- yym4113 := z.EncBinary()
- _ = yym4113
+ if yyq4116[0] {
+ yym4118 := z.EncBinary()
+ _ = yym4118
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
@@ -51752,23 +51816,23 @@ func (x *ResourceQuota) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq4111[0] {
+ if yyq4116[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("kind"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym4114 := z.EncBinary()
- _ = yym4114
+ yym4119 := z.EncBinary()
+ _ = yym4119
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
}
}
}
- if yyr4111 || yy2arr4111 {
+ if yyr4116 || yy2arr4116 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq4111[1] {
- yym4116 := z.EncBinary()
- _ = yym4116
+ if yyq4116[1] {
+ yym4121 := z.EncBinary()
+ _ = yym4121
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
@@ -51777,70 +51841,70 @@ func (x *ResourceQuota) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq4111[1] {
+ if yyq4116[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym4117 := z.EncBinary()
- _ = yym4117
+ yym4122 := z.EncBinary()
+ _ = yym4122
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
}
}
}
- if yyr4111 || yy2arr4111 {
+ if yyr4116 || yy2arr4116 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq4111[2] {
- yy4119 := &x.ObjectMeta
- yy4119.CodecEncodeSelf(e)
+ if yyq4116[2] {
+ yy4124 := &x.ObjectMeta
+ yy4124.CodecEncodeSelf(e)
} else {
r.EncodeNil()
}
} else {
- if yyq4111[2] {
+ if yyq4116[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("metadata"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy4120 := &x.ObjectMeta
- yy4120.CodecEncodeSelf(e)
+ yy4125 := &x.ObjectMeta
+ yy4125.CodecEncodeSelf(e)
}
}
- if yyr4111 || yy2arr4111 {
+ if yyr4116 || yy2arr4116 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq4111[3] {
- yy4122 := &x.Spec
- yy4122.CodecEncodeSelf(e)
+ if yyq4116[3] {
+ yy4127 := &x.Spec
+ yy4127.CodecEncodeSelf(e)
} else {
r.EncodeNil()
}
} else {
- if yyq4111[3] {
+ if yyq4116[3] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("spec"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy4123 := &x.Spec
- yy4123.CodecEncodeSelf(e)
+ yy4128 := &x.Spec
+ yy4128.CodecEncodeSelf(e)
}
}
- if yyr4111 || yy2arr4111 {
+ if yyr4116 || yy2arr4116 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq4111[4] {
- yy4125 := &x.Status
- yy4125.CodecEncodeSelf(e)
+ if yyq4116[4] {
+ yy4130 := &x.Status
+ yy4130.CodecEncodeSelf(e)
} else {
r.EncodeNil()
}
} else {
- if yyq4111[4] {
+ if yyq4116[4] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("status"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy4126 := &x.Status
- yy4126.CodecEncodeSelf(e)
+ yy4131 := &x.Status
+ yy4131.CodecEncodeSelf(e)
}
}
- if yyr4111 || yy2arr4111 {
+ if yyr4116 || yy2arr4116 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -51853,25 +51917,25 @@ func (x *ResourceQuota) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym4127 := z.DecBinary()
- _ = yym4127
+ yym4132 := z.DecBinary()
+ _ = yym4132
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct4128 := r.ContainerType()
- if yyct4128 == codecSelferValueTypeMap1234 {
- yyl4128 := r.ReadMapStart()
- if yyl4128 == 0 {
+ yyct4133 := r.ContainerType()
+ if yyct4133 == codecSelferValueTypeMap1234 {
+ yyl4133 := r.ReadMapStart()
+ if yyl4133 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl4128, d)
+ x.codecDecodeSelfFromMap(yyl4133, d)
}
- } else if yyct4128 == codecSelferValueTypeArray1234 {
- yyl4128 := r.ReadArrayStart()
- if yyl4128 == 0 {
+ } else if yyct4133 == codecSelferValueTypeArray1234 {
+ yyl4133 := r.ReadArrayStart()
+ if yyl4133 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl4128, d)
+ x.codecDecodeSelfFromArray(yyl4133, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -51883,12 +51947,12 @@ func (x *ResourceQuota) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys4129Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys4129Slc
- var yyhl4129 bool = l >= 0
- for yyj4129 := 0; ; yyj4129++ {
- if yyhl4129 {
- if yyj4129 >= l {
+ var yys4134Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys4134Slc
+ var yyhl4134 bool = l >= 0
+ for yyj4134 := 0; ; yyj4134++ {
+ if yyhl4134 {
+ if yyj4134 >= l {
break
}
} else {
@@ -51897,10 +51961,10 @@ func (x *ResourceQuota) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys4129Slc = r.DecodeBytes(yys4129Slc, true, true)
- yys4129 := string(yys4129Slc)
+ yys4134Slc = r.DecodeBytes(yys4134Slc, true, true)
+ yys4134 := string(yys4134Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys4129 {
+ switch yys4134 {
case "kind":
if r.TryDecodeAsNil() {
x.Kind = ""
@@ -51917,27 +51981,27 @@ func (x *ResourceQuota) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.ObjectMeta = ObjectMeta{}
} else {
- yyv4132 := &x.ObjectMeta
- yyv4132.CodecDecodeSelf(d)
+ yyv4137 := &x.ObjectMeta
+ yyv4137.CodecDecodeSelf(d)
}
case "spec":
if r.TryDecodeAsNil() {
x.Spec = ResourceQuotaSpec{}
} else {
- yyv4133 := &x.Spec
- yyv4133.CodecDecodeSelf(d)
+ yyv4138 := &x.Spec
+ yyv4138.CodecDecodeSelf(d)
}
case "status":
if r.TryDecodeAsNil() {
x.Status = ResourceQuotaStatus{}
} else {
- yyv4134 := &x.Status
- yyv4134.CodecDecodeSelf(d)
+ yyv4139 := &x.Status
+ yyv4139.CodecDecodeSelf(d)
}
default:
- z.DecStructFieldNotFound(-1, yys4129)
- } // end switch yys4129
- } // end for yyj4129
+ z.DecStructFieldNotFound(-1, yys4134)
+ } // end switch yys4134
+ } // end for yyj4134
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -51945,16 +52009,16 @@ func (x *ResourceQuota) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj4135 int
- var yyb4135 bool
- var yyhl4135 bool = l >= 0
- yyj4135++
- if yyhl4135 {
- yyb4135 = yyj4135 > l
+ var yyj4140 int
+ var yyb4140 bool
+ var yyhl4140 bool = l >= 0
+ yyj4140++
+ if yyhl4140 {
+ yyb4140 = yyj4140 > l
} else {
- yyb4135 = r.CheckBreak()
+ yyb4140 = r.CheckBreak()
}
- if yyb4135 {
+ if yyb4140 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -51964,13 +52028,13 @@ func (x *ResourceQuota) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Kind = string(r.DecodeString())
}
- yyj4135++
- if yyhl4135 {
- yyb4135 = yyj4135 > l
+ yyj4140++
+ if yyhl4140 {
+ yyb4140 = yyj4140 > l
} else {
- yyb4135 = r.CheckBreak()
+ yyb4140 = r.CheckBreak()
}
- if yyb4135 {
+ if yyb4140 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -51980,13 +52044,13 @@ func (x *ResourceQuota) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.APIVersion = string(r.DecodeString())
}
- yyj4135++
- if yyhl4135 {
- yyb4135 = yyj4135 > l
+ yyj4140++
+ if yyhl4140 {
+ yyb4140 = yyj4140 > l
} else {
- yyb4135 = r.CheckBreak()
+ yyb4140 = r.CheckBreak()
}
- if yyb4135 {
+ if yyb4140 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -51994,16 +52058,16 @@ func (x *ResourceQuota) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.ObjectMeta = ObjectMeta{}
} else {
- yyv4138 := &x.ObjectMeta
- yyv4138.CodecDecodeSelf(d)
+ yyv4143 := &x.ObjectMeta
+ yyv4143.CodecDecodeSelf(d)
}
- yyj4135++
- if yyhl4135 {
- yyb4135 = yyj4135 > l
+ yyj4140++
+ if yyhl4140 {
+ yyb4140 = yyj4140 > l
} else {
- yyb4135 = r.CheckBreak()
+ yyb4140 = r.CheckBreak()
}
- if yyb4135 {
+ if yyb4140 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -52011,16 +52075,16 @@ func (x *ResourceQuota) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Spec = ResourceQuotaSpec{}
} else {
- yyv4139 := &x.Spec
- yyv4139.CodecDecodeSelf(d)
+ yyv4144 := &x.Spec
+ yyv4144.CodecDecodeSelf(d)
}
- yyj4135++
- if yyhl4135 {
- yyb4135 = yyj4135 > l
+ yyj4140++
+ if yyhl4140 {
+ yyb4140 = yyj4140 > l
} else {
- yyb4135 = r.CheckBreak()
+ yyb4140 = r.CheckBreak()
}
- if yyb4135 {
+ if yyb4140 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -52028,21 +52092,21 @@ func (x *ResourceQuota) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Status = ResourceQuotaStatus{}
} else {
- yyv4140 := &x.Status
- yyv4140.CodecDecodeSelf(d)
+ yyv4145 := &x.Status
+ yyv4145.CodecDecodeSelf(d)
}
for {
- yyj4135++
- if yyhl4135 {
- yyb4135 = yyj4135 > l
+ yyj4140++
+ if yyhl4140 {
+ yyb4140 = yyj4140 > l
} else {
- yyb4135 = r.CheckBreak()
+ yyb4140 = r.CheckBreak()
}
- if yyb4135 {
+ if yyb4140 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj4135-1, "")
+ z.DecStructFieldNotFound(yyj4140-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -52054,37 +52118,37 @@ func (x *ResourceQuotaList) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym4141 := z.EncBinary()
- _ = yym4141
+ yym4146 := z.EncBinary()
+ _ = yym4146
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep4142 := !z.EncBinary()
- yy2arr4142 := z.EncBasicHandle().StructToArray
- var yyq4142 [4]bool
- _, _, _ = yysep4142, yyq4142, yy2arr4142
- const yyr4142 bool = false
- yyq4142[0] = x.Kind != ""
- yyq4142[1] = x.APIVersion != ""
- yyq4142[2] = true
- var yynn4142 int
- if yyr4142 || yy2arr4142 {
+ yysep4147 := !z.EncBinary()
+ yy2arr4147 := z.EncBasicHandle().StructToArray
+ var yyq4147 [4]bool
+ _, _, _ = yysep4147, yyq4147, yy2arr4147
+ const yyr4147 bool = false
+ yyq4147[0] = x.Kind != ""
+ yyq4147[1] = x.APIVersion != ""
+ yyq4147[2] = true
+ var yynn4147 int
+ if yyr4147 || yy2arr4147 {
r.EncodeArrayStart(4)
} else {
- yynn4142 = 1
- for _, b := range yyq4142 {
+ yynn4147 = 1
+ for _, b := range yyq4147 {
if b {
- yynn4142++
+ yynn4147++
}
}
- r.EncodeMapStart(yynn4142)
- yynn4142 = 0
+ r.EncodeMapStart(yynn4147)
+ yynn4147 = 0
}
- if yyr4142 || yy2arr4142 {
+ if yyr4147 || yy2arr4147 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq4142[0] {
- yym4144 := z.EncBinary()
- _ = yym4144
+ if yyq4147[0] {
+ yym4149 := z.EncBinary()
+ _ = yym4149
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
@@ -52093,23 +52157,23 @@ func (x *ResourceQuotaList) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq4142[0] {
+ if yyq4147[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("kind"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym4145 := z.EncBinary()
- _ = yym4145
+ yym4150 := z.EncBinary()
+ _ = yym4150
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
}
}
}
- if yyr4142 || yy2arr4142 {
+ if yyr4147 || yy2arr4147 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq4142[1] {
- yym4147 := z.EncBinary()
- _ = yym4147
+ if yyq4147[1] {
+ yym4152 := z.EncBinary()
+ _ = yym4152
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
@@ -52118,54 +52182,54 @@ func (x *ResourceQuotaList) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq4142[1] {
+ if yyq4147[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym4148 := z.EncBinary()
- _ = yym4148
+ yym4153 := z.EncBinary()
+ _ = yym4153
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
}
}
}
- if yyr4142 || yy2arr4142 {
+ if yyr4147 || yy2arr4147 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq4142[2] {
- yy4150 := &x.ListMeta
- yym4151 := z.EncBinary()
- _ = yym4151
+ if yyq4147[2] {
+ yy4155 := &x.ListMeta
+ yym4156 := z.EncBinary()
+ _ = yym4156
if false {
- } else if z.HasExtensions() && z.EncExt(yy4150) {
+ } else if z.HasExtensions() && z.EncExt(yy4155) {
} else {
- z.EncFallback(yy4150)
+ z.EncFallback(yy4155)
}
} else {
r.EncodeNil()
}
} else {
- if yyq4142[2] {
+ if yyq4147[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("metadata"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy4152 := &x.ListMeta
- yym4153 := z.EncBinary()
- _ = yym4153
+ yy4157 := &x.ListMeta
+ yym4158 := z.EncBinary()
+ _ = yym4158
if false {
- } else if z.HasExtensions() && z.EncExt(yy4152) {
+ } else if z.HasExtensions() && z.EncExt(yy4157) {
} else {
- z.EncFallback(yy4152)
+ z.EncFallback(yy4157)
}
}
}
- if yyr4142 || yy2arr4142 {
+ if yyr4147 || yy2arr4147 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if x.Items == nil {
r.EncodeNil()
} else {
- yym4155 := z.EncBinary()
- _ = yym4155
+ yym4160 := z.EncBinary()
+ _ = yym4160
if false {
} else {
h.encSliceResourceQuota(([]ResourceQuota)(x.Items), e)
@@ -52178,15 +52242,15 @@ func (x *ResourceQuotaList) CodecEncodeSelf(e *codec1978.Encoder) {
if x.Items == nil {
r.EncodeNil()
} else {
- yym4156 := z.EncBinary()
- _ = yym4156
+ yym4161 := z.EncBinary()
+ _ = yym4161
if false {
} else {
h.encSliceResourceQuota(([]ResourceQuota)(x.Items), e)
}
}
}
- if yyr4142 || yy2arr4142 {
+ if yyr4147 || yy2arr4147 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -52199,25 +52263,25 @@ func (x *ResourceQuotaList) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym4157 := z.DecBinary()
- _ = yym4157
+ yym4162 := z.DecBinary()
+ _ = yym4162
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct4158 := r.ContainerType()
- if yyct4158 == codecSelferValueTypeMap1234 {
- yyl4158 := r.ReadMapStart()
- if yyl4158 == 0 {
+ yyct4163 := r.ContainerType()
+ if yyct4163 == codecSelferValueTypeMap1234 {
+ yyl4163 := r.ReadMapStart()
+ if yyl4163 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl4158, d)
+ x.codecDecodeSelfFromMap(yyl4163, d)
}
- } else if yyct4158 == codecSelferValueTypeArray1234 {
- yyl4158 := r.ReadArrayStart()
- if yyl4158 == 0 {
+ } else if yyct4163 == codecSelferValueTypeArray1234 {
+ yyl4163 := r.ReadArrayStart()
+ if yyl4163 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl4158, d)
+ x.codecDecodeSelfFromArray(yyl4163, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -52229,12 +52293,12 @@ func (x *ResourceQuotaList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder)
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys4159Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys4159Slc
- var yyhl4159 bool = l >= 0
- for yyj4159 := 0; ; yyj4159++ {
- if yyhl4159 {
- if yyj4159 >= l {
+ var yys4164Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys4164Slc
+ var yyhl4164 bool = l >= 0
+ for yyj4164 := 0; ; yyj4164++ {
+ if yyhl4164 {
+ if yyj4164 >= l {
break
}
} else {
@@ -52243,10 +52307,10 @@ func (x *ResourceQuotaList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder)
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys4159Slc = r.DecodeBytes(yys4159Slc, true, true)
- yys4159 := string(yys4159Slc)
+ yys4164Slc = r.DecodeBytes(yys4164Slc, true, true)
+ yys4164 := string(yys4164Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys4159 {
+ switch yys4164 {
case "kind":
if r.TryDecodeAsNil() {
x.Kind = ""
@@ -52263,31 +52327,31 @@ func (x *ResourceQuotaList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder)
if r.TryDecodeAsNil() {
x.ListMeta = pkg2_v1.ListMeta{}
} else {
- yyv4162 := &x.ListMeta
- yym4163 := z.DecBinary()
- _ = yym4163
+ yyv4167 := &x.ListMeta
+ yym4168 := z.DecBinary()
+ _ = yym4168
if false {
- } else if z.HasExtensions() && z.DecExt(yyv4162) {
+ } else if z.HasExtensions() && z.DecExt(yyv4167) {
} else {
- z.DecFallback(yyv4162, false)
+ z.DecFallback(yyv4167, false)
}
}
case "items":
if r.TryDecodeAsNil() {
x.Items = nil
} else {
- yyv4164 := &x.Items
- yym4165 := z.DecBinary()
- _ = yym4165
+ yyv4169 := &x.Items
+ yym4170 := z.DecBinary()
+ _ = yym4170
if false {
} else {
- h.decSliceResourceQuota((*[]ResourceQuota)(yyv4164), d)
+ h.decSliceResourceQuota((*[]ResourceQuota)(yyv4169), d)
}
}
default:
- z.DecStructFieldNotFound(-1, yys4159)
- } // end switch yys4159
- } // end for yyj4159
+ z.DecStructFieldNotFound(-1, yys4164)
+ } // end switch yys4164
+ } // end for yyj4164
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -52295,16 +52359,16 @@ func (x *ResourceQuotaList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj4166 int
- var yyb4166 bool
- var yyhl4166 bool = l >= 0
- yyj4166++
- if yyhl4166 {
- yyb4166 = yyj4166 > l
+ var yyj4171 int
+ var yyb4171 bool
+ var yyhl4171 bool = l >= 0
+ yyj4171++
+ if yyhl4171 {
+ yyb4171 = yyj4171 > l
} else {
- yyb4166 = r.CheckBreak()
+ yyb4171 = r.CheckBreak()
}
- if yyb4166 {
+ if yyb4171 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -52314,13 +52378,13 @@ func (x *ResourceQuotaList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder
} else {
x.Kind = string(r.DecodeString())
}
- yyj4166++
- if yyhl4166 {
- yyb4166 = yyj4166 > l
+ yyj4171++
+ if yyhl4171 {
+ yyb4171 = yyj4171 > l
} else {
- yyb4166 = r.CheckBreak()
+ yyb4171 = r.CheckBreak()
}
- if yyb4166 {
+ if yyb4171 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -52330,13 +52394,13 @@ func (x *ResourceQuotaList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder
} else {
x.APIVersion = string(r.DecodeString())
}
- yyj4166++
- if yyhl4166 {
- yyb4166 = yyj4166 > l
+ yyj4171++
+ if yyhl4171 {
+ yyb4171 = yyj4171 > l
} else {
- yyb4166 = r.CheckBreak()
+ yyb4171 = r.CheckBreak()
}
- if yyb4166 {
+ if yyb4171 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -52344,22 +52408,22 @@ func (x *ResourceQuotaList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder
if r.TryDecodeAsNil() {
x.ListMeta = pkg2_v1.ListMeta{}
} else {
- yyv4169 := &x.ListMeta
- yym4170 := z.DecBinary()
- _ = yym4170
+ yyv4174 := &x.ListMeta
+ yym4175 := z.DecBinary()
+ _ = yym4175
if false {
- } else if z.HasExtensions() && z.DecExt(yyv4169) {
+ } else if z.HasExtensions() && z.DecExt(yyv4174) {
} else {
- z.DecFallback(yyv4169, false)
+ z.DecFallback(yyv4174, false)
}
}
- yyj4166++
- if yyhl4166 {
- yyb4166 = yyj4166 > l
+ yyj4171++
+ if yyhl4171 {
+ yyb4171 = yyj4171 > l
} else {
- yyb4166 = r.CheckBreak()
+ yyb4171 = r.CheckBreak()
}
- if yyb4166 {
+ if yyb4171 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -52367,26 +52431,26 @@ func (x *ResourceQuotaList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder
if r.TryDecodeAsNil() {
x.Items = nil
} else {
- yyv4171 := &x.Items
- yym4172 := z.DecBinary()
- _ = yym4172
+ yyv4176 := &x.Items
+ yym4177 := z.DecBinary()
+ _ = yym4177
if false {
} else {
- h.decSliceResourceQuota((*[]ResourceQuota)(yyv4171), d)
+ h.decSliceResourceQuota((*[]ResourceQuota)(yyv4176), d)
}
}
for {
- yyj4166++
- if yyhl4166 {
- yyb4166 = yyj4166 > l
+ yyj4171++
+ if yyhl4171 {
+ yyb4171 = yyj4171 > l
} else {
- yyb4166 = r.CheckBreak()
+ yyb4171 = r.CheckBreak()
}
- if yyb4166 {
+ if yyb4171 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj4166-1, "")
+ z.DecStructFieldNotFound(yyj4171-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -52398,40 +52462,40 @@ func (x *Secret) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym4173 := z.EncBinary()
- _ = yym4173
+ yym4178 := z.EncBinary()
+ _ = yym4178
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep4174 := !z.EncBinary()
- yy2arr4174 := z.EncBasicHandle().StructToArray
- var yyq4174 [6]bool
- _, _, _ = yysep4174, yyq4174, yy2arr4174
- const yyr4174 bool = false
- yyq4174[0] = x.Kind != ""
- yyq4174[1] = x.APIVersion != ""
- yyq4174[2] = true
- yyq4174[3] = len(x.Data) != 0
- yyq4174[4] = len(x.StringData) != 0
- yyq4174[5] = x.Type != ""
- var yynn4174 int
- if yyr4174 || yy2arr4174 {
+ yysep4179 := !z.EncBinary()
+ yy2arr4179 := z.EncBasicHandle().StructToArray
+ var yyq4179 [6]bool
+ _, _, _ = yysep4179, yyq4179, yy2arr4179
+ const yyr4179 bool = false
+ yyq4179[0] = x.Kind != ""
+ yyq4179[1] = x.APIVersion != ""
+ yyq4179[2] = true
+ yyq4179[3] = len(x.Data) != 0
+ yyq4179[4] = len(x.StringData) != 0
+ yyq4179[5] = x.Type != ""
+ var yynn4179 int
+ if yyr4179 || yy2arr4179 {
r.EncodeArrayStart(6)
} else {
- yynn4174 = 0
- for _, b := range yyq4174 {
+ yynn4179 = 0
+ for _, b := range yyq4179 {
if b {
- yynn4174++
+ yynn4179++
}
}
- r.EncodeMapStart(yynn4174)
- yynn4174 = 0
+ r.EncodeMapStart(yynn4179)
+ yynn4179 = 0
}
- if yyr4174 || yy2arr4174 {
+ if yyr4179 || yy2arr4179 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq4174[0] {
- yym4176 := z.EncBinary()
- _ = yym4176
+ if yyq4179[0] {
+ yym4181 := z.EncBinary()
+ _ = yym4181
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
@@ -52440,23 +52504,23 @@ func (x *Secret) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq4174[0] {
+ if yyq4179[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("kind"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym4177 := z.EncBinary()
- _ = yym4177
+ yym4182 := z.EncBinary()
+ _ = yym4182
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
}
}
}
- if yyr4174 || yy2arr4174 {
+ if yyr4179 || yy2arr4179 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq4174[1] {
- yym4179 := z.EncBinary()
- _ = yym4179
+ if yyq4179[1] {
+ yym4184 := z.EncBinary()
+ _ = yym4184
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
@@ -52465,43 +52529,43 @@ func (x *Secret) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq4174[1] {
+ if yyq4179[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym4180 := z.EncBinary()
- _ = yym4180
+ yym4185 := z.EncBinary()
+ _ = yym4185
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
}
}
}
- if yyr4174 || yy2arr4174 {
+ if yyr4179 || yy2arr4179 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq4174[2] {
- yy4182 := &x.ObjectMeta
- yy4182.CodecEncodeSelf(e)
+ if yyq4179[2] {
+ yy4187 := &x.ObjectMeta
+ yy4187.CodecEncodeSelf(e)
} else {
r.EncodeNil()
}
} else {
- if yyq4174[2] {
+ if yyq4179[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("metadata"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy4183 := &x.ObjectMeta
- yy4183.CodecEncodeSelf(e)
+ yy4188 := &x.ObjectMeta
+ yy4188.CodecEncodeSelf(e)
}
}
- if yyr4174 || yy2arr4174 {
+ if yyr4179 || yy2arr4179 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq4174[3] {
+ if yyq4179[3] {
if x.Data == nil {
r.EncodeNil()
} else {
- yym4185 := z.EncBinary()
- _ = yym4185
+ yym4190 := z.EncBinary()
+ _ = yym4190
if false {
} else {
h.encMapstringSliceuint8((map[string][]uint8)(x.Data), e)
@@ -52511,15 +52575,15 @@ func (x *Secret) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeNil()
}
} else {
- if yyq4174[3] {
+ if yyq4179[3] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("data"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
if x.Data == nil {
r.EncodeNil()
} else {
- yym4186 := z.EncBinary()
- _ = yym4186
+ yym4191 := z.EncBinary()
+ _ = yym4191
if false {
} else {
h.encMapstringSliceuint8((map[string][]uint8)(x.Data), e)
@@ -52527,14 +52591,14 @@ func (x *Secret) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
- if yyr4174 || yy2arr4174 {
+ if yyr4179 || yy2arr4179 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq4174[4] {
+ if yyq4179[4] {
if x.StringData == nil {
r.EncodeNil()
} else {
- yym4188 := z.EncBinary()
- _ = yym4188
+ yym4193 := z.EncBinary()
+ _ = yym4193
if false {
} else {
z.F.EncMapStringStringV(x.StringData, false, e)
@@ -52544,15 +52608,15 @@ func (x *Secret) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeNil()
}
} else {
- if yyq4174[4] {
+ if yyq4179[4] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("stringData"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
if x.StringData == nil {
r.EncodeNil()
} else {
- yym4189 := z.EncBinary()
- _ = yym4189
+ yym4194 := z.EncBinary()
+ _ = yym4194
if false {
} else {
z.F.EncMapStringStringV(x.StringData, false, e)
@@ -52560,22 +52624,22 @@ func (x *Secret) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
- if yyr4174 || yy2arr4174 {
+ if yyr4179 || yy2arr4179 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq4174[5] {
+ if yyq4179[5] {
x.Type.CodecEncodeSelf(e)
} else {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq4174[5] {
+ if yyq4179[5] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("type"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
x.Type.CodecEncodeSelf(e)
}
}
- if yyr4174 || yy2arr4174 {
+ if yyr4179 || yy2arr4179 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -52588,25 +52652,25 @@ func (x *Secret) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym4191 := z.DecBinary()
- _ = yym4191
+ yym4196 := z.DecBinary()
+ _ = yym4196
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct4192 := r.ContainerType()
- if yyct4192 == codecSelferValueTypeMap1234 {
- yyl4192 := r.ReadMapStart()
- if yyl4192 == 0 {
+ yyct4197 := r.ContainerType()
+ if yyct4197 == codecSelferValueTypeMap1234 {
+ yyl4197 := r.ReadMapStart()
+ if yyl4197 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl4192, d)
+ x.codecDecodeSelfFromMap(yyl4197, d)
}
- } else if yyct4192 == codecSelferValueTypeArray1234 {
- yyl4192 := r.ReadArrayStart()
- if yyl4192 == 0 {
+ } else if yyct4197 == codecSelferValueTypeArray1234 {
+ yyl4197 := r.ReadArrayStart()
+ if yyl4197 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl4192, d)
+ x.codecDecodeSelfFromArray(yyl4197, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -52618,12 +52682,12 @@ func (x *Secret) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys4193Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys4193Slc
- var yyhl4193 bool = l >= 0
- for yyj4193 := 0; ; yyj4193++ {
- if yyhl4193 {
- if yyj4193 >= l {
+ var yys4198Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys4198Slc
+ var yyhl4198 bool = l >= 0
+ for yyj4198 := 0; ; yyj4198++ {
+ if yyhl4198 {
+ if yyj4198 >= l {
break
}
} else {
@@ -52632,10 +52696,10 @@ func (x *Secret) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys4193Slc = r.DecodeBytes(yys4193Slc, true, true)
- yys4193 := string(yys4193Slc)
+ yys4198Slc = r.DecodeBytes(yys4198Slc, true, true)
+ yys4198 := string(yys4198Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys4193 {
+ switch yys4198 {
case "kind":
if r.TryDecodeAsNil() {
x.Kind = ""
@@ -52652,31 +52716,31 @@ func (x *Secret) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.ObjectMeta = ObjectMeta{}
} else {
- yyv4196 := &x.ObjectMeta
- yyv4196.CodecDecodeSelf(d)
+ yyv4201 := &x.ObjectMeta
+ yyv4201.CodecDecodeSelf(d)
}
case "data":
if r.TryDecodeAsNil() {
x.Data = nil
} else {
- yyv4197 := &x.Data
- yym4198 := z.DecBinary()
- _ = yym4198
+ yyv4202 := &x.Data
+ yym4203 := z.DecBinary()
+ _ = yym4203
if false {
} else {
- h.decMapstringSliceuint8((*map[string][]uint8)(yyv4197), d)
+ h.decMapstringSliceuint8((*map[string][]uint8)(yyv4202), d)
}
}
case "stringData":
if r.TryDecodeAsNil() {
x.StringData = nil
} else {
- yyv4199 := &x.StringData
- yym4200 := z.DecBinary()
- _ = yym4200
+ yyv4204 := &x.StringData
+ yym4205 := z.DecBinary()
+ _ = yym4205
if false {
} else {
- z.F.DecMapStringStringX(yyv4199, false, d)
+ z.F.DecMapStringStringX(yyv4204, false, d)
}
}
case "type":
@@ -52686,9 +52750,9 @@ func (x *Secret) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
x.Type = SecretType(r.DecodeString())
}
default:
- z.DecStructFieldNotFound(-1, yys4193)
- } // end switch yys4193
- } // end for yyj4193
+ z.DecStructFieldNotFound(-1, yys4198)
+ } // end switch yys4198
+ } // end for yyj4198
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -52696,16 +52760,16 @@ func (x *Secret) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj4202 int
- var yyb4202 bool
- var yyhl4202 bool = l >= 0
- yyj4202++
- if yyhl4202 {
- yyb4202 = yyj4202 > l
+ var yyj4207 int
+ var yyb4207 bool
+ var yyhl4207 bool = l >= 0
+ yyj4207++
+ if yyhl4207 {
+ yyb4207 = yyj4207 > l
} else {
- yyb4202 = r.CheckBreak()
+ yyb4207 = r.CheckBreak()
}
- if yyb4202 {
+ if yyb4207 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -52715,13 +52779,13 @@ func (x *Secret) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Kind = string(r.DecodeString())
}
- yyj4202++
- if yyhl4202 {
- yyb4202 = yyj4202 > l
+ yyj4207++
+ if yyhl4207 {
+ yyb4207 = yyj4207 > l
} else {
- yyb4202 = r.CheckBreak()
+ yyb4207 = r.CheckBreak()
}
- if yyb4202 {
+ if yyb4207 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -52731,13 +52795,13 @@ func (x *Secret) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.APIVersion = string(r.DecodeString())
}
- yyj4202++
- if yyhl4202 {
- yyb4202 = yyj4202 > l
+ yyj4207++
+ if yyhl4207 {
+ yyb4207 = yyj4207 > l
} else {
- yyb4202 = r.CheckBreak()
+ yyb4207 = r.CheckBreak()
}
- if yyb4202 {
+ if yyb4207 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -52745,16 +52809,16 @@ func (x *Secret) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.ObjectMeta = ObjectMeta{}
} else {
- yyv4205 := &x.ObjectMeta
- yyv4205.CodecDecodeSelf(d)
+ yyv4210 := &x.ObjectMeta
+ yyv4210.CodecDecodeSelf(d)
}
- yyj4202++
- if yyhl4202 {
- yyb4202 = yyj4202 > l
+ yyj4207++
+ if yyhl4207 {
+ yyb4207 = yyj4207 > l
} else {
- yyb4202 = r.CheckBreak()
+ yyb4207 = r.CheckBreak()
}
- if yyb4202 {
+ if yyb4207 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -52762,21 +52826,21 @@ func (x *Secret) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Data = nil
} else {
- yyv4206 := &x.Data
- yym4207 := z.DecBinary()
- _ = yym4207
+ yyv4211 := &x.Data
+ yym4212 := z.DecBinary()
+ _ = yym4212
if false {
} else {
- h.decMapstringSliceuint8((*map[string][]uint8)(yyv4206), d)
+ h.decMapstringSliceuint8((*map[string][]uint8)(yyv4211), d)
}
}
- yyj4202++
- if yyhl4202 {
- yyb4202 = yyj4202 > l
+ yyj4207++
+ if yyhl4207 {
+ yyb4207 = yyj4207 > l
} else {
- yyb4202 = r.CheckBreak()
+ yyb4207 = r.CheckBreak()
}
- if yyb4202 {
+ if yyb4207 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -52784,21 +52848,21 @@ func (x *Secret) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.StringData = nil
} else {
- yyv4208 := &x.StringData
- yym4209 := z.DecBinary()
- _ = yym4209
+ yyv4213 := &x.StringData
+ yym4214 := z.DecBinary()
+ _ = yym4214
if false {
} else {
- z.F.DecMapStringStringX(yyv4208, false, d)
+ z.F.DecMapStringStringX(yyv4213, false, d)
}
}
- yyj4202++
- if yyhl4202 {
- yyb4202 = yyj4202 > l
+ yyj4207++
+ if yyhl4207 {
+ yyb4207 = yyj4207 > l
} else {
- yyb4202 = r.CheckBreak()
+ yyb4207 = r.CheckBreak()
}
- if yyb4202 {
+ if yyb4207 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -52809,17 +52873,17 @@ func (x *Secret) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
x.Type = SecretType(r.DecodeString())
}
for {
- yyj4202++
- if yyhl4202 {
- yyb4202 = yyj4202 > l
+ yyj4207++
+ if yyhl4207 {
+ yyb4207 = yyj4207 > l
} else {
- yyb4202 = r.CheckBreak()
+ yyb4207 = r.CheckBreak()
}
- if yyb4202 {
+ if yyb4207 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj4202-1, "")
+ z.DecStructFieldNotFound(yyj4207-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -52828,8 +52892,8 @@ func (x SecretType) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
- yym4211 := z.EncBinary()
- _ = yym4211
+ yym4216 := z.EncBinary()
+ _ = yym4216
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
@@ -52841,8 +52905,8 @@ func (x *SecretType) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym4212 := z.DecBinary()
- _ = yym4212
+ yym4217 := z.DecBinary()
+ _ = yym4217
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
@@ -52857,37 +52921,37 @@ func (x *SecretList) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym4213 := z.EncBinary()
- _ = yym4213
+ yym4218 := z.EncBinary()
+ _ = yym4218
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep4214 := !z.EncBinary()
- yy2arr4214 := z.EncBasicHandle().StructToArray
- var yyq4214 [4]bool
- _, _, _ = yysep4214, yyq4214, yy2arr4214
- const yyr4214 bool = false
- yyq4214[0] = x.Kind != ""
- yyq4214[1] = x.APIVersion != ""
- yyq4214[2] = true
- var yynn4214 int
- if yyr4214 || yy2arr4214 {
+ yysep4219 := !z.EncBinary()
+ yy2arr4219 := z.EncBasicHandle().StructToArray
+ var yyq4219 [4]bool
+ _, _, _ = yysep4219, yyq4219, yy2arr4219
+ const yyr4219 bool = false
+ yyq4219[0] = x.Kind != ""
+ yyq4219[1] = x.APIVersion != ""
+ yyq4219[2] = true
+ var yynn4219 int
+ if yyr4219 || yy2arr4219 {
r.EncodeArrayStart(4)
} else {
- yynn4214 = 1
- for _, b := range yyq4214 {
+ yynn4219 = 1
+ for _, b := range yyq4219 {
if b {
- yynn4214++
+ yynn4219++
}
}
- r.EncodeMapStart(yynn4214)
- yynn4214 = 0
+ r.EncodeMapStart(yynn4219)
+ yynn4219 = 0
}
- if yyr4214 || yy2arr4214 {
+ if yyr4219 || yy2arr4219 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq4214[0] {
- yym4216 := z.EncBinary()
- _ = yym4216
+ if yyq4219[0] {
+ yym4221 := z.EncBinary()
+ _ = yym4221
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
@@ -52896,23 +52960,23 @@ func (x *SecretList) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq4214[0] {
+ if yyq4219[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("kind"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym4217 := z.EncBinary()
- _ = yym4217
+ yym4222 := z.EncBinary()
+ _ = yym4222
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
}
}
}
- if yyr4214 || yy2arr4214 {
+ if yyr4219 || yy2arr4219 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq4214[1] {
- yym4219 := z.EncBinary()
- _ = yym4219
+ if yyq4219[1] {
+ yym4224 := z.EncBinary()
+ _ = yym4224
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
@@ -52921,54 +52985,54 @@ func (x *SecretList) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq4214[1] {
+ if yyq4219[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym4220 := z.EncBinary()
- _ = yym4220
+ yym4225 := z.EncBinary()
+ _ = yym4225
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
}
}
}
- if yyr4214 || yy2arr4214 {
+ if yyr4219 || yy2arr4219 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq4214[2] {
- yy4222 := &x.ListMeta
- yym4223 := z.EncBinary()
- _ = yym4223
+ if yyq4219[2] {
+ yy4227 := &x.ListMeta
+ yym4228 := z.EncBinary()
+ _ = yym4228
if false {
- } else if z.HasExtensions() && z.EncExt(yy4222) {
+ } else if z.HasExtensions() && z.EncExt(yy4227) {
} else {
- z.EncFallback(yy4222)
+ z.EncFallback(yy4227)
}
} else {
r.EncodeNil()
}
} else {
- if yyq4214[2] {
+ if yyq4219[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("metadata"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy4224 := &x.ListMeta
- yym4225 := z.EncBinary()
- _ = yym4225
+ yy4229 := &x.ListMeta
+ yym4230 := z.EncBinary()
+ _ = yym4230
if false {
- } else if z.HasExtensions() && z.EncExt(yy4224) {
+ } else if z.HasExtensions() && z.EncExt(yy4229) {
} else {
- z.EncFallback(yy4224)
+ z.EncFallback(yy4229)
}
}
}
- if yyr4214 || yy2arr4214 {
+ if yyr4219 || yy2arr4219 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if x.Items == nil {
r.EncodeNil()
} else {
- yym4227 := z.EncBinary()
- _ = yym4227
+ yym4232 := z.EncBinary()
+ _ = yym4232
if false {
} else {
h.encSliceSecret(([]Secret)(x.Items), e)
@@ -52981,15 +53045,15 @@ func (x *SecretList) CodecEncodeSelf(e *codec1978.Encoder) {
if x.Items == nil {
r.EncodeNil()
} else {
- yym4228 := z.EncBinary()
- _ = yym4228
+ yym4233 := z.EncBinary()
+ _ = yym4233
if false {
} else {
h.encSliceSecret(([]Secret)(x.Items), e)
}
}
}
- if yyr4214 || yy2arr4214 {
+ if yyr4219 || yy2arr4219 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -53002,25 +53066,25 @@ func (x *SecretList) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym4229 := z.DecBinary()
- _ = yym4229
+ yym4234 := z.DecBinary()
+ _ = yym4234
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct4230 := r.ContainerType()
- if yyct4230 == codecSelferValueTypeMap1234 {
- yyl4230 := r.ReadMapStart()
- if yyl4230 == 0 {
+ yyct4235 := r.ContainerType()
+ if yyct4235 == codecSelferValueTypeMap1234 {
+ yyl4235 := r.ReadMapStart()
+ if yyl4235 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl4230, d)
+ x.codecDecodeSelfFromMap(yyl4235, d)
}
- } else if yyct4230 == codecSelferValueTypeArray1234 {
- yyl4230 := r.ReadArrayStart()
- if yyl4230 == 0 {
+ } else if yyct4235 == codecSelferValueTypeArray1234 {
+ yyl4235 := r.ReadArrayStart()
+ if yyl4235 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl4230, d)
+ x.codecDecodeSelfFromArray(yyl4235, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -53032,12 +53096,12 @@ func (x *SecretList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys4231Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys4231Slc
- var yyhl4231 bool = l >= 0
- for yyj4231 := 0; ; yyj4231++ {
- if yyhl4231 {
- if yyj4231 >= l {
+ var yys4236Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys4236Slc
+ var yyhl4236 bool = l >= 0
+ for yyj4236 := 0; ; yyj4236++ {
+ if yyhl4236 {
+ if yyj4236 >= l {
break
}
} else {
@@ -53046,10 +53110,10 @@ func (x *SecretList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys4231Slc = r.DecodeBytes(yys4231Slc, true, true)
- yys4231 := string(yys4231Slc)
+ yys4236Slc = r.DecodeBytes(yys4236Slc, true, true)
+ yys4236 := string(yys4236Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys4231 {
+ switch yys4236 {
case "kind":
if r.TryDecodeAsNil() {
x.Kind = ""
@@ -53066,31 +53130,31 @@ func (x *SecretList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.ListMeta = pkg2_v1.ListMeta{}
} else {
- yyv4234 := &x.ListMeta
- yym4235 := z.DecBinary()
- _ = yym4235
+ yyv4239 := &x.ListMeta
+ yym4240 := z.DecBinary()
+ _ = yym4240
if false {
- } else if z.HasExtensions() && z.DecExt(yyv4234) {
+ } else if z.HasExtensions() && z.DecExt(yyv4239) {
} else {
- z.DecFallback(yyv4234, false)
+ z.DecFallback(yyv4239, false)
}
}
case "items":
if r.TryDecodeAsNil() {
x.Items = nil
} else {
- yyv4236 := &x.Items
- yym4237 := z.DecBinary()
- _ = yym4237
+ yyv4241 := &x.Items
+ yym4242 := z.DecBinary()
+ _ = yym4242
if false {
} else {
- h.decSliceSecret((*[]Secret)(yyv4236), d)
+ h.decSliceSecret((*[]Secret)(yyv4241), d)
}
}
default:
- z.DecStructFieldNotFound(-1, yys4231)
- } // end switch yys4231
- } // end for yyj4231
+ z.DecStructFieldNotFound(-1, yys4236)
+ } // end switch yys4236
+ } // end for yyj4236
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -53098,16 +53162,16 @@ func (x *SecretList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj4238 int
- var yyb4238 bool
- var yyhl4238 bool = l >= 0
- yyj4238++
- if yyhl4238 {
- yyb4238 = yyj4238 > l
+ var yyj4243 int
+ var yyb4243 bool
+ var yyhl4243 bool = l >= 0
+ yyj4243++
+ if yyhl4243 {
+ yyb4243 = yyj4243 > l
} else {
- yyb4238 = r.CheckBreak()
+ yyb4243 = r.CheckBreak()
}
- if yyb4238 {
+ if yyb4243 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -53117,13 +53181,13 @@ func (x *SecretList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Kind = string(r.DecodeString())
}
- yyj4238++
- if yyhl4238 {
- yyb4238 = yyj4238 > l
+ yyj4243++
+ if yyhl4243 {
+ yyb4243 = yyj4243 > l
} else {
- yyb4238 = r.CheckBreak()
+ yyb4243 = r.CheckBreak()
}
- if yyb4238 {
+ if yyb4243 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -53133,13 +53197,13 @@ func (x *SecretList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.APIVersion = string(r.DecodeString())
}
- yyj4238++
- if yyhl4238 {
- yyb4238 = yyj4238 > l
+ yyj4243++
+ if yyhl4243 {
+ yyb4243 = yyj4243 > l
} else {
- yyb4238 = r.CheckBreak()
+ yyb4243 = r.CheckBreak()
}
- if yyb4238 {
+ if yyb4243 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -53147,22 +53211,22 @@ func (x *SecretList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.ListMeta = pkg2_v1.ListMeta{}
} else {
- yyv4241 := &x.ListMeta
- yym4242 := z.DecBinary()
- _ = yym4242
+ yyv4246 := &x.ListMeta
+ yym4247 := z.DecBinary()
+ _ = yym4247
if false {
- } else if z.HasExtensions() && z.DecExt(yyv4241) {
+ } else if z.HasExtensions() && z.DecExt(yyv4246) {
} else {
- z.DecFallback(yyv4241, false)
+ z.DecFallback(yyv4246, false)
}
}
- yyj4238++
- if yyhl4238 {
- yyb4238 = yyj4238 > l
+ yyj4243++
+ if yyhl4243 {
+ yyb4243 = yyj4243 > l
} else {
- yyb4238 = r.CheckBreak()
+ yyb4243 = r.CheckBreak()
}
- if yyb4238 {
+ if yyb4243 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -53170,26 +53234,26 @@ func (x *SecretList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Items = nil
} else {
- yyv4243 := &x.Items
- yym4244 := z.DecBinary()
- _ = yym4244
+ yyv4248 := &x.Items
+ yym4249 := z.DecBinary()
+ _ = yym4249
if false {
} else {
- h.decSliceSecret((*[]Secret)(yyv4243), d)
+ h.decSliceSecret((*[]Secret)(yyv4248), d)
}
}
for {
- yyj4238++
- if yyhl4238 {
- yyb4238 = yyj4238 > l
+ yyj4243++
+ if yyhl4243 {
+ yyb4243 = yyj4243 > l
} else {
- yyb4238 = r.CheckBreak()
+ yyb4243 = r.CheckBreak()
}
- if yyb4238 {
+ if yyb4243 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj4238-1, "")
+ z.DecStructFieldNotFound(yyj4243-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -53201,38 +53265,38 @@ func (x *ConfigMap) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym4245 := z.EncBinary()
- _ = yym4245
+ yym4250 := z.EncBinary()
+ _ = yym4250
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep4246 := !z.EncBinary()
- yy2arr4246 := z.EncBasicHandle().StructToArray
- var yyq4246 [4]bool
- _, _, _ = yysep4246, yyq4246, yy2arr4246
- const yyr4246 bool = false
- yyq4246[0] = x.Kind != ""
- yyq4246[1] = x.APIVersion != ""
- yyq4246[2] = true
- yyq4246[3] = len(x.Data) != 0
- var yynn4246 int
- if yyr4246 || yy2arr4246 {
+ yysep4251 := !z.EncBinary()
+ yy2arr4251 := z.EncBasicHandle().StructToArray
+ var yyq4251 [4]bool
+ _, _, _ = yysep4251, yyq4251, yy2arr4251
+ const yyr4251 bool = false
+ yyq4251[0] = x.Kind != ""
+ yyq4251[1] = x.APIVersion != ""
+ yyq4251[2] = true
+ yyq4251[3] = len(x.Data) != 0
+ var yynn4251 int
+ if yyr4251 || yy2arr4251 {
r.EncodeArrayStart(4)
} else {
- yynn4246 = 0
- for _, b := range yyq4246 {
+ yynn4251 = 0
+ for _, b := range yyq4251 {
if b {
- yynn4246++
+ yynn4251++
}
}
- r.EncodeMapStart(yynn4246)
- yynn4246 = 0
+ r.EncodeMapStart(yynn4251)
+ yynn4251 = 0
}
- if yyr4246 || yy2arr4246 {
+ if yyr4251 || yy2arr4251 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq4246[0] {
- yym4248 := z.EncBinary()
- _ = yym4248
+ if yyq4251[0] {
+ yym4253 := z.EncBinary()
+ _ = yym4253
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
@@ -53241,23 +53305,23 @@ func (x *ConfigMap) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq4246[0] {
+ if yyq4251[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("kind"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym4249 := z.EncBinary()
- _ = yym4249
+ yym4254 := z.EncBinary()
+ _ = yym4254
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
}
}
}
- if yyr4246 || yy2arr4246 {
+ if yyr4251 || yy2arr4251 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq4246[1] {
- yym4251 := z.EncBinary()
- _ = yym4251
+ if yyq4251[1] {
+ yym4256 := z.EncBinary()
+ _ = yym4256
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
@@ -53266,43 +53330,43 @@ func (x *ConfigMap) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq4246[1] {
+ if yyq4251[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym4252 := z.EncBinary()
- _ = yym4252
+ yym4257 := z.EncBinary()
+ _ = yym4257
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
}
}
}
- if yyr4246 || yy2arr4246 {
+ if yyr4251 || yy2arr4251 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq4246[2] {
- yy4254 := &x.ObjectMeta
- yy4254.CodecEncodeSelf(e)
+ if yyq4251[2] {
+ yy4259 := &x.ObjectMeta
+ yy4259.CodecEncodeSelf(e)
} else {
r.EncodeNil()
}
} else {
- if yyq4246[2] {
+ if yyq4251[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("metadata"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy4255 := &x.ObjectMeta
- yy4255.CodecEncodeSelf(e)
+ yy4260 := &x.ObjectMeta
+ yy4260.CodecEncodeSelf(e)
}
}
- if yyr4246 || yy2arr4246 {
+ if yyr4251 || yy2arr4251 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq4246[3] {
+ if yyq4251[3] {
if x.Data == nil {
r.EncodeNil()
} else {
- yym4257 := z.EncBinary()
- _ = yym4257
+ yym4262 := z.EncBinary()
+ _ = yym4262
if false {
} else {
z.F.EncMapStringStringV(x.Data, false, e)
@@ -53312,15 +53376,15 @@ func (x *ConfigMap) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeNil()
}
} else {
- if yyq4246[3] {
+ if yyq4251[3] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("data"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
if x.Data == nil {
r.EncodeNil()
} else {
- yym4258 := z.EncBinary()
- _ = yym4258
+ yym4263 := z.EncBinary()
+ _ = yym4263
if false {
} else {
z.F.EncMapStringStringV(x.Data, false, e)
@@ -53328,7 +53392,7 @@ func (x *ConfigMap) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
- if yyr4246 || yy2arr4246 {
+ if yyr4251 || yy2arr4251 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -53341,25 +53405,25 @@ func (x *ConfigMap) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym4259 := z.DecBinary()
- _ = yym4259
+ yym4264 := z.DecBinary()
+ _ = yym4264
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct4260 := r.ContainerType()
- if yyct4260 == codecSelferValueTypeMap1234 {
- yyl4260 := r.ReadMapStart()
- if yyl4260 == 0 {
+ yyct4265 := r.ContainerType()
+ if yyct4265 == codecSelferValueTypeMap1234 {
+ yyl4265 := r.ReadMapStart()
+ if yyl4265 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl4260, d)
+ x.codecDecodeSelfFromMap(yyl4265, d)
}
- } else if yyct4260 == codecSelferValueTypeArray1234 {
- yyl4260 := r.ReadArrayStart()
- if yyl4260 == 0 {
+ } else if yyct4265 == codecSelferValueTypeArray1234 {
+ yyl4265 := r.ReadArrayStart()
+ if yyl4265 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl4260, d)
+ x.codecDecodeSelfFromArray(yyl4265, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -53371,12 +53435,12 @@ func (x *ConfigMap) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys4261Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys4261Slc
- var yyhl4261 bool = l >= 0
- for yyj4261 := 0; ; yyj4261++ {
- if yyhl4261 {
- if yyj4261 >= l {
+ var yys4266Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys4266Slc
+ var yyhl4266 bool = l >= 0
+ for yyj4266 := 0; ; yyj4266++ {
+ if yyhl4266 {
+ if yyj4266 >= l {
break
}
} else {
@@ -53385,10 +53449,10 @@ func (x *ConfigMap) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys4261Slc = r.DecodeBytes(yys4261Slc, true, true)
- yys4261 := string(yys4261Slc)
+ yys4266Slc = r.DecodeBytes(yys4266Slc, true, true)
+ yys4266 := string(yys4266Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys4261 {
+ switch yys4266 {
case "kind":
if r.TryDecodeAsNil() {
x.Kind = ""
@@ -53405,25 +53469,25 @@ func (x *ConfigMap) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.ObjectMeta = ObjectMeta{}
} else {
- yyv4264 := &x.ObjectMeta
- yyv4264.CodecDecodeSelf(d)
+ yyv4269 := &x.ObjectMeta
+ yyv4269.CodecDecodeSelf(d)
}
case "data":
if r.TryDecodeAsNil() {
x.Data = nil
} else {
- yyv4265 := &x.Data
- yym4266 := z.DecBinary()
- _ = yym4266
+ yyv4270 := &x.Data
+ yym4271 := z.DecBinary()
+ _ = yym4271
if false {
} else {
- z.F.DecMapStringStringX(yyv4265, false, d)
+ z.F.DecMapStringStringX(yyv4270, false, d)
}
}
default:
- z.DecStructFieldNotFound(-1, yys4261)
- } // end switch yys4261
- } // end for yyj4261
+ z.DecStructFieldNotFound(-1, yys4266)
+ } // end switch yys4266
+ } // end for yyj4266
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -53431,16 +53495,16 @@ func (x *ConfigMap) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj4267 int
- var yyb4267 bool
- var yyhl4267 bool = l >= 0
- yyj4267++
- if yyhl4267 {
- yyb4267 = yyj4267 > l
+ var yyj4272 int
+ var yyb4272 bool
+ var yyhl4272 bool = l >= 0
+ yyj4272++
+ if yyhl4272 {
+ yyb4272 = yyj4272 > l
} else {
- yyb4267 = r.CheckBreak()
+ yyb4272 = r.CheckBreak()
}
- if yyb4267 {
+ if yyb4272 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -53450,13 +53514,13 @@ func (x *ConfigMap) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Kind = string(r.DecodeString())
}
- yyj4267++
- if yyhl4267 {
- yyb4267 = yyj4267 > l
+ yyj4272++
+ if yyhl4272 {
+ yyb4272 = yyj4272 > l
} else {
- yyb4267 = r.CheckBreak()
+ yyb4272 = r.CheckBreak()
}
- if yyb4267 {
+ if yyb4272 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -53466,13 +53530,13 @@ func (x *ConfigMap) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.APIVersion = string(r.DecodeString())
}
- yyj4267++
- if yyhl4267 {
- yyb4267 = yyj4267 > l
+ yyj4272++
+ if yyhl4272 {
+ yyb4272 = yyj4272 > l
} else {
- yyb4267 = r.CheckBreak()
+ yyb4272 = r.CheckBreak()
}
- if yyb4267 {
+ if yyb4272 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -53480,16 +53544,16 @@ func (x *ConfigMap) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.ObjectMeta = ObjectMeta{}
} else {
- yyv4270 := &x.ObjectMeta
- yyv4270.CodecDecodeSelf(d)
+ yyv4275 := &x.ObjectMeta
+ yyv4275.CodecDecodeSelf(d)
}
- yyj4267++
- if yyhl4267 {
- yyb4267 = yyj4267 > l
+ yyj4272++
+ if yyhl4272 {
+ yyb4272 = yyj4272 > l
} else {
- yyb4267 = r.CheckBreak()
+ yyb4272 = r.CheckBreak()
}
- if yyb4267 {
+ if yyb4272 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -53497,26 +53561,26 @@ func (x *ConfigMap) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Data = nil
} else {
- yyv4271 := &x.Data
- yym4272 := z.DecBinary()
- _ = yym4272
+ yyv4276 := &x.Data
+ yym4277 := z.DecBinary()
+ _ = yym4277
if false {
} else {
- z.F.DecMapStringStringX(yyv4271, false, d)
+ z.F.DecMapStringStringX(yyv4276, false, d)
}
}
for {
- yyj4267++
- if yyhl4267 {
- yyb4267 = yyj4267 > l
+ yyj4272++
+ if yyhl4272 {
+ yyb4272 = yyj4272 > l
} else {
- yyb4267 = r.CheckBreak()
+ yyb4272 = r.CheckBreak()
}
- if yyb4267 {
+ if yyb4272 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj4267-1, "")
+ z.DecStructFieldNotFound(yyj4272-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -53528,37 +53592,37 @@ func (x *ConfigMapList) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym4273 := z.EncBinary()
- _ = yym4273
+ yym4278 := z.EncBinary()
+ _ = yym4278
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep4274 := !z.EncBinary()
- yy2arr4274 := z.EncBasicHandle().StructToArray
- var yyq4274 [4]bool
- _, _, _ = yysep4274, yyq4274, yy2arr4274
- const yyr4274 bool = false
- yyq4274[0] = x.Kind != ""
- yyq4274[1] = x.APIVersion != ""
- yyq4274[2] = true
- var yynn4274 int
- if yyr4274 || yy2arr4274 {
+ yysep4279 := !z.EncBinary()
+ yy2arr4279 := z.EncBasicHandle().StructToArray
+ var yyq4279 [4]bool
+ _, _, _ = yysep4279, yyq4279, yy2arr4279
+ const yyr4279 bool = false
+ yyq4279[0] = x.Kind != ""
+ yyq4279[1] = x.APIVersion != ""
+ yyq4279[2] = true
+ var yynn4279 int
+ if yyr4279 || yy2arr4279 {
r.EncodeArrayStart(4)
} else {
- yynn4274 = 1
- for _, b := range yyq4274 {
+ yynn4279 = 1
+ for _, b := range yyq4279 {
if b {
- yynn4274++
+ yynn4279++
}
}
- r.EncodeMapStart(yynn4274)
- yynn4274 = 0
+ r.EncodeMapStart(yynn4279)
+ yynn4279 = 0
}
- if yyr4274 || yy2arr4274 {
+ if yyr4279 || yy2arr4279 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq4274[0] {
- yym4276 := z.EncBinary()
- _ = yym4276
+ if yyq4279[0] {
+ yym4281 := z.EncBinary()
+ _ = yym4281
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
@@ -53567,23 +53631,23 @@ func (x *ConfigMapList) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq4274[0] {
+ if yyq4279[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("kind"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym4277 := z.EncBinary()
- _ = yym4277
+ yym4282 := z.EncBinary()
+ _ = yym4282
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
}
}
}
- if yyr4274 || yy2arr4274 {
+ if yyr4279 || yy2arr4279 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq4274[1] {
- yym4279 := z.EncBinary()
- _ = yym4279
+ if yyq4279[1] {
+ yym4284 := z.EncBinary()
+ _ = yym4284
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
@@ -53592,54 +53656,54 @@ func (x *ConfigMapList) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq4274[1] {
+ if yyq4279[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym4280 := z.EncBinary()
- _ = yym4280
+ yym4285 := z.EncBinary()
+ _ = yym4285
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
}
}
}
- if yyr4274 || yy2arr4274 {
+ if yyr4279 || yy2arr4279 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq4274[2] {
- yy4282 := &x.ListMeta
- yym4283 := z.EncBinary()
- _ = yym4283
+ if yyq4279[2] {
+ yy4287 := &x.ListMeta
+ yym4288 := z.EncBinary()
+ _ = yym4288
if false {
- } else if z.HasExtensions() && z.EncExt(yy4282) {
+ } else if z.HasExtensions() && z.EncExt(yy4287) {
} else {
- z.EncFallback(yy4282)
+ z.EncFallback(yy4287)
}
} else {
r.EncodeNil()
}
} else {
- if yyq4274[2] {
+ if yyq4279[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("metadata"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy4284 := &x.ListMeta
- yym4285 := z.EncBinary()
- _ = yym4285
+ yy4289 := &x.ListMeta
+ yym4290 := z.EncBinary()
+ _ = yym4290
if false {
- } else if z.HasExtensions() && z.EncExt(yy4284) {
+ } else if z.HasExtensions() && z.EncExt(yy4289) {
} else {
- z.EncFallback(yy4284)
+ z.EncFallback(yy4289)
}
}
}
- if yyr4274 || yy2arr4274 {
+ if yyr4279 || yy2arr4279 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if x.Items == nil {
r.EncodeNil()
} else {
- yym4287 := z.EncBinary()
- _ = yym4287
+ yym4292 := z.EncBinary()
+ _ = yym4292
if false {
} else {
h.encSliceConfigMap(([]ConfigMap)(x.Items), e)
@@ -53652,15 +53716,15 @@ func (x *ConfigMapList) CodecEncodeSelf(e *codec1978.Encoder) {
if x.Items == nil {
r.EncodeNil()
} else {
- yym4288 := z.EncBinary()
- _ = yym4288
+ yym4293 := z.EncBinary()
+ _ = yym4293
if false {
} else {
h.encSliceConfigMap(([]ConfigMap)(x.Items), e)
}
}
}
- if yyr4274 || yy2arr4274 {
+ if yyr4279 || yy2arr4279 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -53673,25 +53737,25 @@ func (x *ConfigMapList) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym4289 := z.DecBinary()
- _ = yym4289
+ yym4294 := z.DecBinary()
+ _ = yym4294
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct4290 := r.ContainerType()
- if yyct4290 == codecSelferValueTypeMap1234 {
- yyl4290 := r.ReadMapStart()
- if yyl4290 == 0 {
+ yyct4295 := r.ContainerType()
+ if yyct4295 == codecSelferValueTypeMap1234 {
+ yyl4295 := r.ReadMapStart()
+ if yyl4295 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl4290, d)
+ x.codecDecodeSelfFromMap(yyl4295, d)
}
- } else if yyct4290 == codecSelferValueTypeArray1234 {
- yyl4290 := r.ReadArrayStart()
- if yyl4290 == 0 {
+ } else if yyct4295 == codecSelferValueTypeArray1234 {
+ yyl4295 := r.ReadArrayStart()
+ if yyl4295 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl4290, d)
+ x.codecDecodeSelfFromArray(yyl4295, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -53703,12 +53767,12 @@ func (x *ConfigMapList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys4291Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys4291Slc
- var yyhl4291 bool = l >= 0
- for yyj4291 := 0; ; yyj4291++ {
- if yyhl4291 {
- if yyj4291 >= l {
+ var yys4296Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys4296Slc
+ var yyhl4296 bool = l >= 0
+ for yyj4296 := 0; ; yyj4296++ {
+ if yyhl4296 {
+ if yyj4296 >= l {
break
}
} else {
@@ -53717,10 +53781,10 @@ func (x *ConfigMapList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys4291Slc = r.DecodeBytes(yys4291Slc, true, true)
- yys4291 := string(yys4291Slc)
+ yys4296Slc = r.DecodeBytes(yys4296Slc, true, true)
+ yys4296 := string(yys4296Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys4291 {
+ switch yys4296 {
case "kind":
if r.TryDecodeAsNil() {
x.Kind = ""
@@ -53737,31 +53801,31 @@ func (x *ConfigMapList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.ListMeta = pkg2_v1.ListMeta{}
} else {
- yyv4294 := &x.ListMeta
- yym4295 := z.DecBinary()
- _ = yym4295
+ yyv4299 := &x.ListMeta
+ yym4300 := z.DecBinary()
+ _ = yym4300
if false {
- } else if z.HasExtensions() && z.DecExt(yyv4294) {
+ } else if z.HasExtensions() && z.DecExt(yyv4299) {
} else {
- z.DecFallback(yyv4294, false)
+ z.DecFallback(yyv4299, false)
}
}
case "items":
if r.TryDecodeAsNil() {
x.Items = nil
} else {
- yyv4296 := &x.Items
- yym4297 := z.DecBinary()
- _ = yym4297
+ yyv4301 := &x.Items
+ yym4302 := z.DecBinary()
+ _ = yym4302
if false {
} else {
- h.decSliceConfigMap((*[]ConfigMap)(yyv4296), d)
+ h.decSliceConfigMap((*[]ConfigMap)(yyv4301), d)
}
}
default:
- z.DecStructFieldNotFound(-1, yys4291)
- } // end switch yys4291
- } // end for yyj4291
+ z.DecStructFieldNotFound(-1, yys4296)
+ } // end switch yys4296
+ } // end for yyj4296
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -53769,16 +53833,16 @@ func (x *ConfigMapList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj4298 int
- var yyb4298 bool
- var yyhl4298 bool = l >= 0
- yyj4298++
- if yyhl4298 {
- yyb4298 = yyj4298 > l
+ var yyj4303 int
+ var yyb4303 bool
+ var yyhl4303 bool = l >= 0
+ yyj4303++
+ if yyhl4303 {
+ yyb4303 = yyj4303 > l
} else {
- yyb4298 = r.CheckBreak()
+ yyb4303 = r.CheckBreak()
}
- if yyb4298 {
+ if yyb4303 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -53788,13 +53852,13 @@ func (x *ConfigMapList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Kind = string(r.DecodeString())
}
- yyj4298++
- if yyhl4298 {
- yyb4298 = yyj4298 > l
+ yyj4303++
+ if yyhl4303 {
+ yyb4303 = yyj4303 > l
} else {
- yyb4298 = r.CheckBreak()
+ yyb4303 = r.CheckBreak()
}
- if yyb4298 {
+ if yyb4303 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -53804,13 +53868,13 @@ func (x *ConfigMapList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.APIVersion = string(r.DecodeString())
}
- yyj4298++
- if yyhl4298 {
- yyb4298 = yyj4298 > l
+ yyj4303++
+ if yyhl4303 {
+ yyb4303 = yyj4303 > l
} else {
- yyb4298 = r.CheckBreak()
+ yyb4303 = r.CheckBreak()
}
- if yyb4298 {
+ if yyb4303 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -53818,22 +53882,22 @@ func (x *ConfigMapList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.ListMeta = pkg2_v1.ListMeta{}
} else {
- yyv4301 := &x.ListMeta
- yym4302 := z.DecBinary()
- _ = yym4302
+ yyv4306 := &x.ListMeta
+ yym4307 := z.DecBinary()
+ _ = yym4307
if false {
- } else if z.HasExtensions() && z.DecExt(yyv4301) {
+ } else if z.HasExtensions() && z.DecExt(yyv4306) {
} else {
- z.DecFallback(yyv4301, false)
+ z.DecFallback(yyv4306, false)
}
}
- yyj4298++
- if yyhl4298 {
- yyb4298 = yyj4298 > l
+ yyj4303++
+ if yyhl4303 {
+ yyb4303 = yyj4303 > l
} else {
- yyb4298 = r.CheckBreak()
+ yyb4303 = r.CheckBreak()
}
- if yyb4298 {
+ if yyb4303 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -53841,26 +53905,26 @@ func (x *ConfigMapList) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Items = nil
} else {
- yyv4303 := &x.Items
- yym4304 := z.DecBinary()
- _ = yym4304
+ yyv4308 := &x.Items
+ yym4309 := z.DecBinary()
+ _ = yym4309
if false {
} else {
- h.decSliceConfigMap((*[]ConfigMap)(yyv4303), d)
+ h.decSliceConfigMap((*[]ConfigMap)(yyv4308), d)
}
}
for {
- yyj4298++
- if yyhl4298 {
- yyb4298 = yyj4298 > l
+ yyj4303++
+ if yyhl4303 {
+ yyb4303 = yyj4303 > l
} else {
- yyb4298 = r.CheckBreak()
+ yyb4303 = r.CheckBreak()
}
- if yyb4298 {
+ if yyb4303 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj4298-1, "")
+ z.DecStructFieldNotFound(yyj4303-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -53869,8 +53933,8 @@ func (x ComponentConditionType) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
- yym4305 := z.EncBinary()
- _ = yym4305
+ yym4310 := z.EncBinary()
+ _ = yym4310
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
@@ -53882,8 +53946,8 @@ func (x *ComponentConditionType) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym4306 := z.DecBinary()
- _ = yym4306
+ yym4311 := z.DecBinary()
+ _ = yym4311
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
@@ -53898,32 +53962,32 @@ func (x *ComponentCondition) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym4307 := z.EncBinary()
- _ = yym4307
+ yym4312 := z.EncBinary()
+ _ = yym4312
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep4308 := !z.EncBinary()
- yy2arr4308 := z.EncBasicHandle().StructToArray
- var yyq4308 [4]bool
- _, _, _ = yysep4308, yyq4308, yy2arr4308
- const yyr4308 bool = false
- yyq4308[2] = x.Message != ""
- yyq4308[3] = x.Error != ""
- var yynn4308 int
- if yyr4308 || yy2arr4308 {
+ yysep4313 := !z.EncBinary()
+ yy2arr4313 := z.EncBasicHandle().StructToArray
+ var yyq4313 [4]bool
+ _, _, _ = yysep4313, yyq4313, yy2arr4313
+ const yyr4313 bool = false
+ yyq4313[2] = x.Message != ""
+ yyq4313[3] = x.Error != ""
+ var yynn4313 int
+ if yyr4313 || yy2arr4313 {
r.EncodeArrayStart(4)
} else {
- yynn4308 = 2
- for _, b := range yyq4308 {
+ yynn4313 = 2
+ for _, b := range yyq4313 {
if b {
- yynn4308++
+ yynn4313++
}
}
- r.EncodeMapStart(yynn4308)
- yynn4308 = 0
+ r.EncodeMapStart(yynn4313)
+ yynn4313 = 0
}
- if yyr4308 || yy2arr4308 {
+ if yyr4313 || yy2arr4313 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
x.Type.CodecEncodeSelf(e)
} else {
@@ -53932,7 +53996,7 @@ func (x *ComponentCondition) CodecEncodeSelf(e *codec1978.Encoder) {
z.EncSendContainerState(codecSelfer_containerMapValue1234)
x.Type.CodecEncodeSelf(e)
}
- if yyr4308 || yy2arr4308 {
+ if yyr4313 || yy2arr4313 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
x.Status.CodecEncodeSelf(e)
} else {
@@ -53941,11 +54005,11 @@ func (x *ComponentCondition) CodecEncodeSelf(e *codec1978.Encoder) {
z.EncSendContainerState(codecSelfer_containerMapValue1234)
x.Status.CodecEncodeSelf(e)
}
- if yyr4308 || yy2arr4308 {
+ if yyr4313 || yy2arr4313 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq4308[2] {
- yym4312 := z.EncBinary()
- _ = yym4312
+ if yyq4313[2] {
+ yym4317 := z.EncBinary()
+ _ = yym4317
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Message))
@@ -53954,23 +54018,23 @@ func (x *ComponentCondition) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq4308[2] {
+ if yyq4313[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("message"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym4313 := z.EncBinary()
- _ = yym4313
+ yym4318 := z.EncBinary()
+ _ = yym4318
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Message))
}
}
}
- if yyr4308 || yy2arr4308 {
+ if yyr4313 || yy2arr4313 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq4308[3] {
- yym4315 := z.EncBinary()
- _ = yym4315
+ if yyq4313[3] {
+ yym4320 := z.EncBinary()
+ _ = yym4320
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Error))
@@ -53979,19 +54043,19 @@ func (x *ComponentCondition) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq4308[3] {
+ if yyq4313[3] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("error"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym4316 := z.EncBinary()
- _ = yym4316
+ yym4321 := z.EncBinary()
+ _ = yym4321
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Error))
}
}
}
- if yyr4308 || yy2arr4308 {
+ if yyr4313 || yy2arr4313 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -54004,25 +54068,25 @@ func (x *ComponentCondition) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym4317 := z.DecBinary()
- _ = yym4317
+ yym4322 := z.DecBinary()
+ _ = yym4322
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct4318 := r.ContainerType()
- if yyct4318 == codecSelferValueTypeMap1234 {
- yyl4318 := r.ReadMapStart()
- if yyl4318 == 0 {
+ yyct4323 := r.ContainerType()
+ if yyct4323 == codecSelferValueTypeMap1234 {
+ yyl4323 := r.ReadMapStart()
+ if yyl4323 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl4318, d)
+ x.codecDecodeSelfFromMap(yyl4323, d)
}
- } else if yyct4318 == codecSelferValueTypeArray1234 {
- yyl4318 := r.ReadArrayStart()
- if yyl4318 == 0 {
+ } else if yyct4323 == codecSelferValueTypeArray1234 {
+ yyl4323 := r.ReadArrayStart()
+ if yyl4323 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl4318, d)
+ x.codecDecodeSelfFromArray(yyl4323, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -54034,12 +54098,12 @@ func (x *ComponentCondition) codecDecodeSelfFromMap(l int, d *codec1978.Decoder)
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys4319Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys4319Slc
- var yyhl4319 bool = l >= 0
- for yyj4319 := 0; ; yyj4319++ {
- if yyhl4319 {
- if yyj4319 >= l {
+ var yys4324Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys4324Slc
+ var yyhl4324 bool = l >= 0
+ for yyj4324 := 0; ; yyj4324++ {
+ if yyhl4324 {
+ if yyj4324 >= l {
break
}
} else {
@@ -54048,10 +54112,10 @@ func (x *ComponentCondition) codecDecodeSelfFromMap(l int, d *codec1978.Decoder)
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys4319Slc = r.DecodeBytes(yys4319Slc, true, true)
- yys4319 := string(yys4319Slc)
+ yys4324Slc = r.DecodeBytes(yys4324Slc, true, true)
+ yys4324 := string(yys4324Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys4319 {
+ switch yys4324 {
case "type":
if r.TryDecodeAsNil() {
x.Type = ""
@@ -54077,9 +54141,9 @@ func (x *ComponentCondition) codecDecodeSelfFromMap(l int, d *codec1978.Decoder)
x.Error = string(r.DecodeString())
}
default:
- z.DecStructFieldNotFound(-1, yys4319)
- } // end switch yys4319
- } // end for yyj4319
+ z.DecStructFieldNotFound(-1, yys4324)
+ } // end switch yys4324
+ } // end for yyj4324
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -54087,16 +54151,16 @@ func (x *ComponentCondition) codecDecodeSelfFromArray(l int, d *codec1978.Decode
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj4324 int
- var yyb4324 bool
- var yyhl4324 bool = l >= 0
- yyj4324++
- if yyhl4324 {
- yyb4324 = yyj4324 > l
+ var yyj4329 int
+ var yyb4329 bool
+ var yyhl4329 bool = l >= 0
+ yyj4329++
+ if yyhl4329 {
+ yyb4329 = yyj4329 > l
} else {
- yyb4324 = r.CheckBreak()
+ yyb4329 = r.CheckBreak()
}
- if yyb4324 {
+ if yyb4329 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -54106,13 +54170,13 @@ func (x *ComponentCondition) codecDecodeSelfFromArray(l int, d *codec1978.Decode
} else {
x.Type = ComponentConditionType(r.DecodeString())
}
- yyj4324++
- if yyhl4324 {
- yyb4324 = yyj4324 > l
+ yyj4329++
+ if yyhl4329 {
+ yyb4329 = yyj4329 > l
} else {
- yyb4324 = r.CheckBreak()
+ yyb4329 = r.CheckBreak()
}
- if yyb4324 {
+ if yyb4329 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -54122,13 +54186,13 @@ func (x *ComponentCondition) codecDecodeSelfFromArray(l int, d *codec1978.Decode
} else {
x.Status = ConditionStatus(r.DecodeString())
}
- yyj4324++
- if yyhl4324 {
- yyb4324 = yyj4324 > l
+ yyj4329++
+ if yyhl4329 {
+ yyb4329 = yyj4329 > l
} else {
- yyb4324 = r.CheckBreak()
+ yyb4329 = r.CheckBreak()
}
- if yyb4324 {
+ if yyb4329 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -54138,13 +54202,13 @@ func (x *ComponentCondition) codecDecodeSelfFromArray(l int, d *codec1978.Decode
} else {
x.Message = string(r.DecodeString())
}
- yyj4324++
- if yyhl4324 {
- yyb4324 = yyj4324 > l
+ yyj4329++
+ if yyhl4329 {
+ yyb4329 = yyj4329 > l
} else {
- yyb4324 = r.CheckBreak()
+ yyb4329 = r.CheckBreak()
}
- if yyb4324 {
+ if yyb4329 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -54155,17 +54219,17 @@ func (x *ComponentCondition) codecDecodeSelfFromArray(l int, d *codec1978.Decode
x.Error = string(r.DecodeString())
}
for {
- yyj4324++
- if yyhl4324 {
- yyb4324 = yyj4324 > l
+ yyj4329++
+ if yyhl4329 {
+ yyb4329 = yyj4329 > l
} else {
- yyb4324 = r.CheckBreak()
+ yyb4329 = r.CheckBreak()
}
- if yyb4324 {
+ if yyb4329 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj4324-1, "")
+ z.DecStructFieldNotFound(yyj4329-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -54177,38 +54241,38 @@ func (x *ComponentStatus) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym4329 := z.EncBinary()
- _ = yym4329
+ yym4334 := z.EncBinary()
+ _ = yym4334
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep4330 := !z.EncBinary()
- yy2arr4330 := z.EncBasicHandle().StructToArray
- var yyq4330 [4]bool
- _, _, _ = yysep4330, yyq4330, yy2arr4330
- const yyr4330 bool = false
- yyq4330[0] = x.Kind != ""
- yyq4330[1] = x.APIVersion != ""
- yyq4330[2] = true
- yyq4330[3] = len(x.Conditions) != 0
- var yynn4330 int
- if yyr4330 || yy2arr4330 {
+ yysep4335 := !z.EncBinary()
+ yy2arr4335 := z.EncBasicHandle().StructToArray
+ var yyq4335 [4]bool
+ _, _, _ = yysep4335, yyq4335, yy2arr4335
+ const yyr4335 bool = false
+ yyq4335[0] = x.Kind != ""
+ yyq4335[1] = x.APIVersion != ""
+ yyq4335[2] = true
+ yyq4335[3] = len(x.Conditions) != 0
+ var yynn4335 int
+ if yyr4335 || yy2arr4335 {
r.EncodeArrayStart(4)
} else {
- yynn4330 = 0
- for _, b := range yyq4330 {
+ yynn4335 = 0
+ for _, b := range yyq4335 {
if b {
- yynn4330++
+ yynn4335++
}
}
- r.EncodeMapStart(yynn4330)
- yynn4330 = 0
+ r.EncodeMapStart(yynn4335)
+ yynn4335 = 0
}
- if yyr4330 || yy2arr4330 {
+ if yyr4335 || yy2arr4335 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq4330[0] {
- yym4332 := z.EncBinary()
- _ = yym4332
+ if yyq4335[0] {
+ yym4337 := z.EncBinary()
+ _ = yym4337
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
@@ -54217,23 +54281,23 @@ func (x *ComponentStatus) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq4330[0] {
+ if yyq4335[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("kind"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym4333 := z.EncBinary()
- _ = yym4333
+ yym4338 := z.EncBinary()
+ _ = yym4338
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
}
}
}
- if yyr4330 || yy2arr4330 {
+ if yyr4335 || yy2arr4335 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq4330[1] {
- yym4335 := z.EncBinary()
- _ = yym4335
+ if yyq4335[1] {
+ yym4340 := z.EncBinary()
+ _ = yym4340
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
@@ -54242,43 +54306,43 @@ func (x *ComponentStatus) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq4330[1] {
+ if yyq4335[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym4336 := z.EncBinary()
- _ = yym4336
+ yym4341 := z.EncBinary()
+ _ = yym4341
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
}
}
}
- if yyr4330 || yy2arr4330 {
+ if yyr4335 || yy2arr4335 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq4330[2] {
- yy4338 := &x.ObjectMeta
- yy4338.CodecEncodeSelf(e)
+ if yyq4335[2] {
+ yy4343 := &x.ObjectMeta
+ yy4343.CodecEncodeSelf(e)
} else {
r.EncodeNil()
}
} else {
- if yyq4330[2] {
+ if yyq4335[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("metadata"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy4339 := &x.ObjectMeta
- yy4339.CodecEncodeSelf(e)
+ yy4344 := &x.ObjectMeta
+ yy4344.CodecEncodeSelf(e)
}
}
- if yyr4330 || yy2arr4330 {
+ if yyr4335 || yy2arr4335 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq4330[3] {
+ if yyq4335[3] {
if x.Conditions == nil {
r.EncodeNil()
} else {
- yym4341 := z.EncBinary()
- _ = yym4341
+ yym4346 := z.EncBinary()
+ _ = yym4346
if false {
} else {
h.encSliceComponentCondition(([]ComponentCondition)(x.Conditions), e)
@@ -54288,15 +54352,15 @@ func (x *ComponentStatus) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeNil()
}
} else {
- if yyq4330[3] {
+ if yyq4335[3] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("conditions"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
if x.Conditions == nil {
r.EncodeNil()
} else {
- yym4342 := z.EncBinary()
- _ = yym4342
+ yym4347 := z.EncBinary()
+ _ = yym4347
if false {
} else {
h.encSliceComponentCondition(([]ComponentCondition)(x.Conditions), e)
@@ -54304,7 +54368,7 @@ func (x *ComponentStatus) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
- if yyr4330 || yy2arr4330 {
+ if yyr4335 || yy2arr4335 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -54317,25 +54381,25 @@ func (x *ComponentStatus) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym4343 := z.DecBinary()
- _ = yym4343
+ yym4348 := z.DecBinary()
+ _ = yym4348
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct4344 := r.ContainerType()
- if yyct4344 == codecSelferValueTypeMap1234 {
- yyl4344 := r.ReadMapStart()
- if yyl4344 == 0 {
+ yyct4349 := r.ContainerType()
+ if yyct4349 == codecSelferValueTypeMap1234 {
+ yyl4349 := r.ReadMapStart()
+ if yyl4349 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl4344, d)
+ x.codecDecodeSelfFromMap(yyl4349, d)
}
- } else if yyct4344 == codecSelferValueTypeArray1234 {
- yyl4344 := r.ReadArrayStart()
- if yyl4344 == 0 {
+ } else if yyct4349 == codecSelferValueTypeArray1234 {
+ yyl4349 := r.ReadArrayStart()
+ if yyl4349 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl4344, d)
+ x.codecDecodeSelfFromArray(yyl4349, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -54347,12 +54411,12 @@ func (x *ComponentStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys4345Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys4345Slc
- var yyhl4345 bool = l >= 0
- for yyj4345 := 0; ; yyj4345++ {
- if yyhl4345 {
- if yyj4345 >= l {
+ var yys4350Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys4350Slc
+ var yyhl4350 bool = l >= 0
+ for yyj4350 := 0; ; yyj4350++ {
+ if yyhl4350 {
+ if yyj4350 >= l {
break
}
} else {
@@ -54361,10 +54425,10 @@ func (x *ComponentStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys4345Slc = r.DecodeBytes(yys4345Slc, true, true)
- yys4345 := string(yys4345Slc)
+ yys4350Slc = r.DecodeBytes(yys4350Slc, true, true)
+ yys4350 := string(yys4350Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys4345 {
+ switch yys4350 {
case "kind":
if r.TryDecodeAsNil() {
x.Kind = ""
@@ -54381,25 +54445,25 @@ func (x *ComponentStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.ObjectMeta = ObjectMeta{}
} else {
- yyv4348 := &x.ObjectMeta
- yyv4348.CodecDecodeSelf(d)
+ yyv4353 := &x.ObjectMeta
+ yyv4353.CodecDecodeSelf(d)
}
case "conditions":
if r.TryDecodeAsNil() {
x.Conditions = nil
} else {
- yyv4349 := &x.Conditions
- yym4350 := z.DecBinary()
- _ = yym4350
+ yyv4354 := &x.Conditions
+ yym4355 := z.DecBinary()
+ _ = yym4355
if false {
} else {
- h.decSliceComponentCondition((*[]ComponentCondition)(yyv4349), d)
+ h.decSliceComponentCondition((*[]ComponentCondition)(yyv4354), d)
}
}
default:
- z.DecStructFieldNotFound(-1, yys4345)
- } // end switch yys4345
- } // end for yyj4345
+ z.DecStructFieldNotFound(-1, yys4350)
+ } // end switch yys4350
+ } // end for yyj4350
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -54407,16 +54471,16 @@ func (x *ComponentStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj4351 int
- var yyb4351 bool
- var yyhl4351 bool = l >= 0
- yyj4351++
- if yyhl4351 {
- yyb4351 = yyj4351 > l
+ var yyj4356 int
+ var yyb4356 bool
+ var yyhl4356 bool = l >= 0
+ yyj4356++
+ if yyhl4356 {
+ yyb4356 = yyj4356 > l
} else {
- yyb4351 = r.CheckBreak()
+ yyb4356 = r.CheckBreak()
}
- if yyb4351 {
+ if yyb4356 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -54426,13 +54490,13 @@ func (x *ComponentStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
} else {
x.Kind = string(r.DecodeString())
}
- yyj4351++
- if yyhl4351 {
- yyb4351 = yyj4351 > l
+ yyj4356++
+ if yyhl4356 {
+ yyb4356 = yyj4356 > l
} else {
- yyb4351 = r.CheckBreak()
+ yyb4356 = r.CheckBreak()
}
- if yyb4351 {
+ if yyb4356 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -54442,13 +54506,13 @@ func (x *ComponentStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
} else {
x.APIVersion = string(r.DecodeString())
}
- yyj4351++
- if yyhl4351 {
- yyb4351 = yyj4351 > l
+ yyj4356++
+ if yyhl4356 {
+ yyb4356 = yyj4356 > l
} else {
- yyb4351 = r.CheckBreak()
+ yyb4356 = r.CheckBreak()
}
- if yyb4351 {
+ if yyb4356 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -54456,16 +54520,16 @@ func (x *ComponentStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
if r.TryDecodeAsNil() {
x.ObjectMeta = ObjectMeta{}
} else {
- yyv4354 := &x.ObjectMeta
- yyv4354.CodecDecodeSelf(d)
+ yyv4359 := &x.ObjectMeta
+ yyv4359.CodecDecodeSelf(d)
}
- yyj4351++
- if yyhl4351 {
- yyb4351 = yyj4351 > l
+ yyj4356++
+ if yyhl4356 {
+ yyb4356 = yyj4356 > l
} else {
- yyb4351 = r.CheckBreak()
+ yyb4356 = r.CheckBreak()
}
- if yyb4351 {
+ if yyb4356 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -54473,26 +54537,26 @@ func (x *ComponentStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
if r.TryDecodeAsNil() {
x.Conditions = nil
} else {
- yyv4355 := &x.Conditions
- yym4356 := z.DecBinary()
- _ = yym4356
+ yyv4360 := &x.Conditions
+ yym4361 := z.DecBinary()
+ _ = yym4361
if false {
} else {
- h.decSliceComponentCondition((*[]ComponentCondition)(yyv4355), d)
+ h.decSliceComponentCondition((*[]ComponentCondition)(yyv4360), d)
}
}
for {
- yyj4351++
- if yyhl4351 {
- yyb4351 = yyj4351 > l
+ yyj4356++
+ if yyhl4356 {
+ yyb4356 = yyj4356 > l
} else {
- yyb4351 = r.CheckBreak()
+ yyb4356 = r.CheckBreak()
}
- if yyb4351 {
+ if yyb4356 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj4351-1, "")
+ z.DecStructFieldNotFound(yyj4356-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -54504,37 +54568,37 @@ func (x *ComponentStatusList) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym4357 := z.EncBinary()
- _ = yym4357
+ yym4362 := z.EncBinary()
+ _ = yym4362
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep4358 := !z.EncBinary()
- yy2arr4358 := z.EncBasicHandle().StructToArray
- var yyq4358 [4]bool
- _, _, _ = yysep4358, yyq4358, yy2arr4358
- const yyr4358 bool = false
- yyq4358[0] = x.Kind != ""
- yyq4358[1] = x.APIVersion != ""
- yyq4358[2] = true
- var yynn4358 int
- if yyr4358 || yy2arr4358 {
+ yysep4363 := !z.EncBinary()
+ yy2arr4363 := z.EncBasicHandle().StructToArray
+ var yyq4363 [4]bool
+ _, _, _ = yysep4363, yyq4363, yy2arr4363
+ const yyr4363 bool = false
+ yyq4363[0] = x.Kind != ""
+ yyq4363[1] = x.APIVersion != ""
+ yyq4363[2] = true
+ var yynn4363 int
+ if yyr4363 || yy2arr4363 {
r.EncodeArrayStart(4)
} else {
- yynn4358 = 1
- for _, b := range yyq4358 {
+ yynn4363 = 1
+ for _, b := range yyq4363 {
if b {
- yynn4358++
+ yynn4363++
}
}
- r.EncodeMapStart(yynn4358)
- yynn4358 = 0
+ r.EncodeMapStart(yynn4363)
+ yynn4363 = 0
}
- if yyr4358 || yy2arr4358 {
+ if yyr4363 || yy2arr4363 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq4358[0] {
- yym4360 := z.EncBinary()
- _ = yym4360
+ if yyq4363[0] {
+ yym4365 := z.EncBinary()
+ _ = yym4365
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
@@ -54543,23 +54607,23 @@ func (x *ComponentStatusList) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq4358[0] {
+ if yyq4363[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("kind"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym4361 := z.EncBinary()
- _ = yym4361
+ yym4366 := z.EncBinary()
+ _ = yym4366
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
}
}
}
- if yyr4358 || yy2arr4358 {
+ if yyr4363 || yy2arr4363 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq4358[1] {
- yym4363 := z.EncBinary()
- _ = yym4363
+ if yyq4363[1] {
+ yym4368 := z.EncBinary()
+ _ = yym4368
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
@@ -54568,54 +54632,54 @@ func (x *ComponentStatusList) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq4358[1] {
+ if yyq4363[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym4364 := z.EncBinary()
- _ = yym4364
+ yym4369 := z.EncBinary()
+ _ = yym4369
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
}
}
}
- if yyr4358 || yy2arr4358 {
+ if yyr4363 || yy2arr4363 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq4358[2] {
- yy4366 := &x.ListMeta
- yym4367 := z.EncBinary()
- _ = yym4367
+ if yyq4363[2] {
+ yy4371 := &x.ListMeta
+ yym4372 := z.EncBinary()
+ _ = yym4372
if false {
- } else if z.HasExtensions() && z.EncExt(yy4366) {
+ } else if z.HasExtensions() && z.EncExt(yy4371) {
} else {
- z.EncFallback(yy4366)
+ z.EncFallback(yy4371)
}
} else {
r.EncodeNil()
}
} else {
- if yyq4358[2] {
+ if yyq4363[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("metadata"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy4368 := &x.ListMeta
- yym4369 := z.EncBinary()
- _ = yym4369
+ yy4373 := &x.ListMeta
+ yym4374 := z.EncBinary()
+ _ = yym4374
if false {
- } else if z.HasExtensions() && z.EncExt(yy4368) {
+ } else if z.HasExtensions() && z.EncExt(yy4373) {
} else {
- z.EncFallback(yy4368)
+ z.EncFallback(yy4373)
}
}
}
- if yyr4358 || yy2arr4358 {
+ if yyr4363 || yy2arr4363 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if x.Items == nil {
r.EncodeNil()
} else {
- yym4371 := z.EncBinary()
- _ = yym4371
+ yym4376 := z.EncBinary()
+ _ = yym4376
if false {
} else {
h.encSliceComponentStatus(([]ComponentStatus)(x.Items), e)
@@ -54628,15 +54692,15 @@ func (x *ComponentStatusList) CodecEncodeSelf(e *codec1978.Encoder) {
if x.Items == nil {
r.EncodeNil()
} else {
- yym4372 := z.EncBinary()
- _ = yym4372
+ yym4377 := z.EncBinary()
+ _ = yym4377
if false {
} else {
h.encSliceComponentStatus(([]ComponentStatus)(x.Items), e)
}
}
}
- if yyr4358 || yy2arr4358 {
+ if yyr4363 || yy2arr4363 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -54649,25 +54713,25 @@ func (x *ComponentStatusList) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym4373 := z.DecBinary()
- _ = yym4373
+ yym4378 := z.DecBinary()
+ _ = yym4378
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct4374 := r.ContainerType()
- if yyct4374 == codecSelferValueTypeMap1234 {
- yyl4374 := r.ReadMapStart()
- if yyl4374 == 0 {
+ yyct4379 := r.ContainerType()
+ if yyct4379 == codecSelferValueTypeMap1234 {
+ yyl4379 := r.ReadMapStart()
+ if yyl4379 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl4374, d)
+ x.codecDecodeSelfFromMap(yyl4379, d)
}
- } else if yyct4374 == codecSelferValueTypeArray1234 {
- yyl4374 := r.ReadArrayStart()
- if yyl4374 == 0 {
+ } else if yyct4379 == codecSelferValueTypeArray1234 {
+ yyl4379 := r.ReadArrayStart()
+ if yyl4379 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl4374, d)
+ x.codecDecodeSelfFromArray(yyl4379, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -54679,12 +54743,12 @@ func (x *ComponentStatusList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys4375Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys4375Slc
- var yyhl4375 bool = l >= 0
- for yyj4375 := 0; ; yyj4375++ {
- if yyhl4375 {
- if yyj4375 >= l {
+ var yys4380Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys4380Slc
+ var yyhl4380 bool = l >= 0
+ for yyj4380 := 0; ; yyj4380++ {
+ if yyhl4380 {
+ if yyj4380 >= l {
break
}
} else {
@@ -54693,10 +54757,10 @@ func (x *ComponentStatusList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys4375Slc = r.DecodeBytes(yys4375Slc, true, true)
- yys4375 := string(yys4375Slc)
+ yys4380Slc = r.DecodeBytes(yys4380Slc, true, true)
+ yys4380 := string(yys4380Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys4375 {
+ switch yys4380 {
case "kind":
if r.TryDecodeAsNil() {
x.Kind = ""
@@ -54713,31 +54777,31 @@ func (x *ComponentStatusList) codecDecodeSelfFromMap(l int, d *codec1978.Decoder
if r.TryDecodeAsNil() {
x.ListMeta = pkg2_v1.ListMeta{}
} else {
- yyv4378 := &x.ListMeta
- yym4379 := z.DecBinary()
- _ = yym4379
+ yyv4383 := &x.ListMeta
+ yym4384 := z.DecBinary()
+ _ = yym4384
if false {
- } else if z.HasExtensions() && z.DecExt(yyv4378) {
+ } else if z.HasExtensions() && z.DecExt(yyv4383) {
} else {
- z.DecFallback(yyv4378, false)
+ z.DecFallback(yyv4383, false)
}
}
case "items":
if r.TryDecodeAsNil() {
x.Items = nil
} else {
- yyv4380 := &x.Items
- yym4381 := z.DecBinary()
- _ = yym4381
+ yyv4385 := &x.Items
+ yym4386 := z.DecBinary()
+ _ = yym4386
if false {
} else {
- h.decSliceComponentStatus((*[]ComponentStatus)(yyv4380), d)
+ h.decSliceComponentStatus((*[]ComponentStatus)(yyv4385), d)
}
}
default:
- z.DecStructFieldNotFound(-1, yys4375)
- } // end switch yys4375
- } // end for yyj4375
+ z.DecStructFieldNotFound(-1, yys4380)
+ } // end switch yys4380
+ } // end for yyj4380
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -54745,16 +54809,16 @@ func (x *ComponentStatusList) codecDecodeSelfFromArray(l int, d *codec1978.Decod
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj4382 int
- var yyb4382 bool
- var yyhl4382 bool = l >= 0
- yyj4382++
- if yyhl4382 {
- yyb4382 = yyj4382 > l
+ var yyj4387 int
+ var yyb4387 bool
+ var yyhl4387 bool = l >= 0
+ yyj4387++
+ if yyhl4387 {
+ yyb4387 = yyj4387 > l
} else {
- yyb4382 = r.CheckBreak()
+ yyb4387 = r.CheckBreak()
}
- if yyb4382 {
+ if yyb4387 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -54764,13 +54828,13 @@ func (x *ComponentStatusList) codecDecodeSelfFromArray(l int, d *codec1978.Decod
} else {
x.Kind = string(r.DecodeString())
}
- yyj4382++
- if yyhl4382 {
- yyb4382 = yyj4382 > l
+ yyj4387++
+ if yyhl4387 {
+ yyb4387 = yyj4387 > l
} else {
- yyb4382 = r.CheckBreak()
+ yyb4387 = r.CheckBreak()
}
- if yyb4382 {
+ if yyb4387 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -54780,13 +54844,13 @@ func (x *ComponentStatusList) codecDecodeSelfFromArray(l int, d *codec1978.Decod
} else {
x.APIVersion = string(r.DecodeString())
}
- yyj4382++
- if yyhl4382 {
- yyb4382 = yyj4382 > l
+ yyj4387++
+ if yyhl4387 {
+ yyb4387 = yyj4387 > l
} else {
- yyb4382 = r.CheckBreak()
+ yyb4387 = r.CheckBreak()
}
- if yyb4382 {
+ if yyb4387 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -54794,22 +54858,22 @@ func (x *ComponentStatusList) codecDecodeSelfFromArray(l int, d *codec1978.Decod
if r.TryDecodeAsNil() {
x.ListMeta = pkg2_v1.ListMeta{}
} else {
- yyv4385 := &x.ListMeta
- yym4386 := z.DecBinary()
- _ = yym4386
+ yyv4390 := &x.ListMeta
+ yym4391 := z.DecBinary()
+ _ = yym4391
if false {
- } else if z.HasExtensions() && z.DecExt(yyv4385) {
+ } else if z.HasExtensions() && z.DecExt(yyv4390) {
} else {
- z.DecFallback(yyv4385, false)
+ z.DecFallback(yyv4390, false)
}
}
- yyj4382++
- if yyhl4382 {
- yyb4382 = yyj4382 > l
+ yyj4387++
+ if yyhl4387 {
+ yyb4387 = yyj4387 > l
} else {
- yyb4382 = r.CheckBreak()
+ yyb4387 = r.CheckBreak()
}
- if yyb4382 {
+ if yyb4387 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -54817,26 +54881,26 @@ func (x *ComponentStatusList) codecDecodeSelfFromArray(l int, d *codec1978.Decod
if r.TryDecodeAsNil() {
x.Items = nil
} else {
- yyv4387 := &x.Items
- yym4388 := z.DecBinary()
- _ = yym4388
+ yyv4392 := &x.Items
+ yym4393 := z.DecBinary()
+ _ = yym4393
if false {
} else {
- h.decSliceComponentStatus((*[]ComponentStatus)(yyv4387), d)
+ h.decSliceComponentStatus((*[]ComponentStatus)(yyv4392), d)
}
}
for {
- yyj4382++
- if yyhl4382 {
- yyb4382 = yyj4382 > l
+ yyj4387++
+ if yyhl4387 {
+ yyb4387 = yyj4387 > l
} else {
- yyb4382 = r.CheckBreak()
+ yyb4387 = r.CheckBreak()
}
- if yyb4382 {
+ if yyb4387 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj4382-1, "")
+ z.DecStructFieldNotFound(yyj4387-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -54848,39 +54912,39 @@ func (x *DownwardAPIVolumeSource) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym4389 := z.EncBinary()
- _ = yym4389
+ yym4394 := z.EncBinary()
+ _ = yym4394
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep4390 := !z.EncBinary()
- yy2arr4390 := z.EncBasicHandle().StructToArray
- var yyq4390 [2]bool
- _, _, _ = yysep4390, yyq4390, yy2arr4390
- const yyr4390 bool = false
- yyq4390[0] = len(x.Items) != 0
- yyq4390[1] = x.DefaultMode != nil
- var yynn4390 int
- if yyr4390 || yy2arr4390 {
+ yysep4395 := !z.EncBinary()
+ yy2arr4395 := z.EncBasicHandle().StructToArray
+ var yyq4395 [2]bool
+ _, _, _ = yysep4395, yyq4395, yy2arr4395
+ const yyr4395 bool = false
+ yyq4395[0] = len(x.Items) != 0
+ yyq4395[1] = x.DefaultMode != nil
+ var yynn4395 int
+ if yyr4395 || yy2arr4395 {
r.EncodeArrayStart(2)
} else {
- yynn4390 = 0
- for _, b := range yyq4390 {
+ yynn4395 = 0
+ for _, b := range yyq4395 {
if b {
- yynn4390++
+ yynn4395++
}
}
- r.EncodeMapStart(yynn4390)
- yynn4390 = 0
+ r.EncodeMapStart(yynn4395)
+ yynn4395 = 0
}
- if yyr4390 || yy2arr4390 {
+ if yyr4395 || yy2arr4395 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq4390[0] {
+ if yyq4395[0] {
if x.Items == nil {
r.EncodeNil()
} else {
- yym4392 := z.EncBinary()
- _ = yym4392
+ yym4397 := z.EncBinary()
+ _ = yym4397
if false {
} else {
h.encSliceDownwardAPIVolumeFile(([]DownwardAPIVolumeFile)(x.Items), e)
@@ -54890,15 +54954,15 @@ func (x *DownwardAPIVolumeSource) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeNil()
}
} else {
- if yyq4390[0] {
+ if yyq4395[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("items"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
if x.Items == nil {
r.EncodeNil()
} else {
- yym4393 := z.EncBinary()
- _ = yym4393
+ yym4398 := z.EncBinary()
+ _ = yym4398
if false {
} else {
h.encSliceDownwardAPIVolumeFile(([]DownwardAPIVolumeFile)(x.Items), e)
@@ -54906,42 +54970,42 @@ func (x *DownwardAPIVolumeSource) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
- if yyr4390 || yy2arr4390 {
+ if yyr4395 || yy2arr4395 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq4390[1] {
+ if yyq4395[1] {
if x.DefaultMode == nil {
r.EncodeNil()
} else {
- yy4395 := *x.DefaultMode
- yym4396 := z.EncBinary()
- _ = yym4396
+ yy4400 := *x.DefaultMode
+ yym4401 := z.EncBinary()
+ _ = yym4401
if false {
} else {
- r.EncodeInt(int64(yy4395))
+ r.EncodeInt(int64(yy4400))
}
}
} else {
r.EncodeNil()
}
} else {
- if yyq4390[1] {
+ if yyq4395[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("defaultMode"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
if x.DefaultMode == nil {
r.EncodeNil()
} else {
- yy4397 := *x.DefaultMode
- yym4398 := z.EncBinary()
- _ = yym4398
+ yy4402 := *x.DefaultMode
+ yym4403 := z.EncBinary()
+ _ = yym4403
if false {
} else {
- r.EncodeInt(int64(yy4397))
+ r.EncodeInt(int64(yy4402))
}
}
}
}
- if yyr4390 || yy2arr4390 {
+ if yyr4395 || yy2arr4395 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -54954,25 +55018,25 @@ func (x *DownwardAPIVolumeSource) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym4399 := z.DecBinary()
- _ = yym4399
+ yym4404 := z.DecBinary()
+ _ = yym4404
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct4400 := r.ContainerType()
- if yyct4400 == codecSelferValueTypeMap1234 {
- yyl4400 := r.ReadMapStart()
- if yyl4400 == 0 {
+ yyct4405 := r.ContainerType()
+ if yyct4405 == codecSelferValueTypeMap1234 {
+ yyl4405 := r.ReadMapStart()
+ if yyl4405 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl4400, d)
+ x.codecDecodeSelfFromMap(yyl4405, d)
}
- } else if yyct4400 == codecSelferValueTypeArray1234 {
- yyl4400 := r.ReadArrayStart()
- if yyl4400 == 0 {
+ } else if yyct4405 == codecSelferValueTypeArray1234 {
+ yyl4405 := r.ReadArrayStart()
+ if yyl4405 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl4400, d)
+ x.codecDecodeSelfFromArray(yyl4405, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -54984,12 +55048,12 @@ func (x *DownwardAPIVolumeSource) codecDecodeSelfFromMap(l int, d *codec1978.Dec
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys4401Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys4401Slc
- var yyhl4401 bool = l >= 0
- for yyj4401 := 0; ; yyj4401++ {
- if yyhl4401 {
- if yyj4401 >= l {
+ var yys4406Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys4406Slc
+ var yyhl4406 bool = l >= 0
+ for yyj4406 := 0; ; yyj4406++ {
+ if yyhl4406 {
+ if yyj4406 >= l {
break
}
} else {
@@ -54998,20 +55062,20 @@ func (x *DownwardAPIVolumeSource) codecDecodeSelfFromMap(l int, d *codec1978.Dec
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys4401Slc = r.DecodeBytes(yys4401Slc, true, true)
- yys4401 := string(yys4401Slc)
+ yys4406Slc = r.DecodeBytes(yys4406Slc, true, true)
+ yys4406 := string(yys4406Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys4401 {
+ switch yys4406 {
case "items":
if r.TryDecodeAsNil() {
x.Items = nil
} else {
- yyv4402 := &x.Items
- yym4403 := z.DecBinary()
- _ = yym4403
+ yyv4407 := &x.Items
+ yym4408 := z.DecBinary()
+ _ = yym4408
if false {
} else {
- h.decSliceDownwardAPIVolumeFile((*[]DownwardAPIVolumeFile)(yyv4402), d)
+ h.decSliceDownwardAPIVolumeFile((*[]DownwardAPIVolumeFile)(yyv4407), d)
}
}
case "defaultMode":
@@ -55023,17 +55087,17 @@ func (x *DownwardAPIVolumeSource) codecDecodeSelfFromMap(l int, d *codec1978.Dec
if x.DefaultMode == nil {
x.DefaultMode = new(int32)
}
- yym4405 := z.DecBinary()
- _ = yym4405
+ yym4410 := z.DecBinary()
+ _ = yym4410
if false {
} else {
*((*int32)(x.DefaultMode)) = int32(r.DecodeInt(32))
}
}
default:
- z.DecStructFieldNotFound(-1, yys4401)
- } // end switch yys4401
- } // end for yyj4401
+ z.DecStructFieldNotFound(-1, yys4406)
+ } // end switch yys4406
+ } // end for yyj4406
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -55041,16 +55105,16 @@ func (x *DownwardAPIVolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.D
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj4406 int
- var yyb4406 bool
- var yyhl4406 bool = l >= 0
- yyj4406++
- if yyhl4406 {
- yyb4406 = yyj4406 > l
+ var yyj4411 int
+ var yyb4411 bool
+ var yyhl4411 bool = l >= 0
+ yyj4411++
+ if yyhl4411 {
+ yyb4411 = yyj4411 > l
} else {
- yyb4406 = r.CheckBreak()
+ yyb4411 = r.CheckBreak()
}
- if yyb4406 {
+ if yyb4411 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -55058,21 +55122,21 @@ func (x *DownwardAPIVolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.D
if r.TryDecodeAsNil() {
x.Items = nil
} else {
- yyv4407 := &x.Items
- yym4408 := z.DecBinary()
- _ = yym4408
+ yyv4412 := &x.Items
+ yym4413 := z.DecBinary()
+ _ = yym4413
if false {
} else {
- h.decSliceDownwardAPIVolumeFile((*[]DownwardAPIVolumeFile)(yyv4407), d)
+ h.decSliceDownwardAPIVolumeFile((*[]DownwardAPIVolumeFile)(yyv4412), d)
}
}
- yyj4406++
- if yyhl4406 {
- yyb4406 = yyj4406 > l
+ yyj4411++
+ if yyhl4411 {
+ yyb4411 = yyj4411 > l
} else {
- yyb4406 = r.CheckBreak()
+ yyb4411 = r.CheckBreak()
}
- if yyb4406 {
+ if yyb4411 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -55085,25 +55149,25 @@ func (x *DownwardAPIVolumeSource) codecDecodeSelfFromArray(l int, d *codec1978.D
if x.DefaultMode == nil {
x.DefaultMode = new(int32)
}
- yym4410 := z.DecBinary()
- _ = yym4410
+ yym4415 := z.DecBinary()
+ _ = yym4415
if false {
} else {
*((*int32)(x.DefaultMode)) = int32(r.DecodeInt(32))
}
}
for {
- yyj4406++
- if yyhl4406 {
- yyb4406 = yyj4406 > l
+ yyj4411++
+ if yyhl4411 {
+ yyb4411 = yyj4411 > l
} else {
- yyb4406 = r.CheckBreak()
+ yyb4411 = r.CheckBreak()
}
- if yyb4406 {
+ if yyb4411 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj4406-1, "")
+ z.DecStructFieldNotFound(yyj4411-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -55115,36 +55179,36 @@ func (x *DownwardAPIVolumeFile) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym4411 := z.EncBinary()
- _ = yym4411
+ yym4416 := z.EncBinary()
+ _ = yym4416
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep4412 := !z.EncBinary()
- yy2arr4412 := z.EncBasicHandle().StructToArray
- var yyq4412 [4]bool
- _, _, _ = yysep4412, yyq4412, yy2arr4412
- const yyr4412 bool = false
- yyq4412[1] = x.FieldRef != nil
- yyq4412[2] = x.ResourceFieldRef != nil
- yyq4412[3] = x.Mode != nil
- var yynn4412 int
- if yyr4412 || yy2arr4412 {
+ yysep4417 := !z.EncBinary()
+ yy2arr4417 := z.EncBasicHandle().StructToArray
+ var yyq4417 [4]bool
+ _, _, _ = yysep4417, yyq4417, yy2arr4417
+ const yyr4417 bool = false
+ yyq4417[1] = x.FieldRef != nil
+ yyq4417[2] = x.ResourceFieldRef != nil
+ yyq4417[3] = x.Mode != nil
+ var yynn4417 int
+ if yyr4417 || yy2arr4417 {
r.EncodeArrayStart(4)
} else {
- yynn4412 = 1
- for _, b := range yyq4412 {
+ yynn4417 = 1
+ for _, b := range yyq4417 {
if b {
- yynn4412++
+ yynn4417++
}
}
- r.EncodeMapStart(yynn4412)
- yynn4412 = 0
+ r.EncodeMapStart(yynn4417)
+ yynn4417 = 0
}
- if yyr4412 || yy2arr4412 {
+ if yyr4417 || yy2arr4417 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym4414 := z.EncBinary()
- _ = yym4414
+ yym4419 := z.EncBinary()
+ _ = yym4419
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Path))
@@ -55153,16 +55217,16 @@ func (x *DownwardAPIVolumeFile) CodecEncodeSelf(e *codec1978.Encoder) {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("path"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym4415 := z.EncBinary()
- _ = yym4415
+ yym4420 := z.EncBinary()
+ _ = yym4420
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Path))
}
}
- if yyr4412 || yy2arr4412 {
+ if yyr4417 || yy2arr4417 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq4412[1] {
+ if yyq4417[1] {
if x.FieldRef == nil {
r.EncodeNil()
} else {
@@ -55172,7 +55236,7 @@ func (x *DownwardAPIVolumeFile) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeNil()
}
} else {
- if yyq4412[1] {
+ if yyq4417[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("fieldRef"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
@@ -55183,9 +55247,9 @@ func (x *DownwardAPIVolumeFile) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
- if yyr4412 || yy2arr4412 {
+ if yyr4417 || yy2arr4417 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq4412[2] {
+ if yyq4417[2] {
if x.ResourceFieldRef == nil {
r.EncodeNil()
} else {
@@ -55195,7 +55259,7 @@ func (x *DownwardAPIVolumeFile) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeNil()
}
} else {
- if yyq4412[2] {
+ if yyq4417[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("resourceFieldRef"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
@@ -55206,42 +55270,42 @@ func (x *DownwardAPIVolumeFile) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
- if yyr4412 || yy2arr4412 {
+ if yyr4417 || yy2arr4417 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq4412[3] {
+ if yyq4417[3] {
if x.Mode == nil {
r.EncodeNil()
} else {
- yy4419 := *x.Mode
- yym4420 := z.EncBinary()
- _ = yym4420
+ yy4424 := *x.Mode
+ yym4425 := z.EncBinary()
+ _ = yym4425
if false {
} else {
- r.EncodeInt(int64(yy4419))
+ r.EncodeInt(int64(yy4424))
}
}
} else {
r.EncodeNil()
}
} else {
- if yyq4412[3] {
+ if yyq4417[3] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("mode"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
if x.Mode == nil {
r.EncodeNil()
} else {
- yy4421 := *x.Mode
- yym4422 := z.EncBinary()
- _ = yym4422
+ yy4426 := *x.Mode
+ yym4427 := z.EncBinary()
+ _ = yym4427
if false {
} else {
- r.EncodeInt(int64(yy4421))
+ r.EncodeInt(int64(yy4426))
}
}
}
}
- if yyr4412 || yy2arr4412 {
+ if yyr4417 || yy2arr4417 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -55254,25 +55318,25 @@ func (x *DownwardAPIVolumeFile) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym4423 := z.DecBinary()
- _ = yym4423
+ yym4428 := z.DecBinary()
+ _ = yym4428
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct4424 := r.ContainerType()
- if yyct4424 == codecSelferValueTypeMap1234 {
- yyl4424 := r.ReadMapStart()
- if yyl4424 == 0 {
+ yyct4429 := r.ContainerType()
+ if yyct4429 == codecSelferValueTypeMap1234 {
+ yyl4429 := r.ReadMapStart()
+ if yyl4429 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl4424, d)
+ x.codecDecodeSelfFromMap(yyl4429, d)
}
- } else if yyct4424 == codecSelferValueTypeArray1234 {
- yyl4424 := r.ReadArrayStart()
- if yyl4424 == 0 {
+ } else if yyct4429 == codecSelferValueTypeArray1234 {
+ yyl4429 := r.ReadArrayStart()
+ if yyl4429 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl4424, d)
+ x.codecDecodeSelfFromArray(yyl4429, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -55284,12 +55348,12 @@ func (x *DownwardAPIVolumeFile) codecDecodeSelfFromMap(l int, d *codec1978.Decod
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys4425Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys4425Slc
- var yyhl4425 bool = l >= 0
- for yyj4425 := 0; ; yyj4425++ {
- if yyhl4425 {
- if yyj4425 >= l {
+ var yys4430Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys4430Slc
+ var yyhl4430 bool = l >= 0
+ for yyj4430 := 0; ; yyj4430++ {
+ if yyhl4430 {
+ if yyj4430 >= l {
break
}
} else {
@@ -55298,10 +55362,10 @@ func (x *DownwardAPIVolumeFile) codecDecodeSelfFromMap(l int, d *codec1978.Decod
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys4425Slc = r.DecodeBytes(yys4425Slc, true, true)
- yys4425 := string(yys4425Slc)
+ yys4430Slc = r.DecodeBytes(yys4430Slc, true, true)
+ yys4430 := string(yys4430Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys4425 {
+ switch yys4430 {
case "path":
if r.TryDecodeAsNil() {
x.Path = ""
@@ -55339,17 +55403,17 @@ func (x *DownwardAPIVolumeFile) codecDecodeSelfFromMap(l int, d *codec1978.Decod
if x.Mode == nil {
x.Mode = new(int32)
}
- yym4430 := z.DecBinary()
- _ = yym4430
+ yym4435 := z.DecBinary()
+ _ = yym4435
if false {
} else {
*((*int32)(x.Mode)) = int32(r.DecodeInt(32))
}
}
default:
- z.DecStructFieldNotFound(-1, yys4425)
- } // end switch yys4425
- } // end for yyj4425
+ z.DecStructFieldNotFound(-1, yys4430)
+ } // end switch yys4430
+ } // end for yyj4430
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -55357,16 +55421,16 @@ func (x *DownwardAPIVolumeFile) codecDecodeSelfFromArray(l int, d *codec1978.Dec
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj4431 int
- var yyb4431 bool
- var yyhl4431 bool = l >= 0
- yyj4431++
- if yyhl4431 {
- yyb4431 = yyj4431 > l
+ var yyj4436 int
+ var yyb4436 bool
+ var yyhl4436 bool = l >= 0
+ yyj4436++
+ if yyhl4436 {
+ yyb4436 = yyj4436 > l
} else {
- yyb4431 = r.CheckBreak()
+ yyb4436 = r.CheckBreak()
}
- if yyb4431 {
+ if yyb4436 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -55376,13 +55440,13 @@ func (x *DownwardAPIVolumeFile) codecDecodeSelfFromArray(l int, d *codec1978.Dec
} else {
x.Path = string(r.DecodeString())
}
- yyj4431++
- if yyhl4431 {
- yyb4431 = yyj4431 > l
+ yyj4436++
+ if yyhl4436 {
+ yyb4436 = yyj4436 > l
} else {
- yyb4431 = r.CheckBreak()
+ yyb4436 = r.CheckBreak()
}
- if yyb4431 {
+ if yyb4436 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -55397,13 +55461,13 @@ func (x *DownwardAPIVolumeFile) codecDecodeSelfFromArray(l int, d *codec1978.Dec
}
x.FieldRef.CodecDecodeSelf(d)
}
- yyj4431++
- if yyhl4431 {
- yyb4431 = yyj4431 > l
+ yyj4436++
+ if yyhl4436 {
+ yyb4436 = yyj4436 > l
} else {
- yyb4431 = r.CheckBreak()
+ yyb4436 = r.CheckBreak()
}
- if yyb4431 {
+ if yyb4436 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -55418,13 +55482,13 @@ func (x *DownwardAPIVolumeFile) codecDecodeSelfFromArray(l int, d *codec1978.Dec
}
x.ResourceFieldRef.CodecDecodeSelf(d)
}
- yyj4431++
- if yyhl4431 {
- yyb4431 = yyj4431 > l
+ yyj4436++
+ if yyhl4436 {
+ yyb4436 = yyj4436 > l
} else {
- yyb4431 = r.CheckBreak()
+ yyb4436 = r.CheckBreak()
}
- if yyb4431 {
+ if yyb4436 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -55437,25 +55501,25 @@ func (x *DownwardAPIVolumeFile) codecDecodeSelfFromArray(l int, d *codec1978.Dec
if x.Mode == nil {
x.Mode = new(int32)
}
- yym4436 := z.DecBinary()
- _ = yym4436
+ yym4441 := z.DecBinary()
+ _ = yym4441
if false {
} else {
*((*int32)(x.Mode)) = int32(r.DecodeInt(32))
}
}
for {
- yyj4431++
- if yyhl4431 {
- yyb4431 = yyj4431 > l
+ yyj4436++
+ if yyhl4436 {
+ yyb4436 = yyj4436 > l
} else {
- yyb4431 = r.CheckBreak()
+ yyb4436 = r.CheckBreak()
}
- if yyb4431 {
+ if yyb4436 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj4431-1, "")
+ z.DecStructFieldNotFound(yyj4436-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -55467,38 +55531,38 @@ func (x *SecurityContext) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym4437 := z.EncBinary()
- _ = yym4437
+ yym4442 := z.EncBinary()
+ _ = yym4442
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep4438 := !z.EncBinary()
- yy2arr4438 := z.EncBasicHandle().StructToArray
- var yyq4438 [6]bool
- _, _, _ = yysep4438, yyq4438, yy2arr4438
- const yyr4438 bool = false
- yyq4438[0] = x.Capabilities != nil
- yyq4438[1] = x.Privileged != nil
- yyq4438[2] = x.SELinuxOptions != nil
- yyq4438[3] = x.RunAsUser != nil
- yyq4438[4] = x.RunAsNonRoot != nil
- yyq4438[5] = x.ReadOnlyRootFilesystem != nil
- var yynn4438 int
- if yyr4438 || yy2arr4438 {
+ yysep4443 := !z.EncBinary()
+ yy2arr4443 := z.EncBasicHandle().StructToArray
+ var yyq4443 [6]bool
+ _, _, _ = yysep4443, yyq4443, yy2arr4443
+ const yyr4443 bool = false
+ yyq4443[0] = x.Capabilities != nil
+ yyq4443[1] = x.Privileged != nil
+ yyq4443[2] = x.SELinuxOptions != nil
+ yyq4443[3] = x.RunAsUser != nil
+ yyq4443[4] = x.RunAsNonRoot != nil
+ yyq4443[5] = x.ReadOnlyRootFilesystem != nil
+ var yynn4443 int
+ if yyr4443 || yy2arr4443 {
r.EncodeArrayStart(6)
} else {
- yynn4438 = 0
- for _, b := range yyq4438 {
+ yynn4443 = 0
+ for _, b := range yyq4443 {
if b {
- yynn4438++
+ yynn4443++
}
}
- r.EncodeMapStart(yynn4438)
- yynn4438 = 0
+ r.EncodeMapStart(yynn4443)
+ yynn4443 = 0
}
- if yyr4438 || yy2arr4438 {
+ if yyr4443 || yy2arr4443 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq4438[0] {
+ if yyq4443[0] {
if x.Capabilities == nil {
r.EncodeNil()
} else {
@@ -55508,7 +55572,7 @@ func (x *SecurityContext) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeNil()
}
} else {
- if yyq4438[0] {
+ if yyq4443[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("capabilities"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
@@ -55519,44 +55583,44 @@ func (x *SecurityContext) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
- if yyr4438 || yy2arr4438 {
+ if yyr4443 || yy2arr4443 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq4438[1] {
+ if yyq4443[1] {
if x.Privileged == nil {
r.EncodeNil()
} else {
- yy4441 := *x.Privileged
- yym4442 := z.EncBinary()
- _ = yym4442
+ yy4446 := *x.Privileged
+ yym4447 := z.EncBinary()
+ _ = yym4447
if false {
} else {
- r.EncodeBool(bool(yy4441))
+ r.EncodeBool(bool(yy4446))
}
}
} else {
r.EncodeNil()
}
} else {
- if yyq4438[1] {
+ if yyq4443[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("privileged"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
if x.Privileged == nil {
r.EncodeNil()
} else {
- yy4443 := *x.Privileged
- yym4444 := z.EncBinary()
- _ = yym4444
+ yy4448 := *x.Privileged
+ yym4449 := z.EncBinary()
+ _ = yym4449
if false {
} else {
- r.EncodeBool(bool(yy4443))
+ r.EncodeBool(bool(yy4448))
}
}
}
}
- if yyr4438 || yy2arr4438 {
+ if yyr4443 || yy2arr4443 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq4438[2] {
+ if yyq4443[2] {
if x.SELinuxOptions == nil {
r.EncodeNil()
} else {
@@ -55566,7 +55630,7 @@ func (x *SecurityContext) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeNil()
}
} else {
- if yyq4438[2] {
+ if yyq4443[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("seLinuxOptions"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
@@ -55577,83 +55641,48 @@ func (x *SecurityContext) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
- if yyr4438 || yy2arr4438 {
+ if yyr4443 || yy2arr4443 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq4438[3] {
+ if yyq4443[3] {
if x.RunAsUser == nil {
r.EncodeNil()
} else {
- yy4447 := *x.RunAsUser
- yym4448 := z.EncBinary()
- _ = yym4448
+ yy4452 := *x.RunAsUser
+ yym4453 := z.EncBinary()
+ _ = yym4453
if false {
} else {
- r.EncodeInt(int64(yy4447))
+ r.EncodeInt(int64(yy4452))
}
}
} else {
r.EncodeNil()
}
} else {
- if yyq4438[3] {
+ if yyq4443[3] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("runAsUser"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
if x.RunAsUser == nil {
r.EncodeNil()
} else {
- yy4449 := *x.RunAsUser
- yym4450 := z.EncBinary()
- _ = yym4450
- if false {
- } else {
- r.EncodeInt(int64(yy4449))
- }
- }
- }
- }
- if yyr4438 || yy2arr4438 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq4438[4] {
- if x.RunAsNonRoot == nil {
- r.EncodeNil()
- } else {
- yy4452 := *x.RunAsNonRoot
- yym4453 := z.EncBinary()
- _ = yym4453
- if false {
- } else {
- r.EncodeBool(bool(yy4452))
- }
- }
- } else {
- r.EncodeNil()
- }
- } else {
- if yyq4438[4] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("runAsNonRoot"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- if x.RunAsNonRoot == nil {
- r.EncodeNil()
- } else {
- yy4454 := *x.RunAsNonRoot
+ yy4454 := *x.RunAsUser
yym4455 := z.EncBinary()
_ = yym4455
if false {
} else {
- r.EncodeBool(bool(yy4454))
+ r.EncodeInt(int64(yy4454))
}
}
}
}
- if yyr4438 || yy2arr4438 {
+ if yyr4443 || yy2arr4443 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq4438[5] {
- if x.ReadOnlyRootFilesystem == nil {
+ if yyq4443[4] {
+ if x.RunAsNonRoot == nil {
r.EncodeNil()
} else {
- yy4457 := *x.ReadOnlyRootFilesystem
+ yy4457 := *x.RunAsNonRoot
yym4458 := z.EncBinary()
_ = yym4458
if false {
@@ -55665,14 +55694,14 @@ func (x *SecurityContext) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeNil()
}
} else {
- if yyq4438[5] {
+ if yyq4443[4] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("readOnlyRootFilesystem"))
+ r.EncodeString(codecSelferC_UTF81234, string("runAsNonRoot"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- if x.ReadOnlyRootFilesystem == nil {
+ if x.RunAsNonRoot == nil {
r.EncodeNil()
} else {
- yy4459 := *x.ReadOnlyRootFilesystem
+ yy4459 := *x.RunAsNonRoot
yym4460 := z.EncBinary()
_ = yym4460
if false {
@@ -55682,7 +55711,42 @@ func (x *SecurityContext) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
}
- if yyr4438 || yy2arr4438 {
+ if yyr4443 || yy2arr4443 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq4443[5] {
+ if x.ReadOnlyRootFilesystem == nil {
+ r.EncodeNil()
+ } else {
+ yy4462 := *x.ReadOnlyRootFilesystem
+ yym4463 := z.EncBinary()
+ _ = yym4463
+ if false {
+ } else {
+ r.EncodeBool(bool(yy4462))
+ }
+ }
+ } else {
+ r.EncodeNil()
+ }
+ } else {
+ if yyq4443[5] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("readOnlyRootFilesystem"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ if x.ReadOnlyRootFilesystem == nil {
+ r.EncodeNil()
+ } else {
+ yy4464 := *x.ReadOnlyRootFilesystem
+ yym4465 := z.EncBinary()
+ _ = yym4465
+ if false {
+ } else {
+ r.EncodeBool(bool(yy4464))
+ }
+ }
+ }
+ }
+ if yyr4443 || yy2arr4443 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -55695,25 +55759,25 @@ func (x *SecurityContext) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym4461 := z.DecBinary()
- _ = yym4461
+ yym4466 := z.DecBinary()
+ _ = yym4466
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct4462 := r.ContainerType()
- if yyct4462 == codecSelferValueTypeMap1234 {
- yyl4462 := r.ReadMapStart()
- if yyl4462 == 0 {
+ yyct4467 := r.ContainerType()
+ if yyct4467 == codecSelferValueTypeMap1234 {
+ yyl4467 := r.ReadMapStart()
+ if yyl4467 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl4462, d)
+ x.codecDecodeSelfFromMap(yyl4467, d)
}
- } else if yyct4462 == codecSelferValueTypeArray1234 {
- yyl4462 := r.ReadArrayStart()
- if yyl4462 == 0 {
+ } else if yyct4467 == codecSelferValueTypeArray1234 {
+ yyl4467 := r.ReadArrayStart()
+ if yyl4467 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl4462, d)
+ x.codecDecodeSelfFromArray(yyl4467, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -55725,12 +55789,12 @@ func (x *SecurityContext) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys4463Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys4463Slc
- var yyhl4463 bool = l >= 0
- for yyj4463 := 0; ; yyj4463++ {
- if yyhl4463 {
- if yyj4463 >= l {
+ var yys4468Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys4468Slc
+ var yyhl4468 bool = l >= 0
+ for yyj4468 := 0; ; yyj4468++ {
+ if yyhl4468 {
+ if yyj4468 >= l {
break
}
} else {
@@ -55739,10 +55803,10 @@ func (x *SecurityContext) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys4463Slc = r.DecodeBytes(yys4463Slc, true, true)
- yys4463 := string(yys4463Slc)
+ yys4468Slc = r.DecodeBytes(yys4468Slc, true, true)
+ yys4468 := string(yys4468Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys4463 {
+ switch yys4468 {
case "capabilities":
if r.TryDecodeAsNil() {
if x.Capabilities != nil {
@@ -55763,8 +55827,8 @@ func (x *SecurityContext) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
if x.Privileged == nil {
x.Privileged = new(bool)
}
- yym4466 := z.DecBinary()
- _ = yym4466
+ yym4471 := z.DecBinary()
+ _ = yym4471
if false {
} else {
*((*bool)(x.Privileged)) = r.DecodeBool()
@@ -55790,8 +55854,8 @@ func (x *SecurityContext) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
if x.RunAsUser == nil {
x.RunAsUser = new(int64)
}
- yym4469 := z.DecBinary()
- _ = yym4469
+ yym4474 := z.DecBinary()
+ _ = yym4474
if false {
} else {
*((*int64)(x.RunAsUser)) = int64(r.DecodeInt(64))
@@ -55806,8 +55870,8 @@ func (x *SecurityContext) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
if x.RunAsNonRoot == nil {
x.RunAsNonRoot = new(bool)
}
- yym4471 := z.DecBinary()
- _ = yym4471
+ yym4476 := z.DecBinary()
+ _ = yym4476
if false {
} else {
*((*bool)(x.RunAsNonRoot)) = r.DecodeBool()
@@ -55822,17 +55886,17 @@ func (x *SecurityContext) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
if x.ReadOnlyRootFilesystem == nil {
x.ReadOnlyRootFilesystem = new(bool)
}
- yym4473 := z.DecBinary()
- _ = yym4473
+ yym4478 := z.DecBinary()
+ _ = yym4478
if false {
} else {
*((*bool)(x.ReadOnlyRootFilesystem)) = r.DecodeBool()
}
}
default:
- z.DecStructFieldNotFound(-1, yys4463)
- } // end switch yys4463
- } // end for yyj4463
+ z.DecStructFieldNotFound(-1, yys4468)
+ } // end switch yys4468
+ } // end for yyj4468
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -55840,16 +55904,16 @@ func (x *SecurityContext) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj4474 int
- var yyb4474 bool
- var yyhl4474 bool = l >= 0
- yyj4474++
- if yyhl4474 {
- yyb4474 = yyj4474 > l
+ var yyj4479 int
+ var yyb4479 bool
+ var yyhl4479 bool = l >= 0
+ yyj4479++
+ if yyhl4479 {
+ yyb4479 = yyj4479 > l
} else {
- yyb4474 = r.CheckBreak()
+ yyb4479 = r.CheckBreak()
}
- if yyb4474 {
+ if yyb4479 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -55864,13 +55928,13 @@ func (x *SecurityContext) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
}
x.Capabilities.CodecDecodeSelf(d)
}
- yyj4474++
- if yyhl4474 {
- yyb4474 = yyj4474 > l
+ yyj4479++
+ if yyhl4479 {
+ yyb4479 = yyj4479 > l
} else {
- yyb4474 = r.CheckBreak()
+ yyb4479 = r.CheckBreak()
}
- if yyb4474 {
+ if yyb4479 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -55883,20 +55947,20 @@ func (x *SecurityContext) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
if x.Privileged == nil {
x.Privileged = new(bool)
}
- yym4477 := z.DecBinary()
- _ = yym4477
+ yym4482 := z.DecBinary()
+ _ = yym4482
if false {
} else {
*((*bool)(x.Privileged)) = r.DecodeBool()
}
}
- yyj4474++
- if yyhl4474 {
- yyb4474 = yyj4474 > l
+ yyj4479++
+ if yyhl4479 {
+ yyb4479 = yyj4479 > l
} else {
- yyb4474 = r.CheckBreak()
+ yyb4479 = r.CheckBreak()
}
- if yyb4474 {
+ if yyb4479 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -55911,13 +55975,13 @@ func (x *SecurityContext) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
}
x.SELinuxOptions.CodecDecodeSelf(d)
}
- yyj4474++
- if yyhl4474 {
- yyb4474 = yyj4474 > l
+ yyj4479++
+ if yyhl4479 {
+ yyb4479 = yyj4479 > l
} else {
- yyb4474 = r.CheckBreak()
+ yyb4479 = r.CheckBreak()
}
- if yyb4474 {
+ if yyb4479 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -55930,20 +55994,20 @@ func (x *SecurityContext) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
if x.RunAsUser == nil {
x.RunAsUser = new(int64)
}
- yym4480 := z.DecBinary()
- _ = yym4480
+ yym4485 := z.DecBinary()
+ _ = yym4485
if false {
} else {
*((*int64)(x.RunAsUser)) = int64(r.DecodeInt(64))
}
}
- yyj4474++
- if yyhl4474 {
- yyb4474 = yyj4474 > l
+ yyj4479++
+ if yyhl4479 {
+ yyb4479 = yyj4479 > l
} else {
- yyb4474 = r.CheckBreak()
+ yyb4479 = r.CheckBreak()
}
- if yyb4474 {
+ if yyb4479 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -55956,20 +56020,20 @@ func (x *SecurityContext) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
if x.RunAsNonRoot == nil {
x.RunAsNonRoot = new(bool)
}
- yym4482 := z.DecBinary()
- _ = yym4482
+ yym4487 := z.DecBinary()
+ _ = yym4487
if false {
} else {
*((*bool)(x.RunAsNonRoot)) = r.DecodeBool()
}
}
- yyj4474++
- if yyhl4474 {
- yyb4474 = yyj4474 > l
+ yyj4479++
+ if yyhl4479 {
+ yyb4479 = yyj4479 > l
} else {
- yyb4474 = r.CheckBreak()
+ yyb4479 = r.CheckBreak()
}
- if yyb4474 {
+ if yyb4479 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -55982,25 +56046,25 @@ func (x *SecurityContext) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
if x.ReadOnlyRootFilesystem == nil {
x.ReadOnlyRootFilesystem = new(bool)
}
- yym4484 := z.DecBinary()
- _ = yym4484
+ yym4489 := z.DecBinary()
+ _ = yym4489
if false {
} else {
*((*bool)(x.ReadOnlyRootFilesystem)) = r.DecodeBool()
}
}
for {
- yyj4474++
- if yyhl4474 {
- yyb4474 = yyj4474 > l
+ yyj4479++
+ if yyhl4479 {
+ yyb4479 = yyj4479 > l
} else {
- yyb4474 = r.CheckBreak()
+ yyb4479 = r.CheckBreak()
}
- if yyb4474 {
+ if yyb4479 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj4474-1, "")
+ z.DecStructFieldNotFound(yyj4479-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -56012,38 +56076,38 @@ func (x *SELinuxOptions) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym4485 := z.EncBinary()
- _ = yym4485
+ yym4490 := z.EncBinary()
+ _ = yym4490
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep4486 := !z.EncBinary()
- yy2arr4486 := z.EncBasicHandle().StructToArray
- var yyq4486 [4]bool
- _, _, _ = yysep4486, yyq4486, yy2arr4486
- const yyr4486 bool = false
- yyq4486[0] = x.User != ""
- yyq4486[1] = x.Role != ""
- yyq4486[2] = x.Type != ""
- yyq4486[3] = x.Level != ""
- var yynn4486 int
- if yyr4486 || yy2arr4486 {
+ yysep4491 := !z.EncBinary()
+ yy2arr4491 := z.EncBasicHandle().StructToArray
+ var yyq4491 [4]bool
+ _, _, _ = yysep4491, yyq4491, yy2arr4491
+ const yyr4491 bool = false
+ yyq4491[0] = x.User != ""
+ yyq4491[1] = x.Role != ""
+ yyq4491[2] = x.Type != ""
+ yyq4491[3] = x.Level != ""
+ var yynn4491 int
+ if yyr4491 || yy2arr4491 {
r.EncodeArrayStart(4)
} else {
- yynn4486 = 0
- for _, b := range yyq4486 {
+ yynn4491 = 0
+ for _, b := range yyq4491 {
if b {
- yynn4486++
+ yynn4491++
}
}
- r.EncodeMapStart(yynn4486)
- yynn4486 = 0
+ r.EncodeMapStart(yynn4491)
+ yynn4491 = 0
}
- if yyr4486 || yy2arr4486 {
+ if yyr4491 || yy2arr4491 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq4486[0] {
- yym4488 := z.EncBinary()
- _ = yym4488
+ if yyq4491[0] {
+ yym4493 := z.EncBinary()
+ _ = yym4493
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.User))
@@ -56052,74 +56116,74 @@ func (x *SELinuxOptions) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq4486[0] {
+ if yyq4491[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("user"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym4489 := z.EncBinary()
- _ = yym4489
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.User))
- }
- }
- }
- if yyr4486 || yy2arr4486 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq4486[1] {
- yym4491 := z.EncBinary()
- _ = yym4491
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Role))
- }
- } else {
- r.EncodeString(codecSelferC_UTF81234, "")
- }
- } else {
- if yyq4486[1] {
- z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("role"))
- z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym4492 := z.EncBinary()
- _ = yym4492
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Role))
- }
- }
- }
- if yyr4486 || yy2arr4486 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq4486[2] {
yym4494 := z.EncBinary()
_ = yym4494
if false {
} else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Type))
+ r.EncodeString(codecSelferC_UTF81234, string(x.User))
+ }
+ }
+ }
+ if yyr4491 || yy2arr4491 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq4491[1] {
+ yym4496 := z.EncBinary()
+ _ = yym4496
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Role))
}
} else {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq4486[2] {
+ if yyq4491[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- r.EncodeString(codecSelferC_UTF81234, string("type"))
+ r.EncodeString(codecSelferC_UTF81234, string("role"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym4495 := z.EncBinary()
- _ = yym4495
- if false {
- } else {
- r.EncodeString(codecSelferC_UTF81234, string(x.Type))
- }
- }
- }
- if yyr4486 || yy2arr4486 {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq4486[3] {
yym4497 := z.EncBinary()
_ = yym4497
if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Role))
+ }
+ }
+ }
+ if yyr4491 || yy2arr4491 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq4491[2] {
+ yym4499 := z.EncBinary()
+ _ = yym4499
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Type))
+ }
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, "")
+ }
+ } else {
+ if yyq4491[2] {
+ z.EncSendContainerState(codecSelfer_containerMapKey1234)
+ r.EncodeString(codecSelferC_UTF81234, string("type"))
+ z.EncSendContainerState(codecSelfer_containerMapValue1234)
+ yym4500 := z.EncBinary()
+ _ = yym4500
+ if false {
+ } else {
+ r.EncodeString(codecSelferC_UTF81234, string(x.Type))
+ }
+ }
+ }
+ if yyr4491 || yy2arr4491 {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ if yyq4491[3] {
+ yym4502 := z.EncBinary()
+ _ = yym4502
+ if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Level))
}
@@ -56127,19 +56191,19 @@ func (x *SELinuxOptions) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq4486[3] {
+ if yyq4491[3] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("level"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym4498 := z.EncBinary()
- _ = yym4498
+ yym4503 := z.EncBinary()
+ _ = yym4503
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Level))
}
}
}
- if yyr4486 || yy2arr4486 {
+ if yyr4491 || yy2arr4491 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -56152,25 +56216,25 @@ func (x *SELinuxOptions) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym4499 := z.DecBinary()
- _ = yym4499
+ yym4504 := z.DecBinary()
+ _ = yym4504
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct4500 := r.ContainerType()
- if yyct4500 == codecSelferValueTypeMap1234 {
- yyl4500 := r.ReadMapStart()
- if yyl4500 == 0 {
+ yyct4505 := r.ContainerType()
+ if yyct4505 == codecSelferValueTypeMap1234 {
+ yyl4505 := r.ReadMapStart()
+ if yyl4505 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl4500, d)
+ x.codecDecodeSelfFromMap(yyl4505, d)
}
- } else if yyct4500 == codecSelferValueTypeArray1234 {
- yyl4500 := r.ReadArrayStart()
- if yyl4500 == 0 {
+ } else if yyct4505 == codecSelferValueTypeArray1234 {
+ yyl4505 := r.ReadArrayStart()
+ if yyl4505 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl4500, d)
+ x.codecDecodeSelfFromArray(yyl4505, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -56182,12 +56246,12 @@ func (x *SELinuxOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys4501Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys4501Slc
- var yyhl4501 bool = l >= 0
- for yyj4501 := 0; ; yyj4501++ {
- if yyhl4501 {
- if yyj4501 >= l {
+ var yys4506Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys4506Slc
+ var yyhl4506 bool = l >= 0
+ for yyj4506 := 0; ; yyj4506++ {
+ if yyhl4506 {
+ if yyj4506 >= l {
break
}
} else {
@@ -56196,10 +56260,10 @@ func (x *SELinuxOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys4501Slc = r.DecodeBytes(yys4501Slc, true, true)
- yys4501 := string(yys4501Slc)
+ yys4506Slc = r.DecodeBytes(yys4506Slc, true, true)
+ yys4506 := string(yys4506Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys4501 {
+ switch yys4506 {
case "user":
if r.TryDecodeAsNil() {
x.User = ""
@@ -56225,9 +56289,9 @@ func (x *SELinuxOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
x.Level = string(r.DecodeString())
}
default:
- z.DecStructFieldNotFound(-1, yys4501)
- } // end switch yys4501
- } // end for yyj4501
+ z.DecStructFieldNotFound(-1, yys4506)
+ } // end switch yys4506
+ } // end for yyj4506
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -56235,16 +56299,16 @@ func (x *SELinuxOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj4506 int
- var yyb4506 bool
- var yyhl4506 bool = l >= 0
- yyj4506++
- if yyhl4506 {
- yyb4506 = yyj4506 > l
+ var yyj4511 int
+ var yyb4511 bool
+ var yyhl4511 bool = l >= 0
+ yyj4511++
+ if yyhl4511 {
+ yyb4511 = yyj4511 > l
} else {
- yyb4506 = r.CheckBreak()
+ yyb4511 = r.CheckBreak()
}
- if yyb4506 {
+ if yyb4511 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -56254,13 +56318,13 @@ func (x *SELinuxOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.User = string(r.DecodeString())
}
- yyj4506++
- if yyhl4506 {
- yyb4506 = yyj4506 > l
+ yyj4511++
+ if yyhl4511 {
+ yyb4511 = yyj4511 > l
} else {
- yyb4506 = r.CheckBreak()
+ yyb4511 = r.CheckBreak()
}
- if yyb4506 {
+ if yyb4511 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -56270,13 +56334,13 @@ func (x *SELinuxOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Role = string(r.DecodeString())
}
- yyj4506++
- if yyhl4506 {
- yyb4506 = yyj4506 > l
+ yyj4511++
+ if yyhl4511 {
+ yyb4511 = yyj4511 > l
} else {
- yyb4506 = r.CheckBreak()
+ yyb4511 = r.CheckBreak()
}
- if yyb4506 {
+ if yyb4511 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -56286,13 +56350,13 @@ func (x *SELinuxOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
} else {
x.Type = string(r.DecodeString())
}
- yyj4506++
- if yyhl4506 {
- yyb4506 = yyj4506 > l
+ yyj4511++
+ if yyhl4511 {
+ yyb4511 = yyj4511 > l
} else {
- yyb4506 = r.CheckBreak()
+ yyb4511 = r.CheckBreak()
}
- if yyb4506 {
+ if yyb4511 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -56303,17 +56367,17 @@ func (x *SELinuxOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
x.Level = string(r.DecodeString())
}
for {
- yyj4506++
- if yyhl4506 {
- yyb4506 = yyj4506 > l
+ yyj4511++
+ if yyhl4511 {
+ yyb4511 = yyj4511 > l
} else {
- yyb4506 = r.CheckBreak()
+ yyb4511 = r.CheckBreak()
}
- if yyb4506 {
+ if yyb4511 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj4506-1, "")
+ z.DecStructFieldNotFound(yyj4511-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -56325,37 +56389,37 @@ func (x *RangeAllocation) CodecEncodeSelf(e *codec1978.Encoder) {
if x == nil {
r.EncodeNil()
} else {
- yym4511 := z.EncBinary()
- _ = yym4511
+ yym4516 := z.EncBinary()
+ _ = yym4516
if false {
} else if z.HasExtensions() && z.EncExt(x) {
} else {
- yysep4512 := !z.EncBinary()
- yy2arr4512 := z.EncBasicHandle().StructToArray
- var yyq4512 [5]bool
- _, _, _ = yysep4512, yyq4512, yy2arr4512
- const yyr4512 bool = false
- yyq4512[0] = x.Kind != ""
- yyq4512[1] = x.APIVersion != ""
- yyq4512[2] = true
- var yynn4512 int
- if yyr4512 || yy2arr4512 {
+ yysep4517 := !z.EncBinary()
+ yy2arr4517 := z.EncBasicHandle().StructToArray
+ var yyq4517 [5]bool
+ _, _, _ = yysep4517, yyq4517, yy2arr4517
+ const yyr4517 bool = false
+ yyq4517[0] = x.Kind != ""
+ yyq4517[1] = x.APIVersion != ""
+ yyq4517[2] = true
+ var yynn4517 int
+ if yyr4517 || yy2arr4517 {
r.EncodeArrayStart(5)
} else {
- yynn4512 = 2
- for _, b := range yyq4512 {
+ yynn4517 = 2
+ for _, b := range yyq4517 {
if b {
- yynn4512++
+ yynn4517++
}
}
- r.EncodeMapStart(yynn4512)
- yynn4512 = 0
+ r.EncodeMapStart(yynn4517)
+ yynn4517 = 0
}
- if yyr4512 || yy2arr4512 {
+ if yyr4517 || yy2arr4517 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq4512[0] {
- yym4514 := z.EncBinary()
- _ = yym4514
+ if yyq4517[0] {
+ yym4519 := z.EncBinary()
+ _ = yym4519
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
@@ -56364,23 +56428,23 @@ func (x *RangeAllocation) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq4512[0] {
+ if yyq4517[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("kind"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym4515 := z.EncBinary()
- _ = yym4515
+ yym4520 := z.EncBinary()
+ _ = yym4520
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
}
}
}
- if yyr4512 || yy2arr4512 {
+ if yyr4517 || yy2arr4517 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq4512[1] {
- yym4517 := z.EncBinary()
- _ = yym4517
+ if yyq4517[1] {
+ yym4522 := z.EncBinary()
+ _ = yym4522
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
@@ -56389,39 +56453,39 @@ func (x *RangeAllocation) CodecEncodeSelf(e *codec1978.Encoder) {
r.EncodeString(codecSelferC_UTF81234, "")
}
} else {
- if yyq4512[1] {
+ if yyq4517[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym4518 := z.EncBinary()
- _ = yym4518
+ yym4523 := z.EncBinary()
+ _ = yym4523
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
}
}
}
- if yyr4512 || yy2arr4512 {
+ if yyr4517 || yy2arr4517 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- if yyq4512[2] {
- yy4520 := &x.ObjectMeta
- yy4520.CodecEncodeSelf(e)
+ if yyq4517[2] {
+ yy4525 := &x.ObjectMeta
+ yy4525.CodecEncodeSelf(e)
} else {
r.EncodeNil()
}
} else {
- if yyq4512[2] {
+ if yyq4517[2] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("metadata"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy4521 := &x.ObjectMeta
- yy4521.CodecEncodeSelf(e)
+ yy4526 := &x.ObjectMeta
+ yy4526.CodecEncodeSelf(e)
}
}
- if yyr4512 || yy2arr4512 {
+ if yyr4517 || yy2arr4517 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yym4523 := z.EncBinary()
- _ = yym4523
+ yym4528 := z.EncBinary()
+ _ = yym4528
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Range))
@@ -56430,20 +56494,20 @@ func (x *RangeAllocation) CodecEncodeSelf(e *codec1978.Encoder) {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("range"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yym4524 := z.EncBinary()
- _ = yym4524
+ yym4529 := z.EncBinary()
+ _ = yym4529
if false {
} else {
r.EncodeString(codecSelferC_UTF81234, string(x.Range))
}
}
- if yyr4512 || yy2arr4512 {
+ if yyr4517 || yy2arr4517 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if x.Data == nil {
r.EncodeNil()
} else {
- yym4526 := z.EncBinary()
- _ = yym4526
+ yym4531 := z.EncBinary()
+ _ = yym4531
if false {
} else {
r.EncodeStringBytes(codecSelferC_RAW1234, []byte(x.Data))
@@ -56456,15 +56520,15 @@ func (x *RangeAllocation) CodecEncodeSelf(e *codec1978.Encoder) {
if x.Data == nil {
r.EncodeNil()
} else {
- yym4527 := z.EncBinary()
- _ = yym4527
+ yym4532 := z.EncBinary()
+ _ = yym4532
if false {
} else {
r.EncodeStringBytes(codecSelferC_RAW1234, []byte(x.Data))
}
}
}
- if yyr4512 || yy2arr4512 {
+ if yyr4517 || yy2arr4517 {
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -56477,25 +56541,25 @@ func (x *RangeAllocation) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yym4528 := z.DecBinary()
- _ = yym4528
+ yym4533 := z.DecBinary()
+ _ = yym4533
if false {
} else if z.HasExtensions() && z.DecExt(x) {
} else {
- yyct4529 := r.ContainerType()
- if yyct4529 == codecSelferValueTypeMap1234 {
- yyl4529 := r.ReadMapStart()
- if yyl4529 == 0 {
+ yyct4534 := r.ContainerType()
+ if yyct4534 == codecSelferValueTypeMap1234 {
+ yyl4534 := r.ReadMapStart()
+ if yyl4534 == 0 {
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
} else {
- x.codecDecodeSelfFromMap(yyl4529, d)
+ x.codecDecodeSelfFromMap(yyl4534, d)
}
- } else if yyct4529 == codecSelferValueTypeArray1234 {
- yyl4529 := r.ReadArrayStart()
- if yyl4529 == 0 {
+ } else if yyct4534 == codecSelferValueTypeArray1234 {
+ yyl4534 := r.ReadArrayStart()
+ if yyl4534 == 0 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
} else {
- x.codecDecodeSelfFromArray(yyl4529, d)
+ x.codecDecodeSelfFromArray(yyl4534, d)
}
} else {
panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
@@ -56507,12 +56571,12 @@ func (x *RangeAllocation) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yys4530Slc = z.DecScratchBuffer() // default slice to decode into
- _ = yys4530Slc
- var yyhl4530 bool = l >= 0
- for yyj4530 := 0; ; yyj4530++ {
- if yyhl4530 {
- if yyj4530 >= l {
+ var yys4535Slc = z.DecScratchBuffer() // default slice to decode into
+ _ = yys4535Slc
+ var yyhl4535 bool = l >= 0
+ for yyj4535 := 0; ; yyj4535++ {
+ if yyhl4535 {
+ if yyj4535 >= l {
break
}
} else {
@@ -56521,10 +56585,10 @@ func (x *RangeAllocation) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
}
}
z.DecSendContainerState(codecSelfer_containerMapKey1234)
- yys4530Slc = r.DecodeBytes(yys4530Slc, true, true)
- yys4530 := string(yys4530Slc)
+ yys4535Slc = r.DecodeBytes(yys4535Slc, true, true)
+ yys4535 := string(yys4535Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
- switch yys4530 {
+ switch yys4535 {
case "kind":
if r.TryDecodeAsNil() {
x.Kind = ""
@@ -56541,8 +56605,8 @@ func (x *RangeAllocation) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.ObjectMeta = ObjectMeta{}
} else {
- yyv4533 := &x.ObjectMeta
- yyv4533.CodecDecodeSelf(d)
+ yyv4538 := &x.ObjectMeta
+ yyv4538.CodecDecodeSelf(d)
}
case "range":
if r.TryDecodeAsNil() {
@@ -56554,18 +56618,18 @@ func (x *RangeAllocation) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
if r.TryDecodeAsNil() {
x.Data = nil
} else {
- yyv4535 := &x.Data
- yym4536 := z.DecBinary()
- _ = yym4536
+ yyv4540 := &x.Data
+ yym4541 := z.DecBinary()
+ _ = yym4541
if false {
} else {
- *yyv4535 = r.DecodeBytes(*(*[]byte)(yyv4535), false, false)
+ *yyv4540 = r.DecodeBytes(*(*[]byte)(yyv4540), false, false)
}
}
default:
- z.DecStructFieldNotFound(-1, yys4530)
- } // end switch yys4530
- } // end for yyj4530
+ z.DecStructFieldNotFound(-1, yys4535)
+ } // end switch yys4535
+ } // end for yyj4535
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
@@ -56573,16 +56637,16 @@ func (x *RangeAllocation) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- var yyj4537 int
- var yyb4537 bool
- var yyhl4537 bool = l >= 0
- yyj4537++
- if yyhl4537 {
- yyb4537 = yyj4537 > l
+ var yyj4542 int
+ var yyb4542 bool
+ var yyhl4542 bool = l >= 0
+ yyj4542++
+ if yyhl4542 {
+ yyb4542 = yyj4542 > l
} else {
- yyb4537 = r.CheckBreak()
+ yyb4542 = r.CheckBreak()
}
- if yyb4537 {
+ if yyb4542 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -56592,13 +56656,13 @@ func (x *RangeAllocation) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
} else {
x.Kind = string(r.DecodeString())
}
- yyj4537++
- if yyhl4537 {
- yyb4537 = yyj4537 > l
+ yyj4542++
+ if yyhl4542 {
+ yyb4542 = yyj4542 > l
} else {
- yyb4537 = r.CheckBreak()
+ yyb4542 = r.CheckBreak()
}
- if yyb4537 {
+ if yyb4542 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -56608,13 +56672,13 @@ func (x *RangeAllocation) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
} else {
x.APIVersion = string(r.DecodeString())
}
- yyj4537++
- if yyhl4537 {
- yyb4537 = yyj4537 > l
+ yyj4542++
+ if yyhl4542 {
+ yyb4542 = yyj4542 > l
} else {
- yyb4537 = r.CheckBreak()
+ yyb4542 = r.CheckBreak()
}
- if yyb4537 {
+ if yyb4542 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -56622,16 +56686,16 @@ func (x *RangeAllocation) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
if r.TryDecodeAsNil() {
x.ObjectMeta = ObjectMeta{}
} else {
- yyv4540 := &x.ObjectMeta
- yyv4540.CodecDecodeSelf(d)
+ yyv4545 := &x.ObjectMeta
+ yyv4545.CodecDecodeSelf(d)
}
- yyj4537++
- if yyhl4537 {
- yyb4537 = yyj4537 > l
+ yyj4542++
+ if yyhl4542 {
+ yyb4542 = yyj4542 > l
} else {
- yyb4537 = r.CheckBreak()
+ yyb4542 = r.CheckBreak()
}
- if yyb4537 {
+ if yyb4542 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -56641,13 +56705,13 @@ func (x *RangeAllocation) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
} else {
x.Range = string(r.DecodeString())
}
- yyj4537++
- if yyhl4537 {
- yyb4537 = yyj4537 > l
+ yyj4542++
+ if yyhl4542 {
+ yyb4542 = yyj4542 > l
} else {
- yyb4537 = r.CheckBreak()
+ yyb4542 = r.CheckBreak()
}
- if yyb4537 {
+ if yyb4542 {
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
return
}
@@ -56655,26 +56719,26 @@ func (x *RangeAllocation) codecDecodeSelfFromArray(l int, d *codec1978.Decoder)
if r.TryDecodeAsNil() {
x.Data = nil
} else {
- yyv4542 := &x.Data
- yym4543 := z.DecBinary()
- _ = yym4543
+ yyv4547 := &x.Data
+ yym4548 := z.DecBinary()
+ _ = yym4548
if false {
} else {
- *yyv4542 = r.DecodeBytes(*(*[]byte)(yyv4542), false, false)
+ *yyv4547 = r.DecodeBytes(*(*[]byte)(yyv4547), false, false)
}
}
for {
- yyj4537++
- if yyhl4537 {
- yyb4537 = yyj4537 > l
+ yyj4542++
+ if yyhl4542 {
+ yyb4542 = yyj4542 > l
} else {
- yyb4537 = r.CheckBreak()
+ yyb4542 = r.CheckBreak()
}
- if yyb4537 {
+ if yyb4542 {
break
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
- z.DecStructFieldNotFound(yyj4537-1, "")
+ z.DecStructFieldNotFound(yyj4542-1, "")
}
z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -56684,15 +56748,15 @@ func (x codecSelfer1234) encSlicev1_OwnerReference(v []pkg2_v1.OwnerReference, e
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
r.EncodeArrayStart(len(v))
- for _, yyv4544 := range v {
+ for _, yyv4549 := range v {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy4545 := &yyv4544
- yym4546 := z.EncBinary()
- _ = yym4546
+ yy4550 := &yyv4549
+ yym4551 := z.EncBinary()
+ _ = yym4551
if false {
- } else if z.HasExtensions() && z.EncExt(yy4545) {
+ } else if z.HasExtensions() && z.EncExt(yy4550) {
} else {
- z.EncFallback(yy4545)
+ z.EncFallback(yy4550)
}
}
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
@@ -56703,74 +56767,74 @@ func (x codecSelfer1234) decSlicev1_OwnerReference(v *[]pkg2_v1.OwnerReference,
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yyv4547 := *v
- yyh4547, yyl4547 := z.DecSliceHelperStart()
- var yyc4547 bool
- if yyl4547 == 0 {
- if yyv4547 == nil {
- yyv4547 = []pkg2_v1.OwnerReference{}
- yyc4547 = true
- } else if len(yyv4547) != 0 {
- yyv4547 = yyv4547[:0]
- yyc4547 = true
+ yyv4552 := *v
+ yyh4552, yyl4552 := z.DecSliceHelperStart()
+ var yyc4552 bool
+ if yyl4552 == 0 {
+ if yyv4552 == nil {
+ yyv4552 = []pkg2_v1.OwnerReference{}
+ yyc4552 = true
+ } else if len(yyv4552) != 0 {
+ yyv4552 = yyv4552[:0]
+ yyc4552 = true
}
- } else if yyl4547 > 0 {
- var yyrr4547, yyrl4547 int
- var yyrt4547 bool
- if yyl4547 > cap(yyv4547) {
+ } else if yyl4552 > 0 {
+ var yyrr4552, yyrl4552 int
+ var yyrt4552 bool
+ if yyl4552 > cap(yyv4552) {
- yyrg4547 := len(yyv4547) > 0
- yyv24547 := yyv4547
- yyrl4547, yyrt4547 = z.DecInferLen(yyl4547, z.DecBasicHandle().MaxInitLen, 72)
- if yyrt4547 {
- if yyrl4547 <= cap(yyv4547) {
- yyv4547 = yyv4547[:yyrl4547]
+ yyrg4552 := len(yyv4552) > 0
+ yyv24552 := yyv4552
+ yyrl4552, yyrt4552 = z.DecInferLen(yyl4552, z.DecBasicHandle().MaxInitLen, 72)
+ if yyrt4552 {
+ if yyrl4552 <= cap(yyv4552) {
+ yyv4552 = yyv4552[:yyrl4552]
} else {
- yyv4547 = make([]pkg2_v1.OwnerReference, yyrl4547)
+ yyv4552 = make([]pkg2_v1.OwnerReference, yyrl4552)
}
} else {
- yyv4547 = make([]pkg2_v1.OwnerReference, yyrl4547)
+ yyv4552 = make([]pkg2_v1.OwnerReference, yyrl4552)
}
- yyc4547 = true
- yyrr4547 = len(yyv4547)
- if yyrg4547 {
- copy(yyv4547, yyv24547)
+ yyc4552 = true
+ yyrr4552 = len(yyv4552)
+ if yyrg4552 {
+ copy(yyv4552, yyv24552)
}
- } else if yyl4547 != len(yyv4547) {
- yyv4547 = yyv4547[:yyl4547]
- yyc4547 = true
+ } else if yyl4552 != len(yyv4552) {
+ yyv4552 = yyv4552[:yyl4552]
+ yyc4552 = true
}
- yyj4547 := 0
- for ; yyj4547 < yyrr4547; yyj4547++ {
- yyh4547.ElemContainerState(yyj4547)
+ yyj4552 := 0
+ for ; yyj4552 < yyrr4552; yyj4552++ {
+ yyh4552.ElemContainerState(yyj4552)
if r.TryDecodeAsNil() {
- yyv4547[yyj4547] = pkg2_v1.OwnerReference{}
+ yyv4552[yyj4552] = pkg2_v1.OwnerReference{}
} else {
- yyv4548 := &yyv4547[yyj4547]
- yym4549 := z.DecBinary()
- _ = yym4549
+ yyv4553 := &yyv4552[yyj4552]
+ yym4554 := z.DecBinary()
+ _ = yym4554
if false {
- } else if z.HasExtensions() && z.DecExt(yyv4548) {
+ } else if z.HasExtensions() && z.DecExt(yyv4553) {
} else {
- z.DecFallback(yyv4548, false)
+ z.DecFallback(yyv4553, false)
}
}
}
- if yyrt4547 {
- for ; yyj4547 < yyl4547; yyj4547++ {
- yyv4547 = append(yyv4547, pkg2_v1.OwnerReference{})
- yyh4547.ElemContainerState(yyj4547)
+ if yyrt4552 {
+ for ; yyj4552 < yyl4552; yyj4552++ {
+ yyv4552 = append(yyv4552, pkg2_v1.OwnerReference{})
+ yyh4552.ElemContainerState(yyj4552)
if r.TryDecodeAsNil() {
- yyv4547[yyj4547] = pkg2_v1.OwnerReference{}
+ yyv4552[yyj4552] = pkg2_v1.OwnerReference{}
} else {
- yyv4550 := &yyv4547[yyj4547]
- yym4551 := z.DecBinary()
- _ = yym4551
+ yyv4555 := &yyv4552[yyj4552]
+ yym4556 := z.DecBinary()
+ _ = yym4556
if false {
- } else if z.HasExtensions() && z.DecExt(yyv4550) {
+ } else if z.HasExtensions() && z.DecExt(yyv4555) {
} else {
- z.DecFallback(yyv4550, false)
+ z.DecFallback(yyv4555, false)
}
}
@@ -56778,25 +56842,25 @@ func (x codecSelfer1234) decSlicev1_OwnerReference(v *[]pkg2_v1.OwnerReference,
}
} else {
- yyj4547 := 0
- for ; !r.CheckBreak(); yyj4547++ {
+ yyj4552 := 0
+ for ; !r.CheckBreak(); yyj4552++ {
- if yyj4547 >= len(yyv4547) {
- yyv4547 = append(yyv4547, pkg2_v1.OwnerReference{}) // var yyz4547 pkg2_v1.OwnerReference
- yyc4547 = true
+ if yyj4552 >= len(yyv4552) {
+ yyv4552 = append(yyv4552, pkg2_v1.OwnerReference{}) // var yyz4552 pkg2_v1.OwnerReference
+ yyc4552 = true
}
- yyh4547.ElemContainerState(yyj4547)
- if yyj4547 < len(yyv4547) {
+ yyh4552.ElemContainerState(yyj4552)
+ if yyj4552 < len(yyv4552) {
if r.TryDecodeAsNil() {
- yyv4547[yyj4547] = pkg2_v1.OwnerReference{}
+ yyv4552[yyj4552] = pkg2_v1.OwnerReference{}
} else {
- yyv4552 := &yyv4547[yyj4547]
- yym4553 := z.DecBinary()
- _ = yym4553
+ yyv4557 := &yyv4552[yyj4552]
+ yym4558 := z.DecBinary()
+ _ = yym4558
if false {
- } else if z.HasExtensions() && z.DecExt(yyv4552) {
+ } else if z.HasExtensions() && z.DecExt(yyv4557) {
} else {
- z.DecFallback(yyv4552, false)
+ z.DecFallback(yyv4557, false)
}
}
@@ -56805,17 +56869,17 @@ func (x codecSelfer1234) decSlicev1_OwnerReference(v *[]pkg2_v1.OwnerReference,
}
}
- if yyj4547 < len(yyv4547) {
- yyv4547 = yyv4547[:yyj4547]
- yyc4547 = true
- } else if yyj4547 == 0 && yyv4547 == nil {
- yyv4547 = []pkg2_v1.OwnerReference{}
- yyc4547 = true
+ if yyj4552 < len(yyv4552) {
+ yyv4552 = yyv4552[:yyj4552]
+ yyc4552 = true
+ } else if yyj4552 == 0 && yyv4552 == nil {
+ yyv4552 = []pkg2_v1.OwnerReference{}
+ yyc4552 = true
}
}
- yyh4547.End()
- if yyc4547 {
- *v = yyv4547
+ yyh4552.End()
+ if yyc4552 {
+ *v = yyv4552
}
}
@@ -56824,9 +56888,9 @@ func (x codecSelfer1234) encSlicePersistentVolumeAccessMode(v []PersistentVolume
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
r.EncodeArrayStart(len(v))
- for _, yyv4554 := range v {
+ for _, yyv4559 := range v {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yyv4554.CodecEncodeSelf(e)
+ yyv4559.CodecEncodeSelf(e)
}
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -56836,75 +56900,75 @@ func (x codecSelfer1234) decSlicePersistentVolumeAccessMode(v *[]PersistentVolum
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yyv4555 := *v
- yyh4555, yyl4555 := z.DecSliceHelperStart()
- var yyc4555 bool
- if yyl4555 == 0 {
- if yyv4555 == nil {
- yyv4555 = []PersistentVolumeAccessMode{}
- yyc4555 = true
- } else if len(yyv4555) != 0 {
- yyv4555 = yyv4555[:0]
- yyc4555 = true
+ yyv4560 := *v
+ yyh4560, yyl4560 := z.DecSliceHelperStart()
+ var yyc4560 bool
+ if yyl4560 == 0 {
+ if yyv4560 == nil {
+ yyv4560 = []PersistentVolumeAccessMode{}
+ yyc4560 = true
+ } else if len(yyv4560) != 0 {
+ yyv4560 = yyv4560[:0]
+ yyc4560 = true
}
- } else if yyl4555 > 0 {
- var yyrr4555, yyrl4555 int
- var yyrt4555 bool
- if yyl4555 > cap(yyv4555) {
+ } else if yyl4560 > 0 {
+ var yyrr4560, yyrl4560 int
+ var yyrt4560 bool
+ if yyl4560 > cap(yyv4560) {
- yyrl4555, yyrt4555 = z.DecInferLen(yyl4555, z.DecBasicHandle().MaxInitLen, 16)
- if yyrt4555 {
- if yyrl4555 <= cap(yyv4555) {
- yyv4555 = yyv4555[:yyrl4555]
+ yyrl4560, yyrt4560 = z.DecInferLen(yyl4560, z.DecBasicHandle().MaxInitLen, 16)
+ if yyrt4560 {
+ if yyrl4560 <= cap(yyv4560) {
+ yyv4560 = yyv4560[:yyrl4560]
} else {
- yyv4555 = make([]PersistentVolumeAccessMode, yyrl4555)
+ yyv4560 = make([]PersistentVolumeAccessMode, yyrl4560)
}
} else {
- yyv4555 = make([]PersistentVolumeAccessMode, yyrl4555)
+ yyv4560 = make([]PersistentVolumeAccessMode, yyrl4560)
}
- yyc4555 = true
- yyrr4555 = len(yyv4555)
- } else if yyl4555 != len(yyv4555) {
- yyv4555 = yyv4555[:yyl4555]
- yyc4555 = true
+ yyc4560 = true
+ yyrr4560 = len(yyv4560)
+ } else if yyl4560 != len(yyv4560) {
+ yyv4560 = yyv4560[:yyl4560]
+ yyc4560 = true
}
- yyj4555 := 0
- for ; yyj4555 < yyrr4555; yyj4555++ {
- yyh4555.ElemContainerState(yyj4555)
+ yyj4560 := 0
+ for ; yyj4560 < yyrr4560; yyj4560++ {
+ yyh4560.ElemContainerState(yyj4560)
if r.TryDecodeAsNil() {
- yyv4555[yyj4555] = ""
+ yyv4560[yyj4560] = ""
} else {
- yyv4555[yyj4555] = PersistentVolumeAccessMode(r.DecodeString())
+ yyv4560[yyj4560] = PersistentVolumeAccessMode(r.DecodeString())
}
}
- if yyrt4555 {
- for ; yyj4555 < yyl4555; yyj4555++ {
- yyv4555 = append(yyv4555, "")
- yyh4555.ElemContainerState(yyj4555)
+ if yyrt4560 {
+ for ; yyj4560 < yyl4560; yyj4560++ {
+ yyv4560 = append(yyv4560, "")
+ yyh4560.ElemContainerState(yyj4560)
if r.TryDecodeAsNil() {
- yyv4555[yyj4555] = ""
+ yyv4560[yyj4560] = ""
} else {
- yyv4555[yyj4555] = PersistentVolumeAccessMode(r.DecodeString())
+ yyv4560[yyj4560] = PersistentVolumeAccessMode(r.DecodeString())
}
}
}
} else {
- yyj4555 := 0
- for ; !r.CheckBreak(); yyj4555++ {
+ yyj4560 := 0
+ for ; !r.CheckBreak(); yyj4560++ {
- if yyj4555 >= len(yyv4555) {
- yyv4555 = append(yyv4555, "") // var yyz4555 PersistentVolumeAccessMode
- yyc4555 = true
+ if yyj4560 >= len(yyv4560) {
+ yyv4560 = append(yyv4560, "") // var yyz4560 PersistentVolumeAccessMode
+ yyc4560 = true
}
- yyh4555.ElemContainerState(yyj4555)
- if yyj4555 < len(yyv4555) {
+ yyh4560.ElemContainerState(yyj4560)
+ if yyj4560 < len(yyv4560) {
if r.TryDecodeAsNil() {
- yyv4555[yyj4555] = ""
+ yyv4560[yyj4560] = ""
} else {
- yyv4555[yyj4555] = PersistentVolumeAccessMode(r.DecodeString())
+ yyv4560[yyj4560] = PersistentVolumeAccessMode(r.DecodeString())
}
} else {
@@ -56912,17 +56976,17 @@ func (x codecSelfer1234) decSlicePersistentVolumeAccessMode(v *[]PersistentVolum
}
}
- if yyj4555 < len(yyv4555) {
- yyv4555 = yyv4555[:yyj4555]
- yyc4555 = true
- } else if yyj4555 == 0 && yyv4555 == nil {
- yyv4555 = []PersistentVolumeAccessMode{}
- yyc4555 = true
+ if yyj4560 < len(yyv4560) {
+ yyv4560 = yyv4560[:yyj4560]
+ yyc4560 = true
+ } else if yyj4560 == 0 && yyv4560 == nil {
+ yyv4560 = []PersistentVolumeAccessMode{}
+ yyc4560 = true
}
}
- yyh4555.End()
- if yyc4555 {
- *v = yyv4555
+ yyh4560.End()
+ if yyc4560 {
+ *v = yyv4560
}
}
@@ -56931,10 +56995,10 @@ func (x codecSelfer1234) encSlicePersistentVolume(v []PersistentVolume, e *codec
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
r.EncodeArrayStart(len(v))
- for _, yyv4559 := range v {
+ for _, yyv4564 := range v {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy4560 := &yyv4559
- yy4560.CodecEncodeSelf(e)
+ yy4565 := &yyv4564
+ yy4565.CodecEncodeSelf(e)
}
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -56944,83 +57008,83 @@ func (x codecSelfer1234) decSlicePersistentVolume(v *[]PersistentVolume, d *code
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yyv4561 := *v
- yyh4561, yyl4561 := z.DecSliceHelperStart()
- var yyc4561 bool
- if yyl4561 == 0 {
- if yyv4561 == nil {
- yyv4561 = []PersistentVolume{}
- yyc4561 = true
- } else if len(yyv4561) != 0 {
- yyv4561 = yyv4561[:0]
- yyc4561 = true
+ yyv4566 := *v
+ yyh4566, yyl4566 := z.DecSliceHelperStart()
+ var yyc4566 bool
+ if yyl4566 == 0 {
+ if yyv4566 == nil {
+ yyv4566 = []PersistentVolume{}
+ yyc4566 = true
+ } else if len(yyv4566) != 0 {
+ yyv4566 = yyv4566[:0]
+ yyc4566 = true
}
- } else if yyl4561 > 0 {
- var yyrr4561, yyrl4561 int
- var yyrt4561 bool
- if yyl4561 > cap(yyv4561) {
+ } else if yyl4566 > 0 {
+ var yyrr4566, yyrl4566 int
+ var yyrt4566 bool
+ if yyl4566 > cap(yyv4566) {
- yyrg4561 := len(yyv4561) > 0
- yyv24561 := yyv4561
- yyrl4561, yyrt4561 = z.DecInferLen(yyl4561, z.DecBasicHandle().MaxInitLen, 496)
- if yyrt4561 {
- if yyrl4561 <= cap(yyv4561) {
- yyv4561 = yyv4561[:yyrl4561]
+ yyrg4566 := len(yyv4566) > 0
+ yyv24566 := yyv4566
+ yyrl4566, yyrt4566 = z.DecInferLen(yyl4566, z.DecBasicHandle().MaxInitLen, 496)
+ if yyrt4566 {
+ if yyrl4566 <= cap(yyv4566) {
+ yyv4566 = yyv4566[:yyrl4566]
} else {
- yyv4561 = make([]PersistentVolume, yyrl4561)
+ yyv4566 = make([]PersistentVolume, yyrl4566)
}
} else {
- yyv4561 = make([]PersistentVolume, yyrl4561)
+ yyv4566 = make([]PersistentVolume, yyrl4566)
}
- yyc4561 = true
- yyrr4561 = len(yyv4561)
- if yyrg4561 {
- copy(yyv4561, yyv24561)
+ yyc4566 = true
+ yyrr4566 = len(yyv4566)
+ if yyrg4566 {
+ copy(yyv4566, yyv24566)
}
- } else if yyl4561 != len(yyv4561) {
- yyv4561 = yyv4561[:yyl4561]
- yyc4561 = true
+ } else if yyl4566 != len(yyv4566) {
+ yyv4566 = yyv4566[:yyl4566]
+ yyc4566 = true
}
- yyj4561 := 0
- for ; yyj4561 < yyrr4561; yyj4561++ {
- yyh4561.ElemContainerState(yyj4561)
+ yyj4566 := 0
+ for ; yyj4566 < yyrr4566; yyj4566++ {
+ yyh4566.ElemContainerState(yyj4566)
if r.TryDecodeAsNil() {
- yyv4561[yyj4561] = PersistentVolume{}
+ yyv4566[yyj4566] = PersistentVolume{}
} else {
- yyv4562 := &yyv4561[yyj4561]
- yyv4562.CodecDecodeSelf(d)
+ yyv4567 := &yyv4566[yyj4566]
+ yyv4567.CodecDecodeSelf(d)
}
}
- if yyrt4561 {
- for ; yyj4561 < yyl4561; yyj4561++ {
- yyv4561 = append(yyv4561, PersistentVolume{})
- yyh4561.ElemContainerState(yyj4561)
+ if yyrt4566 {
+ for ; yyj4566 < yyl4566; yyj4566++ {
+ yyv4566 = append(yyv4566, PersistentVolume{})
+ yyh4566.ElemContainerState(yyj4566)
if r.TryDecodeAsNil() {
- yyv4561[yyj4561] = PersistentVolume{}
+ yyv4566[yyj4566] = PersistentVolume{}
} else {
- yyv4563 := &yyv4561[yyj4561]
- yyv4563.CodecDecodeSelf(d)
+ yyv4568 := &yyv4566[yyj4566]
+ yyv4568.CodecDecodeSelf(d)
}
}
}
} else {
- yyj4561 := 0
- for ; !r.CheckBreak(); yyj4561++ {
+ yyj4566 := 0
+ for ; !r.CheckBreak(); yyj4566++ {
- if yyj4561 >= len(yyv4561) {
- yyv4561 = append(yyv4561, PersistentVolume{}) // var yyz4561 PersistentVolume
- yyc4561 = true
+ if yyj4566 >= len(yyv4566) {
+ yyv4566 = append(yyv4566, PersistentVolume{}) // var yyz4566 PersistentVolume
+ yyc4566 = true
}
- yyh4561.ElemContainerState(yyj4561)
- if yyj4561 < len(yyv4561) {
+ yyh4566.ElemContainerState(yyj4566)
+ if yyj4566 < len(yyv4566) {
if r.TryDecodeAsNil() {
- yyv4561[yyj4561] = PersistentVolume{}
+ yyv4566[yyj4566] = PersistentVolume{}
} else {
- yyv4564 := &yyv4561[yyj4561]
- yyv4564.CodecDecodeSelf(d)
+ yyv4569 := &yyv4566[yyj4566]
+ yyv4569.CodecDecodeSelf(d)
}
} else {
@@ -57028,17 +57092,17 @@ func (x codecSelfer1234) decSlicePersistentVolume(v *[]PersistentVolume, d *code
}
}
- if yyj4561 < len(yyv4561) {
- yyv4561 = yyv4561[:yyj4561]
- yyc4561 = true
- } else if yyj4561 == 0 && yyv4561 == nil {
- yyv4561 = []PersistentVolume{}
- yyc4561 = true
+ if yyj4566 < len(yyv4566) {
+ yyv4566 = yyv4566[:yyj4566]
+ yyc4566 = true
+ } else if yyj4566 == 0 && yyv4566 == nil {
+ yyv4566 = []PersistentVolume{}
+ yyc4566 = true
}
}
- yyh4561.End()
- if yyc4561 {
- *v = yyv4561
+ yyh4566.End()
+ if yyc4566 {
+ *v = yyv4566
}
}
@@ -57047,10 +57111,10 @@ func (x codecSelfer1234) encSlicePersistentVolumeClaim(v []PersistentVolumeClaim
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
r.EncodeArrayStart(len(v))
- for _, yyv4565 := range v {
+ for _, yyv4570 := range v {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy4566 := &yyv4565
- yy4566.CodecEncodeSelf(e)
+ yy4571 := &yyv4570
+ yy4571.CodecEncodeSelf(e)
}
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -57060,83 +57124,83 @@ func (x codecSelfer1234) decSlicePersistentVolumeClaim(v *[]PersistentVolumeClai
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yyv4567 := *v
- yyh4567, yyl4567 := z.DecSliceHelperStart()
- var yyc4567 bool
- if yyl4567 == 0 {
- if yyv4567 == nil {
- yyv4567 = []PersistentVolumeClaim{}
- yyc4567 = true
- } else if len(yyv4567) != 0 {
- yyv4567 = yyv4567[:0]
- yyc4567 = true
+ yyv4572 := *v
+ yyh4572, yyl4572 := z.DecSliceHelperStart()
+ var yyc4572 bool
+ if yyl4572 == 0 {
+ if yyv4572 == nil {
+ yyv4572 = []PersistentVolumeClaim{}
+ yyc4572 = true
+ } else if len(yyv4572) != 0 {
+ yyv4572 = yyv4572[:0]
+ yyc4572 = true
}
- } else if yyl4567 > 0 {
- var yyrr4567, yyrl4567 int
- var yyrt4567 bool
- if yyl4567 > cap(yyv4567) {
+ } else if yyl4572 > 0 {
+ var yyrr4572, yyrl4572 int
+ var yyrt4572 bool
+ if yyl4572 > cap(yyv4572) {
- yyrg4567 := len(yyv4567) > 0
- yyv24567 := yyv4567
- yyrl4567, yyrt4567 = z.DecInferLen(yyl4567, z.DecBasicHandle().MaxInitLen, 368)
- if yyrt4567 {
- if yyrl4567 <= cap(yyv4567) {
- yyv4567 = yyv4567[:yyrl4567]
+ yyrg4572 := len(yyv4572) > 0
+ yyv24572 := yyv4572
+ yyrl4572, yyrt4572 = z.DecInferLen(yyl4572, z.DecBasicHandle().MaxInitLen, 368)
+ if yyrt4572 {
+ if yyrl4572 <= cap(yyv4572) {
+ yyv4572 = yyv4572[:yyrl4572]
} else {
- yyv4567 = make([]PersistentVolumeClaim, yyrl4567)
+ yyv4572 = make([]PersistentVolumeClaim, yyrl4572)
}
} else {
- yyv4567 = make([]PersistentVolumeClaim, yyrl4567)
+ yyv4572 = make([]PersistentVolumeClaim, yyrl4572)
}
- yyc4567 = true
- yyrr4567 = len(yyv4567)
- if yyrg4567 {
- copy(yyv4567, yyv24567)
+ yyc4572 = true
+ yyrr4572 = len(yyv4572)
+ if yyrg4572 {
+ copy(yyv4572, yyv24572)
}
- } else if yyl4567 != len(yyv4567) {
- yyv4567 = yyv4567[:yyl4567]
- yyc4567 = true
+ } else if yyl4572 != len(yyv4572) {
+ yyv4572 = yyv4572[:yyl4572]
+ yyc4572 = true
}
- yyj4567 := 0
- for ; yyj4567 < yyrr4567; yyj4567++ {
- yyh4567.ElemContainerState(yyj4567)
+ yyj4572 := 0
+ for ; yyj4572 < yyrr4572; yyj4572++ {
+ yyh4572.ElemContainerState(yyj4572)
if r.TryDecodeAsNil() {
- yyv4567[yyj4567] = PersistentVolumeClaim{}
+ yyv4572[yyj4572] = PersistentVolumeClaim{}
} else {
- yyv4568 := &yyv4567[yyj4567]
- yyv4568.CodecDecodeSelf(d)
+ yyv4573 := &yyv4572[yyj4572]
+ yyv4573.CodecDecodeSelf(d)
}
}
- if yyrt4567 {
- for ; yyj4567 < yyl4567; yyj4567++ {
- yyv4567 = append(yyv4567, PersistentVolumeClaim{})
- yyh4567.ElemContainerState(yyj4567)
+ if yyrt4572 {
+ for ; yyj4572 < yyl4572; yyj4572++ {
+ yyv4572 = append(yyv4572, PersistentVolumeClaim{})
+ yyh4572.ElemContainerState(yyj4572)
if r.TryDecodeAsNil() {
- yyv4567[yyj4567] = PersistentVolumeClaim{}
+ yyv4572[yyj4572] = PersistentVolumeClaim{}
} else {
- yyv4569 := &yyv4567[yyj4567]
- yyv4569.CodecDecodeSelf(d)
+ yyv4574 := &yyv4572[yyj4572]
+ yyv4574.CodecDecodeSelf(d)
}
}
}
} else {
- yyj4567 := 0
- for ; !r.CheckBreak(); yyj4567++ {
+ yyj4572 := 0
+ for ; !r.CheckBreak(); yyj4572++ {
- if yyj4567 >= len(yyv4567) {
- yyv4567 = append(yyv4567, PersistentVolumeClaim{}) // var yyz4567 PersistentVolumeClaim
- yyc4567 = true
+ if yyj4572 >= len(yyv4572) {
+ yyv4572 = append(yyv4572, PersistentVolumeClaim{}) // var yyz4572 PersistentVolumeClaim
+ yyc4572 = true
}
- yyh4567.ElemContainerState(yyj4567)
- if yyj4567 < len(yyv4567) {
+ yyh4572.ElemContainerState(yyj4572)
+ if yyj4572 < len(yyv4572) {
if r.TryDecodeAsNil() {
- yyv4567[yyj4567] = PersistentVolumeClaim{}
+ yyv4572[yyj4572] = PersistentVolumeClaim{}
} else {
- yyv4570 := &yyv4567[yyj4567]
- yyv4570.CodecDecodeSelf(d)
+ yyv4575 := &yyv4572[yyj4572]
+ yyv4575.CodecDecodeSelf(d)
}
} else {
@@ -57144,17 +57208,17 @@ func (x codecSelfer1234) decSlicePersistentVolumeClaim(v *[]PersistentVolumeClai
}
}
- if yyj4567 < len(yyv4567) {
- yyv4567 = yyv4567[:yyj4567]
- yyc4567 = true
- } else if yyj4567 == 0 && yyv4567 == nil {
- yyv4567 = []PersistentVolumeClaim{}
- yyc4567 = true
+ if yyj4572 < len(yyv4572) {
+ yyv4572 = yyv4572[:yyj4572]
+ yyc4572 = true
+ } else if yyj4572 == 0 && yyv4572 == nil {
+ yyv4572 = []PersistentVolumeClaim{}
+ yyc4572 = true
}
}
- yyh4567.End()
- if yyc4567 {
- *v = yyv4567
+ yyh4572.End()
+ if yyc4572 {
+ *v = yyv4572
}
}
@@ -57163,10 +57227,10 @@ func (x codecSelfer1234) encSliceKeyToPath(v []KeyToPath, e *codec1978.Encoder)
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
r.EncodeArrayStart(len(v))
- for _, yyv4571 := range v {
+ for _, yyv4576 := range v {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy4572 := &yyv4571
- yy4572.CodecEncodeSelf(e)
+ yy4577 := &yyv4576
+ yy4577.CodecEncodeSelf(e)
}
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -57176,83 +57240,83 @@ func (x codecSelfer1234) decSliceKeyToPath(v *[]KeyToPath, d *codec1978.Decoder)
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yyv4573 := *v
- yyh4573, yyl4573 := z.DecSliceHelperStart()
- var yyc4573 bool
- if yyl4573 == 0 {
- if yyv4573 == nil {
- yyv4573 = []KeyToPath{}
- yyc4573 = true
- } else if len(yyv4573) != 0 {
- yyv4573 = yyv4573[:0]
- yyc4573 = true
+ yyv4578 := *v
+ yyh4578, yyl4578 := z.DecSliceHelperStart()
+ var yyc4578 bool
+ if yyl4578 == 0 {
+ if yyv4578 == nil {
+ yyv4578 = []KeyToPath{}
+ yyc4578 = true
+ } else if len(yyv4578) != 0 {
+ yyv4578 = yyv4578[:0]
+ yyc4578 = true
}
- } else if yyl4573 > 0 {
- var yyrr4573, yyrl4573 int
- var yyrt4573 bool
- if yyl4573 > cap(yyv4573) {
+ } else if yyl4578 > 0 {
+ var yyrr4578, yyrl4578 int
+ var yyrt4578 bool
+ if yyl4578 > cap(yyv4578) {
- yyrg4573 := len(yyv4573) > 0
- yyv24573 := yyv4573
- yyrl4573, yyrt4573 = z.DecInferLen(yyl4573, z.DecBasicHandle().MaxInitLen, 40)
- if yyrt4573 {
- if yyrl4573 <= cap(yyv4573) {
- yyv4573 = yyv4573[:yyrl4573]
+ yyrg4578 := len(yyv4578) > 0
+ yyv24578 := yyv4578
+ yyrl4578, yyrt4578 = z.DecInferLen(yyl4578, z.DecBasicHandle().MaxInitLen, 40)
+ if yyrt4578 {
+ if yyrl4578 <= cap(yyv4578) {
+ yyv4578 = yyv4578[:yyrl4578]
} else {
- yyv4573 = make([]KeyToPath, yyrl4573)
+ yyv4578 = make([]KeyToPath, yyrl4578)
}
} else {
- yyv4573 = make([]KeyToPath, yyrl4573)
+ yyv4578 = make([]KeyToPath, yyrl4578)
}
- yyc4573 = true
- yyrr4573 = len(yyv4573)
- if yyrg4573 {
- copy(yyv4573, yyv24573)
+ yyc4578 = true
+ yyrr4578 = len(yyv4578)
+ if yyrg4578 {
+ copy(yyv4578, yyv24578)
}
- } else if yyl4573 != len(yyv4573) {
- yyv4573 = yyv4573[:yyl4573]
- yyc4573 = true
+ } else if yyl4578 != len(yyv4578) {
+ yyv4578 = yyv4578[:yyl4578]
+ yyc4578 = true
}
- yyj4573 := 0
- for ; yyj4573 < yyrr4573; yyj4573++ {
- yyh4573.ElemContainerState(yyj4573)
+ yyj4578 := 0
+ for ; yyj4578 < yyrr4578; yyj4578++ {
+ yyh4578.ElemContainerState(yyj4578)
if r.TryDecodeAsNil() {
- yyv4573[yyj4573] = KeyToPath{}
+ yyv4578[yyj4578] = KeyToPath{}
} else {
- yyv4574 := &yyv4573[yyj4573]
- yyv4574.CodecDecodeSelf(d)
+ yyv4579 := &yyv4578[yyj4578]
+ yyv4579.CodecDecodeSelf(d)
}
}
- if yyrt4573 {
- for ; yyj4573 < yyl4573; yyj4573++ {
- yyv4573 = append(yyv4573, KeyToPath{})
- yyh4573.ElemContainerState(yyj4573)
+ if yyrt4578 {
+ for ; yyj4578 < yyl4578; yyj4578++ {
+ yyv4578 = append(yyv4578, KeyToPath{})
+ yyh4578.ElemContainerState(yyj4578)
if r.TryDecodeAsNil() {
- yyv4573[yyj4573] = KeyToPath{}
+ yyv4578[yyj4578] = KeyToPath{}
} else {
- yyv4575 := &yyv4573[yyj4573]
- yyv4575.CodecDecodeSelf(d)
+ yyv4580 := &yyv4578[yyj4578]
+ yyv4580.CodecDecodeSelf(d)
}
}
}
} else {
- yyj4573 := 0
- for ; !r.CheckBreak(); yyj4573++ {
+ yyj4578 := 0
+ for ; !r.CheckBreak(); yyj4578++ {
- if yyj4573 >= len(yyv4573) {
- yyv4573 = append(yyv4573, KeyToPath{}) // var yyz4573 KeyToPath
- yyc4573 = true
+ if yyj4578 >= len(yyv4578) {
+ yyv4578 = append(yyv4578, KeyToPath{}) // var yyz4578 KeyToPath
+ yyc4578 = true
}
- yyh4573.ElemContainerState(yyj4573)
- if yyj4573 < len(yyv4573) {
+ yyh4578.ElemContainerState(yyj4578)
+ if yyj4578 < len(yyv4578) {
if r.TryDecodeAsNil() {
- yyv4573[yyj4573] = KeyToPath{}
+ yyv4578[yyj4578] = KeyToPath{}
} else {
- yyv4576 := &yyv4573[yyj4573]
- yyv4576.CodecDecodeSelf(d)
+ yyv4581 := &yyv4578[yyj4578]
+ yyv4581.CodecDecodeSelf(d)
}
} else {
@@ -57260,17 +57324,17 @@ func (x codecSelfer1234) decSliceKeyToPath(v *[]KeyToPath, d *codec1978.Decoder)
}
}
- if yyj4573 < len(yyv4573) {
- yyv4573 = yyv4573[:yyj4573]
- yyc4573 = true
- } else if yyj4573 == 0 && yyv4573 == nil {
- yyv4573 = []KeyToPath{}
- yyc4573 = true
+ if yyj4578 < len(yyv4578) {
+ yyv4578 = yyv4578[:yyj4578]
+ yyc4578 = true
+ } else if yyj4578 == 0 && yyv4578 == nil {
+ yyv4578 = []KeyToPath{}
+ yyc4578 = true
}
}
- yyh4573.End()
- if yyc4573 {
- *v = yyv4573
+ yyh4578.End()
+ if yyc4578 {
+ *v = yyv4578
}
}
@@ -57279,10 +57343,10 @@ func (x codecSelfer1234) encSliceHTTPHeader(v []HTTPHeader, e *codec1978.Encoder
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
r.EncodeArrayStart(len(v))
- for _, yyv4577 := range v {
+ for _, yyv4582 := range v {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy4578 := &yyv4577
- yy4578.CodecEncodeSelf(e)
+ yy4583 := &yyv4582
+ yy4583.CodecEncodeSelf(e)
}
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -57292,127 +57356,12 @@ func (x codecSelfer1234) decSliceHTTPHeader(v *[]HTTPHeader, d *codec1978.Decode
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yyv4579 := *v
- yyh4579, yyl4579 := z.DecSliceHelperStart()
- var yyc4579 bool
- if yyl4579 == 0 {
- if yyv4579 == nil {
- yyv4579 = []HTTPHeader{}
- yyc4579 = true
- } else if len(yyv4579) != 0 {
- yyv4579 = yyv4579[:0]
- yyc4579 = true
- }
- } else if yyl4579 > 0 {
- var yyrr4579, yyrl4579 int
- var yyrt4579 bool
- if yyl4579 > cap(yyv4579) {
-
- yyrg4579 := len(yyv4579) > 0
- yyv24579 := yyv4579
- yyrl4579, yyrt4579 = z.DecInferLen(yyl4579, z.DecBasicHandle().MaxInitLen, 32)
- if yyrt4579 {
- if yyrl4579 <= cap(yyv4579) {
- yyv4579 = yyv4579[:yyrl4579]
- } else {
- yyv4579 = make([]HTTPHeader, yyrl4579)
- }
- } else {
- yyv4579 = make([]HTTPHeader, yyrl4579)
- }
- yyc4579 = true
- yyrr4579 = len(yyv4579)
- if yyrg4579 {
- copy(yyv4579, yyv24579)
- }
- } else if yyl4579 != len(yyv4579) {
- yyv4579 = yyv4579[:yyl4579]
- yyc4579 = true
- }
- yyj4579 := 0
- for ; yyj4579 < yyrr4579; yyj4579++ {
- yyh4579.ElemContainerState(yyj4579)
- if r.TryDecodeAsNil() {
- yyv4579[yyj4579] = HTTPHeader{}
- } else {
- yyv4580 := &yyv4579[yyj4579]
- yyv4580.CodecDecodeSelf(d)
- }
-
- }
- if yyrt4579 {
- for ; yyj4579 < yyl4579; yyj4579++ {
- yyv4579 = append(yyv4579, HTTPHeader{})
- yyh4579.ElemContainerState(yyj4579)
- if r.TryDecodeAsNil() {
- yyv4579[yyj4579] = HTTPHeader{}
- } else {
- yyv4581 := &yyv4579[yyj4579]
- yyv4581.CodecDecodeSelf(d)
- }
-
- }
- }
-
- } else {
- yyj4579 := 0
- for ; !r.CheckBreak(); yyj4579++ {
-
- if yyj4579 >= len(yyv4579) {
- yyv4579 = append(yyv4579, HTTPHeader{}) // var yyz4579 HTTPHeader
- yyc4579 = true
- }
- yyh4579.ElemContainerState(yyj4579)
- if yyj4579 < len(yyv4579) {
- if r.TryDecodeAsNil() {
- yyv4579[yyj4579] = HTTPHeader{}
- } else {
- yyv4582 := &yyv4579[yyj4579]
- yyv4582.CodecDecodeSelf(d)
- }
-
- } else {
- z.DecSwallow()
- }
-
- }
- if yyj4579 < len(yyv4579) {
- yyv4579 = yyv4579[:yyj4579]
- yyc4579 = true
- } else if yyj4579 == 0 && yyv4579 == nil {
- yyv4579 = []HTTPHeader{}
- yyc4579 = true
- }
- }
- yyh4579.End()
- if yyc4579 {
- *v = yyv4579
- }
-}
-
-func (x codecSelfer1234) encSliceCapability(v []Capability, e *codec1978.Encoder) {
- var h codecSelfer1234
- z, r := codec1978.GenHelperEncoder(e)
- _, _, _ = h, z, r
- r.EncodeArrayStart(len(v))
- for _, yyv4583 := range v {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yyv4583.CodecEncodeSelf(e)
- }
- z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
-}
-
-func (x codecSelfer1234) decSliceCapability(v *[]Capability, d *codec1978.Decoder) {
- var h codecSelfer1234
- z, r := codec1978.GenHelperDecoder(d)
- _, _, _ = h, z, r
-
yyv4584 := *v
yyh4584, yyl4584 := z.DecSliceHelperStart()
var yyc4584 bool
if yyl4584 == 0 {
if yyv4584 == nil {
- yyv4584 = []Capability{}
+ yyv4584 = []HTTPHeader{}
yyc4584 = true
} else if len(yyv4584) != 0 {
yyv4584 = yyv4584[:0]
@@ -57423,18 +57372,23 @@ func (x codecSelfer1234) decSliceCapability(v *[]Capability, d *codec1978.Decode
var yyrt4584 bool
if yyl4584 > cap(yyv4584) {
- yyrl4584, yyrt4584 = z.DecInferLen(yyl4584, z.DecBasicHandle().MaxInitLen, 16)
+ yyrg4584 := len(yyv4584) > 0
+ yyv24584 := yyv4584
+ yyrl4584, yyrt4584 = z.DecInferLen(yyl4584, z.DecBasicHandle().MaxInitLen, 32)
if yyrt4584 {
if yyrl4584 <= cap(yyv4584) {
yyv4584 = yyv4584[:yyrl4584]
} else {
- yyv4584 = make([]Capability, yyrl4584)
+ yyv4584 = make([]HTTPHeader, yyrl4584)
}
} else {
- yyv4584 = make([]Capability, yyrl4584)
+ yyv4584 = make([]HTTPHeader, yyrl4584)
}
yyc4584 = true
yyrr4584 = len(yyv4584)
+ if yyrg4584 {
+ copy(yyv4584, yyv24584)
+ }
} else if yyl4584 != len(yyv4584) {
yyv4584 = yyv4584[:yyl4584]
yyc4584 = true
@@ -57443,20 +57397,22 @@ func (x codecSelfer1234) decSliceCapability(v *[]Capability, d *codec1978.Decode
for ; yyj4584 < yyrr4584; yyj4584++ {
yyh4584.ElemContainerState(yyj4584)
if r.TryDecodeAsNil() {
- yyv4584[yyj4584] = ""
+ yyv4584[yyj4584] = HTTPHeader{}
} else {
- yyv4584[yyj4584] = Capability(r.DecodeString())
+ yyv4585 := &yyv4584[yyj4584]
+ yyv4585.CodecDecodeSelf(d)
}
}
if yyrt4584 {
for ; yyj4584 < yyl4584; yyj4584++ {
- yyv4584 = append(yyv4584, "")
+ yyv4584 = append(yyv4584, HTTPHeader{})
yyh4584.ElemContainerState(yyj4584)
if r.TryDecodeAsNil() {
- yyv4584[yyj4584] = ""
+ yyv4584[yyj4584] = HTTPHeader{}
} else {
- yyv4584[yyj4584] = Capability(r.DecodeString())
+ yyv4586 := &yyv4584[yyj4584]
+ yyv4586.CodecDecodeSelf(d)
}
}
@@ -57467,15 +57423,16 @@ func (x codecSelfer1234) decSliceCapability(v *[]Capability, d *codec1978.Decode
for ; !r.CheckBreak(); yyj4584++ {
if yyj4584 >= len(yyv4584) {
- yyv4584 = append(yyv4584, "") // var yyz4584 Capability
+ yyv4584 = append(yyv4584, HTTPHeader{}) // var yyz4584 HTTPHeader
yyc4584 = true
}
yyh4584.ElemContainerState(yyj4584)
if yyj4584 < len(yyv4584) {
if r.TryDecodeAsNil() {
- yyv4584[yyj4584] = ""
+ yyv4584[yyj4584] = HTTPHeader{}
} else {
- yyv4584[yyj4584] = Capability(r.DecodeString())
+ yyv4587 := &yyv4584[yyj4584]
+ yyv4587.CodecDecodeSelf(d)
}
} else {
@@ -57487,7 +57444,7 @@ func (x codecSelfer1234) decSliceCapability(v *[]Capability, d *codec1978.Decode
yyv4584 = yyv4584[:yyj4584]
yyc4584 = true
} else if yyj4584 == 0 && yyv4584 == nil {
- yyv4584 = []Capability{}
+ yyv4584 = []HTTPHeader{}
yyc4584 = true
}
}
@@ -57497,15 +57454,122 @@ func (x codecSelfer1234) decSliceCapability(v *[]Capability, d *codec1978.Decode
}
}
-func (x codecSelfer1234) encSliceContainerPort(v []ContainerPort, e *codec1978.Encoder) {
+func (x codecSelfer1234) encSliceCapability(v []Capability, e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
r.EncodeArrayStart(len(v))
for _, yyv4588 := range v {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy4589 := &yyv4588
- yy4589.CodecEncodeSelf(e)
+ yyv4588.CodecEncodeSelf(e)
+ }
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x codecSelfer1234) decSliceCapability(v *[]Capability, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+
+ yyv4589 := *v
+ yyh4589, yyl4589 := z.DecSliceHelperStart()
+ var yyc4589 bool
+ if yyl4589 == 0 {
+ if yyv4589 == nil {
+ yyv4589 = []Capability{}
+ yyc4589 = true
+ } else if len(yyv4589) != 0 {
+ yyv4589 = yyv4589[:0]
+ yyc4589 = true
+ }
+ } else if yyl4589 > 0 {
+ var yyrr4589, yyrl4589 int
+ var yyrt4589 bool
+ if yyl4589 > cap(yyv4589) {
+
+ yyrl4589, yyrt4589 = z.DecInferLen(yyl4589, z.DecBasicHandle().MaxInitLen, 16)
+ if yyrt4589 {
+ if yyrl4589 <= cap(yyv4589) {
+ yyv4589 = yyv4589[:yyrl4589]
+ } else {
+ yyv4589 = make([]Capability, yyrl4589)
+ }
+ } else {
+ yyv4589 = make([]Capability, yyrl4589)
+ }
+ yyc4589 = true
+ yyrr4589 = len(yyv4589)
+ } else if yyl4589 != len(yyv4589) {
+ yyv4589 = yyv4589[:yyl4589]
+ yyc4589 = true
+ }
+ yyj4589 := 0
+ for ; yyj4589 < yyrr4589; yyj4589++ {
+ yyh4589.ElemContainerState(yyj4589)
+ if r.TryDecodeAsNil() {
+ yyv4589[yyj4589] = ""
+ } else {
+ yyv4589[yyj4589] = Capability(r.DecodeString())
+ }
+
+ }
+ if yyrt4589 {
+ for ; yyj4589 < yyl4589; yyj4589++ {
+ yyv4589 = append(yyv4589, "")
+ yyh4589.ElemContainerState(yyj4589)
+ if r.TryDecodeAsNil() {
+ yyv4589[yyj4589] = ""
+ } else {
+ yyv4589[yyj4589] = Capability(r.DecodeString())
+ }
+
+ }
+ }
+
+ } else {
+ yyj4589 := 0
+ for ; !r.CheckBreak(); yyj4589++ {
+
+ if yyj4589 >= len(yyv4589) {
+ yyv4589 = append(yyv4589, "") // var yyz4589 Capability
+ yyc4589 = true
+ }
+ yyh4589.ElemContainerState(yyj4589)
+ if yyj4589 < len(yyv4589) {
+ if r.TryDecodeAsNil() {
+ yyv4589[yyj4589] = ""
+ } else {
+ yyv4589[yyj4589] = Capability(r.DecodeString())
+ }
+
+ } else {
+ z.DecSwallow()
+ }
+
+ }
+ if yyj4589 < len(yyv4589) {
+ yyv4589 = yyv4589[:yyj4589]
+ yyc4589 = true
+ } else if yyj4589 == 0 && yyv4589 == nil {
+ yyv4589 = []Capability{}
+ yyc4589 = true
+ }
+ }
+ yyh4589.End()
+ if yyc4589 {
+ *v = yyv4589
+ }
+}
+
+func (x codecSelfer1234) encSliceContainerPort(v []ContainerPort, e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ r.EncodeArrayStart(len(v))
+ for _, yyv4593 := range v {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy4594 := &yyv4593
+ yy4594.CodecEncodeSelf(e)
}
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -57515,83 +57579,83 @@ func (x codecSelfer1234) decSliceContainerPort(v *[]ContainerPort, d *codec1978.
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yyv4590 := *v
- yyh4590, yyl4590 := z.DecSliceHelperStart()
- var yyc4590 bool
- if yyl4590 == 0 {
- if yyv4590 == nil {
- yyv4590 = []ContainerPort{}
- yyc4590 = true
- } else if len(yyv4590) != 0 {
- yyv4590 = yyv4590[:0]
- yyc4590 = true
+ yyv4595 := *v
+ yyh4595, yyl4595 := z.DecSliceHelperStart()
+ var yyc4595 bool
+ if yyl4595 == 0 {
+ if yyv4595 == nil {
+ yyv4595 = []ContainerPort{}
+ yyc4595 = true
+ } else if len(yyv4595) != 0 {
+ yyv4595 = yyv4595[:0]
+ yyc4595 = true
}
- } else if yyl4590 > 0 {
- var yyrr4590, yyrl4590 int
- var yyrt4590 bool
- if yyl4590 > cap(yyv4590) {
+ } else if yyl4595 > 0 {
+ var yyrr4595, yyrl4595 int
+ var yyrt4595 bool
+ if yyl4595 > cap(yyv4595) {
- yyrg4590 := len(yyv4590) > 0
- yyv24590 := yyv4590
- yyrl4590, yyrt4590 = z.DecInferLen(yyl4590, z.DecBasicHandle().MaxInitLen, 56)
- if yyrt4590 {
- if yyrl4590 <= cap(yyv4590) {
- yyv4590 = yyv4590[:yyrl4590]
+ yyrg4595 := len(yyv4595) > 0
+ yyv24595 := yyv4595
+ yyrl4595, yyrt4595 = z.DecInferLen(yyl4595, z.DecBasicHandle().MaxInitLen, 56)
+ if yyrt4595 {
+ if yyrl4595 <= cap(yyv4595) {
+ yyv4595 = yyv4595[:yyrl4595]
} else {
- yyv4590 = make([]ContainerPort, yyrl4590)
+ yyv4595 = make([]ContainerPort, yyrl4595)
}
} else {
- yyv4590 = make([]ContainerPort, yyrl4590)
+ yyv4595 = make([]ContainerPort, yyrl4595)
}
- yyc4590 = true
- yyrr4590 = len(yyv4590)
- if yyrg4590 {
- copy(yyv4590, yyv24590)
+ yyc4595 = true
+ yyrr4595 = len(yyv4595)
+ if yyrg4595 {
+ copy(yyv4595, yyv24595)
}
- } else if yyl4590 != len(yyv4590) {
- yyv4590 = yyv4590[:yyl4590]
- yyc4590 = true
+ } else if yyl4595 != len(yyv4595) {
+ yyv4595 = yyv4595[:yyl4595]
+ yyc4595 = true
}
- yyj4590 := 0
- for ; yyj4590 < yyrr4590; yyj4590++ {
- yyh4590.ElemContainerState(yyj4590)
+ yyj4595 := 0
+ for ; yyj4595 < yyrr4595; yyj4595++ {
+ yyh4595.ElemContainerState(yyj4595)
if r.TryDecodeAsNil() {
- yyv4590[yyj4590] = ContainerPort{}
+ yyv4595[yyj4595] = ContainerPort{}
} else {
- yyv4591 := &yyv4590[yyj4590]
- yyv4591.CodecDecodeSelf(d)
+ yyv4596 := &yyv4595[yyj4595]
+ yyv4596.CodecDecodeSelf(d)
}
}
- if yyrt4590 {
- for ; yyj4590 < yyl4590; yyj4590++ {
- yyv4590 = append(yyv4590, ContainerPort{})
- yyh4590.ElemContainerState(yyj4590)
+ if yyrt4595 {
+ for ; yyj4595 < yyl4595; yyj4595++ {
+ yyv4595 = append(yyv4595, ContainerPort{})
+ yyh4595.ElemContainerState(yyj4595)
if r.TryDecodeAsNil() {
- yyv4590[yyj4590] = ContainerPort{}
+ yyv4595[yyj4595] = ContainerPort{}
} else {
- yyv4592 := &yyv4590[yyj4590]
- yyv4592.CodecDecodeSelf(d)
+ yyv4597 := &yyv4595[yyj4595]
+ yyv4597.CodecDecodeSelf(d)
}
}
}
} else {
- yyj4590 := 0
- for ; !r.CheckBreak(); yyj4590++ {
+ yyj4595 := 0
+ for ; !r.CheckBreak(); yyj4595++ {
- if yyj4590 >= len(yyv4590) {
- yyv4590 = append(yyv4590, ContainerPort{}) // var yyz4590 ContainerPort
- yyc4590 = true
+ if yyj4595 >= len(yyv4595) {
+ yyv4595 = append(yyv4595, ContainerPort{}) // var yyz4595 ContainerPort
+ yyc4595 = true
}
- yyh4590.ElemContainerState(yyj4590)
- if yyj4590 < len(yyv4590) {
+ yyh4595.ElemContainerState(yyj4595)
+ if yyj4595 < len(yyv4595) {
if r.TryDecodeAsNil() {
- yyv4590[yyj4590] = ContainerPort{}
+ yyv4595[yyj4595] = ContainerPort{}
} else {
- yyv4593 := &yyv4590[yyj4590]
- yyv4593.CodecDecodeSelf(d)
+ yyv4598 := &yyv4595[yyj4595]
+ yyv4598.CodecDecodeSelf(d)
}
} else {
@@ -57599,17 +57663,17 @@ func (x codecSelfer1234) decSliceContainerPort(v *[]ContainerPort, d *codec1978.
}
}
- if yyj4590 < len(yyv4590) {
- yyv4590 = yyv4590[:yyj4590]
- yyc4590 = true
- } else if yyj4590 == 0 && yyv4590 == nil {
- yyv4590 = []ContainerPort{}
- yyc4590 = true
+ if yyj4595 < len(yyv4595) {
+ yyv4595 = yyv4595[:yyj4595]
+ yyc4595 = true
+ } else if yyj4595 == 0 && yyv4595 == nil {
+ yyv4595 = []ContainerPort{}
+ yyc4595 = true
}
}
- yyh4590.End()
- if yyc4590 {
- *v = yyv4590
+ yyh4595.End()
+ if yyc4595 {
+ *v = yyv4595
}
}
@@ -57618,10 +57682,10 @@ func (x codecSelfer1234) encSliceEnvVar(v []EnvVar, e *codec1978.Encoder) {
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
r.EncodeArrayStart(len(v))
- for _, yyv4594 := range v {
+ for _, yyv4599 := range v {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy4595 := &yyv4594
- yy4595.CodecEncodeSelf(e)
+ yy4600 := &yyv4599
+ yy4600.CodecEncodeSelf(e)
}
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -57631,83 +57695,83 @@ func (x codecSelfer1234) decSliceEnvVar(v *[]EnvVar, d *codec1978.Decoder) {
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yyv4596 := *v
- yyh4596, yyl4596 := z.DecSliceHelperStart()
- var yyc4596 bool
- if yyl4596 == 0 {
- if yyv4596 == nil {
- yyv4596 = []EnvVar{}
- yyc4596 = true
- } else if len(yyv4596) != 0 {
- yyv4596 = yyv4596[:0]
- yyc4596 = true
+ yyv4601 := *v
+ yyh4601, yyl4601 := z.DecSliceHelperStart()
+ var yyc4601 bool
+ if yyl4601 == 0 {
+ if yyv4601 == nil {
+ yyv4601 = []EnvVar{}
+ yyc4601 = true
+ } else if len(yyv4601) != 0 {
+ yyv4601 = yyv4601[:0]
+ yyc4601 = true
}
- } else if yyl4596 > 0 {
- var yyrr4596, yyrl4596 int
- var yyrt4596 bool
- if yyl4596 > cap(yyv4596) {
+ } else if yyl4601 > 0 {
+ var yyrr4601, yyrl4601 int
+ var yyrt4601 bool
+ if yyl4601 > cap(yyv4601) {
- yyrg4596 := len(yyv4596) > 0
- yyv24596 := yyv4596
- yyrl4596, yyrt4596 = z.DecInferLen(yyl4596, z.DecBasicHandle().MaxInitLen, 40)
- if yyrt4596 {
- if yyrl4596 <= cap(yyv4596) {
- yyv4596 = yyv4596[:yyrl4596]
+ yyrg4601 := len(yyv4601) > 0
+ yyv24601 := yyv4601
+ yyrl4601, yyrt4601 = z.DecInferLen(yyl4601, z.DecBasicHandle().MaxInitLen, 40)
+ if yyrt4601 {
+ if yyrl4601 <= cap(yyv4601) {
+ yyv4601 = yyv4601[:yyrl4601]
} else {
- yyv4596 = make([]EnvVar, yyrl4596)
+ yyv4601 = make([]EnvVar, yyrl4601)
}
} else {
- yyv4596 = make([]EnvVar, yyrl4596)
+ yyv4601 = make([]EnvVar, yyrl4601)
}
- yyc4596 = true
- yyrr4596 = len(yyv4596)
- if yyrg4596 {
- copy(yyv4596, yyv24596)
+ yyc4601 = true
+ yyrr4601 = len(yyv4601)
+ if yyrg4601 {
+ copy(yyv4601, yyv24601)
}
- } else if yyl4596 != len(yyv4596) {
- yyv4596 = yyv4596[:yyl4596]
- yyc4596 = true
+ } else if yyl4601 != len(yyv4601) {
+ yyv4601 = yyv4601[:yyl4601]
+ yyc4601 = true
}
- yyj4596 := 0
- for ; yyj4596 < yyrr4596; yyj4596++ {
- yyh4596.ElemContainerState(yyj4596)
+ yyj4601 := 0
+ for ; yyj4601 < yyrr4601; yyj4601++ {
+ yyh4601.ElemContainerState(yyj4601)
if r.TryDecodeAsNil() {
- yyv4596[yyj4596] = EnvVar{}
+ yyv4601[yyj4601] = EnvVar{}
} else {
- yyv4597 := &yyv4596[yyj4596]
- yyv4597.CodecDecodeSelf(d)
+ yyv4602 := &yyv4601[yyj4601]
+ yyv4602.CodecDecodeSelf(d)
}
}
- if yyrt4596 {
- for ; yyj4596 < yyl4596; yyj4596++ {
- yyv4596 = append(yyv4596, EnvVar{})
- yyh4596.ElemContainerState(yyj4596)
+ if yyrt4601 {
+ for ; yyj4601 < yyl4601; yyj4601++ {
+ yyv4601 = append(yyv4601, EnvVar{})
+ yyh4601.ElemContainerState(yyj4601)
if r.TryDecodeAsNil() {
- yyv4596[yyj4596] = EnvVar{}
+ yyv4601[yyj4601] = EnvVar{}
} else {
- yyv4598 := &yyv4596[yyj4596]
- yyv4598.CodecDecodeSelf(d)
+ yyv4603 := &yyv4601[yyj4601]
+ yyv4603.CodecDecodeSelf(d)
}
}
}
} else {
- yyj4596 := 0
- for ; !r.CheckBreak(); yyj4596++ {
+ yyj4601 := 0
+ for ; !r.CheckBreak(); yyj4601++ {
- if yyj4596 >= len(yyv4596) {
- yyv4596 = append(yyv4596, EnvVar{}) // var yyz4596 EnvVar
- yyc4596 = true
+ if yyj4601 >= len(yyv4601) {
+ yyv4601 = append(yyv4601, EnvVar{}) // var yyz4601 EnvVar
+ yyc4601 = true
}
- yyh4596.ElemContainerState(yyj4596)
- if yyj4596 < len(yyv4596) {
+ yyh4601.ElemContainerState(yyj4601)
+ if yyj4601 < len(yyv4601) {
if r.TryDecodeAsNil() {
- yyv4596[yyj4596] = EnvVar{}
+ yyv4601[yyj4601] = EnvVar{}
} else {
- yyv4599 := &yyv4596[yyj4596]
- yyv4599.CodecDecodeSelf(d)
+ yyv4604 := &yyv4601[yyj4601]
+ yyv4604.CodecDecodeSelf(d)
}
} else {
@@ -57715,17 +57779,17 @@ func (x codecSelfer1234) decSliceEnvVar(v *[]EnvVar, d *codec1978.Decoder) {
}
}
- if yyj4596 < len(yyv4596) {
- yyv4596 = yyv4596[:yyj4596]
- yyc4596 = true
- } else if yyj4596 == 0 && yyv4596 == nil {
- yyv4596 = []EnvVar{}
- yyc4596 = true
+ if yyj4601 < len(yyv4601) {
+ yyv4601 = yyv4601[:yyj4601]
+ yyc4601 = true
+ } else if yyj4601 == 0 && yyv4601 == nil {
+ yyv4601 = []EnvVar{}
+ yyc4601 = true
}
}
- yyh4596.End()
- if yyc4596 {
- *v = yyv4596
+ yyh4601.End()
+ if yyc4601 {
+ *v = yyv4601
}
}
@@ -57734,10 +57798,10 @@ func (x codecSelfer1234) encSliceVolumeMount(v []VolumeMount, e *codec1978.Encod
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
r.EncodeArrayStart(len(v))
- for _, yyv4600 := range v {
+ for _, yyv4605 := range v {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy4601 := &yyv4600
- yy4601.CodecEncodeSelf(e)
+ yy4606 := &yyv4605
+ yy4606.CodecEncodeSelf(e)
}
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -57747,83 +57811,83 @@ func (x codecSelfer1234) decSliceVolumeMount(v *[]VolumeMount, d *codec1978.Deco
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yyv4602 := *v
- yyh4602, yyl4602 := z.DecSliceHelperStart()
- var yyc4602 bool
- if yyl4602 == 0 {
- if yyv4602 == nil {
- yyv4602 = []VolumeMount{}
- yyc4602 = true
- } else if len(yyv4602) != 0 {
- yyv4602 = yyv4602[:0]
- yyc4602 = true
+ yyv4607 := *v
+ yyh4607, yyl4607 := z.DecSliceHelperStart()
+ var yyc4607 bool
+ if yyl4607 == 0 {
+ if yyv4607 == nil {
+ yyv4607 = []VolumeMount{}
+ yyc4607 = true
+ } else if len(yyv4607) != 0 {
+ yyv4607 = yyv4607[:0]
+ yyc4607 = true
}
- } else if yyl4602 > 0 {
- var yyrr4602, yyrl4602 int
- var yyrt4602 bool
- if yyl4602 > cap(yyv4602) {
+ } else if yyl4607 > 0 {
+ var yyrr4607, yyrl4607 int
+ var yyrt4607 bool
+ if yyl4607 > cap(yyv4607) {
- yyrg4602 := len(yyv4602) > 0
- yyv24602 := yyv4602
- yyrl4602, yyrt4602 = z.DecInferLen(yyl4602, z.DecBasicHandle().MaxInitLen, 56)
- if yyrt4602 {
- if yyrl4602 <= cap(yyv4602) {
- yyv4602 = yyv4602[:yyrl4602]
+ yyrg4607 := len(yyv4607) > 0
+ yyv24607 := yyv4607
+ yyrl4607, yyrt4607 = z.DecInferLen(yyl4607, z.DecBasicHandle().MaxInitLen, 56)
+ if yyrt4607 {
+ if yyrl4607 <= cap(yyv4607) {
+ yyv4607 = yyv4607[:yyrl4607]
} else {
- yyv4602 = make([]VolumeMount, yyrl4602)
+ yyv4607 = make([]VolumeMount, yyrl4607)
}
} else {
- yyv4602 = make([]VolumeMount, yyrl4602)
+ yyv4607 = make([]VolumeMount, yyrl4607)
}
- yyc4602 = true
- yyrr4602 = len(yyv4602)
- if yyrg4602 {
- copy(yyv4602, yyv24602)
+ yyc4607 = true
+ yyrr4607 = len(yyv4607)
+ if yyrg4607 {
+ copy(yyv4607, yyv24607)
}
- } else if yyl4602 != len(yyv4602) {
- yyv4602 = yyv4602[:yyl4602]
- yyc4602 = true
+ } else if yyl4607 != len(yyv4607) {
+ yyv4607 = yyv4607[:yyl4607]
+ yyc4607 = true
}
- yyj4602 := 0
- for ; yyj4602 < yyrr4602; yyj4602++ {
- yyh4602.ElemContainerState(yyj4602)
+ yyj4607 := 0
+ for ; yyj4607 < yyrr4607; yyj4607++ {
+ yyh4607.ElemContainerState(yyj4607)
if r.TryDecodeAsNil() {
- yyv4602[yyj4602] = VolumeMount{}
+ yyv4607[yyj4607] = VolumeMount{}
} else {
- yyv4603 := &yyv4602[yyj4602]
- yyv4603.CodecDecodeSelf(d)
+ yyv4608 := &yyv4607[yyj4607]
+ yyv4608.CodecDecodeSelf(d)
}
}
- if yyrt4602 {
- for ; yyj4602 < yyl4602; yyj4602++ {
- yyv4602 = append(yyv4602, VolumeMount{})
- yyh4602.ElemContainerState(yyj4602)
+ if yyrt4607 {
+ for ; yyj4607 < yyl4607; yyj4607++ {
+ yyv4607 = append(yyv4607, VolumeMount{})
+ yyh4607.ElemContainerState(yyj4607)
if r.TryDecodeAsNil() {
- yyv4602[yyj4602] = VolumeMount{}
+ yyv4607[yyj4607] = VolumeMount{}
} else {
- yyv4604 := &yyv4602[yyj4602]
- yyv4604.CodecDecodeSelf(d)
+ yyv4609 := &yyv4607[yyj4607]
+ yyv4609.CodecDecodeSelf(d)
}
}
}
} else {
- yyj4602 := 0
- for ; !r.CheckBreak(); yyj4602++ {
+ yyj4607 := 0
+ for ; !r.CheckBreak(); yyj4607++ {
- if yyj4602 >= len(yyv4602) {
- yyv4602 = append(yyv4602, VolumeMount{}) // var yyz4602 VolumeMount
- yyc4602 = true
+ if yyj4607 >= len(yyv4607) {
+ yyv4607 = append(yyv4607, VolumeMount{}) // var yyz4607 VolumeMount
+ yyc4607 = true
}
- yyh4602.ElemContainerState(yyj4602)
- if yyj4602 < len(yyv4602) {
+ yyh4607.ElemContainerState(yyj4607)
+ if yyj4607 < len(yyv4607) {
if r.TryDecodeAsNil() {
- yyv4602[yyj4602] = VolumeMount{}
+ yyv4607[yyj4607] = VolumeMount{}
} else {
- yyv4605 := &yyv4602[yyj4602]
- yyv4605.CodecDecodeSelf(d)
+ yyv4610 := &yyv4607[yyj4607]
+ yyv4610.CodecDecodeSelf(d)
}
} else {
@@ -57831,17 +57895,17 @@ func (x codecSelfer1234) decSliceVolumeMount(v *[]VolumeMount, d *codec1978.Deco
}
}
- if yyj4602 < len(yyv4602) {
- yyv4602 = yyv4602[:yyj4602]
- yyc4602 = true
- } else if yyj4602 == 0 && yyv4602 == nil {
- yyv4602 = []VolumeMount{}
- yyc4602 = true
+ if yyj4607 < len(yyv4607) {
+ yyv4607 = yyv4607[:yyj4607]
+ yyc4607 = true
+ } else if yyj4607 == 0 && yyv4607 == nil {
+ yyv4607 = []VolumeMount{}
+ yyc4607 = true
}
}
- yyh4602.End()
- if yyc4602 {
- *v = yyv4602
+ yyh4607.End()
+ if yyc4607 {
+ *v = yyv4607
}
}
@@ -57850,10 +57914,10 @@ func (x codecSelfer1234) encSliceNodeSelectorTerm(v []NodeSelectorTerm, e *codec
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
r.EncodeArrayStart(len(v))
- for _, yyv4606 := range v {
+ for _, yyv4611 := range v {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy4607 := &yyv4606
- yy4607.CodecEncodeSelf(e)
+ yy4612 := &yyv4611
+ yy4612.CodecEncodeSelf(e)
}
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -57863,83 +57927,83 @@ func (x codecSelfer1234) decSliceNodeSelectorTerm(v *[]NodeSelectorTerm, d *code
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yyv4608 := *v
- yyh4608, yyl4608 := z.DecSliceHelperStart()
- var yyc4608 bool
- if yyl4608 == 0 {
- if yyv4608 == nil {
- yyv4608 = []NodeSelectorTerm{}
- yyc4608 = true
- } else if len(yyv4608) != 0 {
- yyv4608 = yyv4608[:0]
- yyc4608 = true
+ yyv4613 := *v
+ yyh4613, yyl4613 := z.DecSliceHelperStart()
+ var yyc4613 bool
+ if yyl4613 == 0 {
+ if yyv4613 == nil {
+ yyv4613 = []NodeSelectorTerm{}
+ yyc4613 = true
+ } else if len(yyv4613) != 0 {
+ yyv4613 = yyv4613[:0]
+ yyc4613 = true
}
- } else if yyl4608 > 0 {
- var yyrr4608, yyrl4608 int
- var yyrt4608 bool
- if yyl4608 > cap(yyv4608) {
+ } else if yyl4613 > 0 {
+ var yyrr4613, yyrl4613 int
+ var yyrt4613 bool
+ if yyl4613 > cap(yyv4613) {
- yyrg4608 := len(yyv4608) > 0
- yyv24608 := yyv4608
- yyrl4608, yyrt4608 = z.DecInferLen(yyl4608, z.DecBasicHandle().MaxInitLen, 24)
- if yyrt4608 {
- if yyrl4608 <= cap(yyv4608) {
- yyv4608 = yyv4608[:yyrl4608]
+ yyrg4613 := len(yyv4613) > 0
+ yyv24613 := yyv4613
+ yyrl4613, yyrt4613 = z.DecInferLen(yyl4613, z.DecBasicHandle().MaxInitLen, 24)
+ if yyrt4613 {
+ if yyrl4613 <= cap(yyv4613) {
+ yyv4613 = yyv4613[:yyrl4613]
} else {
- yyv4608 = make([]NodeSelectorTerm, yyrl4608)
+ yyv4613 = make([]NodeSelectorTerm, yyrl4613)
}
} else {
- yyv4608 = make([]NodeSelectorTerm, yyrl4608)
+ yyv4613 = make([]NodeSelectorTerm, yyrl4613)
}
- yyc4608 = true
- yyrr4608 = len(yyv4608)
- if yyrg4608 {
- copy(yyv4608, yyv24608)
+ yyc4613 = true
+ yyrr4613 = len(yyv4613)
+ if yyrg4613 {
+ copy(yyv4613, yyv24613)
}
- } else if yyl4608 != len(yyv4608) {
- yyv4608 = yyv4608[:yyl4608]
- yyc4608 = true
+ } else if yyl4613 != len(yyv4613) {
+ yyv4613 = yyv4613[:yyl4613]
+ yyc4613 = true
}
- yyj4608 := 0
- for ; yyj4608 < yyrr4608; yyj4608++ {
- yyh4608.ElemContainerState(yyj4608)
+ yyj4613 := 0
+ for ; yyj4613 < yyrr4613; yyj4613++ {
+ yyh4613.ElemContainerState(yyj4613)
if r.TryDecodeAsNil() {
- yyv4608[yyj4608] = NodeSelectorTerm{}
+ yyv4613[yyj4613] = NodeSelectorTerm{}
} else {
- yyv4609 := &yyv4608[yyj4608]
- yyv4609.CodecDecodeSelf(d)
+ yyv4614 := &yyv4613[yyj4613]
+ yyv4614.CodecDecodeSelf(d)
}
}
- if yyrt4608 {
- for ; yyj4608 < yyl4608; yyj4608++ {
- yyv4608 = append(yyv4608, NodeSelectorTerm{})
- yyh4608.ElemContainerState(yyj4608)
+ if yyrt4613 {
+ for ; yyj4613 < yyl4613; yyj4613++ {
+ yyv4613 = append(yyv4613, NodeSelectorTerm{})
+ yyh4613.ElemContainerState(yyj4613)
if r.TryDecodeAsNil() {
- yyv4608[yyj4608] = NodeSelectorTerm{}
+ yyv4613[yyj4613] = NodeSelectorTerm{}
} else {
- yyv4610 := &yyv4608[yyj4608]
- yyv4610.CodecDecodeSelf(d)
+ yyv4615 := &yyv4613[yyj4613]
+ yyv4615.CodecDecodeSelf(d)
}
}
}
} else {
- yyj4608 := 0
- for ; !r.CheckBreak(); yyj4608++ {
+ yyj4613 := 0
+ for ; !r.CheckBreak(); yyj4613++ {
- if yyj4608 >= len(yyv4608) {
- yyv4608 = append(yyv4608, NodeSelectorTerm{}) // var yyz4608 NodeSelectorTerm
- yyc4608 = true
+ if yyj4613 >= len(yyv4613) {
+ yyv4613 = append(yyv4613, NodeSelectorTerm{}) // var yyz4613 NodeSelectorTerm
+ yyc4613 = true
}
- yyh4608.ElemContainerState(yyj4608)
- if yyj4608 < len(yyv4608) {
+ yyh4613.ElemContainerState(yyj4613)
+ if yyj4613 < len(yyv4613) {
if r.TryDecodeAsNil() {
- yyv4608[yyj4608] = NodeSelectorTerm{}
+ yyv4613[yyj4613] = NodeSelectorTerm{}
} else {
- yyv4611 := &yyv4608[yyj4608]
- yyv4611.CodecDecodeSelf(d)
+ yyv4616 := &yyv4613[yyj4613]
+ yyv4616.CodecDecodeSelf(d)
}
} else {
@@ -57947,17 +58011,17 @@ func (x codecSelfer1234) decSliceNodeSelectorTerm(v *[]NodeSelectorTerm, d *code
}
}
- if yyj4608 < len(yyv4608) {
- yyv4608 = yyv4608[:yyj4608]
- yyc4608 = true
- } else if yyj4608 == 0 && yyv4608 == nil {
- yyv4608 = []NodeSelectorTerm{}
- yyc4608 = true
+ if yyj4613 < len(yyv4613) {
+ yyv4613 = yyv4613[:yyj4613]
+ yyc4613 = true
+ } else if yyj4613 == 0 && yyv4613 == nil {
+ yyv4613 = []NodeSelectorTerm{}
+ yyc4613 = true
}
}
- yyh4608.End()
- if yyc4608 {
- *v = yyv4608
+ yyh4613.End()
+ if yyc4613 {
+ *v = yyv4613
}
}
@@ -57966,10 +58030,10 @@ func (x codecSelfer1234) encSliceNodeSelectorRequirement(v []NodeSelectorRequire
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
r.EncodeArrayStart(len(v))
- for _, yyv4612 := range v {
+ for _, yyv4617 := range v {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy4613 := &yyv4612
- yy4613.CodecEncodeSelf(e)
+ yy4618 := &yyv4617
+ yy4618.CodecEncodeSelf(e)
}
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -57979,83 +58043,83 @@ func (x codecSelfer1234) decSliceNodeSelectorRequirement(v *[]NodeSelectorRequir
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yyv4614 := *v
- yyh4614, yyl4614 := z.DecSliceHelperStart()
- var yyc4614 bool
- if yyl4614 == 0 {
- if yyv4614 == nil {
- yyv4614 = []NodeSelectorRequirement{}
- yyc4614 = true
- } else if len(yyv4614) != 0 {
- yyv4614 = yyv4614[:0]
- yyc4614 = true
+ yyv4619 := *v
+ yyh4619, yyl4619 := z.DecSliceHelperStart()
+ var yyc4619 bool
+ if yyl4619 == 0 {
+ if yyv4619 == nil {
+ yyv4619 = []NodeSelectorRequirement{}
+ yyc4619 = true
+ } else if len(yyv4619) != 0 {
+ yyv4619 = yyv4619[:0]
+ yyc4619 = true
}
- } else if yyl4614 > 0 {
- var yyrr4614, yyrl4614 int
- var yyrt4614 bool
- if yyl4614 > cap(yyv4614) {
+ } else if yyl4619 > 0 {
+ var yyrr4619, yyrl4619 int
+ var yyrt4619 bool
+ if yyl4619 > cap(yyv4619) {
- yyrg4614 := len(yyv4614) > 0
- yyv24614 := yyv4614
- yyrl4614, yyrt4614 = z.DecInferLen(yyl4614, z.DecBasicHandle().MaxInitLen, 56)
- if yyrt4614 {
- if yyrl4614 <= cap(yyv4614) {
- yyv4614 = yyv4614[:yyrl4614]
+ yyrg4619 := len(yyv4619) > 0
+ yyv24619 := yyv4619
+ yyrl4619, yyrt4619 = z.DecInferLen(yyl4619, z.DecBasicHandle().MaxInitLen, 56)
+ if yyrt4619 {
+ if yyrl4619 <= cap(yyv4619) {
+ yyv4619 = yyv4619[:yyrl4619]
} else {
- yyv4614 = make([]NodeSelectorRequirement, yyrl4614)
+ yyv4619 = make([]NodeSelectorRequirement, yyrl4619)
}
} else {
- yyv4614 = make([]NodeSelectorRequirement, yyrl4614)
+ yyv4619 = make([]NodeSelectorRequirement, yyrl4619)
}
- yyc4614 = true
- yyrr4614 = len(yyv4614)
- if yyrg4614 {
- copy(yyv4614, yyv24614)
+ yyc4619 = true
+ yyrr4619 = len(yyv4619)
+ if yyrg4619 {
+ copy(yyv4619, yyv24619)
}
- } else if yyl4614 != len(yyv4614) {
- yyv4614 = yyv4614[:yyl4614]
- yyc4614 = true
+ } else if yyl4619 != len(yyv4619) {
+ yyv4619 = yyv4619[:yyl4619]
+ yyc4619 = true
}
- yyj4614 := 0
- for ; yyj4614 < yyrr4614; yyj4614++ {
- yyh4614.ElemContainerState(yyj4614)
+ yyj4619 := 0
+ for ; yyj4619 < yyrr4619; yyj4619++ {
+ yyh4619.ElemContainerState(yyj4619)
if r.TryDecodeAsNil() {
- yyv4614[yyj4614] = NodeSelectorRequirement{}
+ yyv4619[yyj4619] = NodeSelectorRequirement{}
} else {
- yyv4615 := &yyv4614[yyj4614]
- yyv4615.CodecDecodeSelf(d)
+ yyv4620 := &yyv4619[yyj4619]
+ yyv4620.CodecDecodeSelf(d)
}
}
- if yyrt4614 {
- for ; yyj4614 < yyl4614; yyj4614++ {
- yyv4614 = append(yyv4614, NodeSelectorRequirement{})
- yyh4614.ElemContainerState(yyj4614)
+ if yyrt4619 {
+ for ; yyj4619 < yyl4619; yyj4619++ {
+ yyv4619 = append(yyv4619, NodeSelectorRequirement{})
+ yyh4619.ElemContainerState(yyj4619)
if r.TryDecodeAsNil() {
- yyv4614[yyj4614] = NodeSelectorRequirement{}
+ yyv4619[yyj4619] = NodeSelectorRequirement{}
} else {
- yyv4616 := &yyv4614[yyj4614]
- yyv4616.CodecDecodeSelf(d)
+ yyv4621 := &yyv4619[yyj4619]
+ yyv4621.CodecDecodeSelf(d)
}
}
}
} else {
- yyj4614 := 0
- for ; !r.CheckBreak(); yyj4614++ {
+ yyj4619 := 0
+ for ; !r.CheckBreak(); yyj4619++ {
- if yyj4614 >= len(yyv4614) {
- yyv4614 = append(yyv4614, NodeSelectorRequirement{}) // var yyz4614 NodeSelectorRequirement
- yyc4614 = true
+ if yyj4619 >= len(yyv4619) {
+ yyv4619 = append(yyv4619, NodeSelectorRequirement{}) // var yyz4619 NodeSelectorRequirement
+ yyc4619 = true
}
- yyh4614.ElemContainerState(yyj4614)
- if yyj4614 < len(yyv4614) {
+ yyh4619.ElemContainerState(yyj4619)
+ if yyj4619 < len(yyv4619) {
if r.TryDecodeAsNil() {
- yyv4614[yyj4614] = NodeSelectorRequirement{}
+ yyv4619[yyj4619] = NodeSelectorRequirement{}
} else {
- yyv4617 := &yyv4614[yyj4614]
- yyv4617.CodecDecodeSelf(d)
+ yyv4622 := &yyv4619[yyj4619]
+ yyv4622.CodecDecodeSelf(d)
}
} else {
@@ -58063,17 +58127,17 @@ func (x codecSelfer1234) decSliceNodeSelectorRequirement(v *[]NodeSelectorRequir
}
}
- if yyj4614 < len(yyv4614) {
- yyv4614 = yyv4614[:yyj4614]
- yyc4614 = true
- } else if yyj4614 == 0 && yyv4614 == nil {
- yyv4614 = []NodeSelectorRequirement{}
- yyc4614 = true
+ if yyj4619 < len(yyv4619) {
+ yyv4619 = yyv4619[:yyj4619]
+ yyc4619 = true
+ } else if yyj4619 == 0 && yyv4619 == nil {
+ yyv4619 = []NodeSelectorRequirement{}
+ yyc4619 = true
}
}
- yyh4614.End()
- if yyc4614 {
- *v = yyv4614
+ yyh4619.End()
+ if yyc4619 {
+ *v = yyv4619
}
}
@@ -58082,10 +58146,10 @@ func (x codecSelfer1234) encSlicePodAffinityTerm(v []PodAffinityTerm, e *codec19
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
r.EncodeArrayStart(len(v))
- for _, yyv4618 := range v {
+ for _, yyv4623 := range v {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy4619 := &yyv4618
- yy4619.CodecEncodeSelf(e)
+ yy4624 := &yyv4623
+ yy4624.CodecEncodeSelf(e)
}
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -58095,83 +58159,83 @@ func (x codecSelfer1234) decSlicePodAffinityTerm(v *[]PodAffinityTerm, d *codec1
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yyv4620 := *v
- yyh4620, yyl4620 := z.DecSliceHelperStart()
- var yyc4620 bool
- if yyl4620 == 0 {
- if yyv4620 == nil {
- yyv4620 = []PodAffinityTerm{}
- yyc4620 = true
- } else if len(yyv4620) != 0 {
- yyv4620 = yyv4620[:0]
- yyc4620 = true
+ yyv4625 := *v
+ yyh4625, yyl4625 := z.DecSliceHelperStart()
+ var yyc4625 bool
+ if yyl4625 == 0 {
+ if yyv4625 == nil {
+ yyv4625 = []PodAffinityTerm{}
+ yyc4625 = true
+ } else if len(yyv4625) != 0 {
+ yyv4625 = yyv4625[:0]
+ yyc4625 = true
}
- } else if yyl4620 > 0 {
- var yyrr4620, yyrl4620 int
- var yyrt4620 bool
- if yyl4620 > cap(yyv4620) {
+ } else if yyl4625 > 0 {
+ var yyrr4625, yyrl4625 int
+ var yyrt4625 bool
+ if yyl4625 > cap(yyv4625) {
- yyrg4620 := len(yyv4620) > 0
- yyv24620 := yyv4620
- yyrl4620, yyrt4620 = z.DecInferLen(yyl4620, z.DecBasicHandle().MaxInitLen, 48)
- if yyrt4620 {
- if yyrl4620 <= cap(yyv4620) {
- yyv4620 = yyv4620[:yyrl4620]
+ yyrg4625 := len(yyv4625) > 0
+ yyv24625 := yyv4625
+ yyrl4625, yyrt4625 = z.DecInferLen(yyl4625, z.DecBasicHandle().MaxInitLen, 48)
+ if yyrt4625 {
+ if yyrl4625 <= cap(yyv4625) {
+ yyv4625 = yyv4625[:yyrl4625]
} else {
- yyv4620 = make([]PodAffinityTerm, yyrl4620)
+ yyv4625 = make([]PodAffinityTerm, yyrl4625)
}
} else {
- yyv4620 = make([]PodAffinityTerm, yyrl4620)
+ yyv4625 = make([]PodAffinityTerm, yyrl4625)
}
- yyc4620 = true
- yyrr4620 = len(yyv4620)
- if yyrg4620 {
- copy(yyv4620, yyv24620)
+ yyc4625 = true
+ yyrr4625 = len(yyv4625)
+ if yyrg4625 {
+ copy(yyv4625, yyv24625)
}
- } else if yyl4620 != len(yyv4620) {
- yyv4620 = yyv4620[:yyl4620]
- yyc4620 = true
+ } else if yyl4625 != len(yyv4625) {
+ yyv4625 = yyv4625[:yyl4625]
+ yyc4625 = true
}
- yyj4620 := 0
- for ; yyj4620 < yyrr4620; yyj4620++ {
- yyh4620.ElemContainerState(yyj4620)
+ yyj4625 := 0
+ for ; yyj4625 < yyrr4625; yyj4625++ {
+ yyh4625.ElemContainerState(yyj4625)
if r.TryDecodeAsNil() {
- yyv4620[yyj4620] = PodAffinityTerm{}
+ yyv4625[yyj4625] = PodAffinityTerm{}
} else {
- yyv4621 := &yyv4620[yyj4620]
- yyv4621.CodecDecodeSelf(d)
+ yyv4626 := &yyv4625[yyj4625]
+ yyv4626.CodecDecodeSelf(d)
}
}
- if yyrt4620 {
- for ; yyj4620 < yyl4620; yyj4620++ {
- yyv4620 = append(yyv4620, PodAffinityTerm{})
- yyh4620.ElemContainerState(yyj4620)
+ if yyrt4625 {
+ for ; yyj4625 < yyl4625; yyj4625++ {
+ yyv4625 = append(yyv4625, PodAffinityTerm{})
+ yyh4625.ElemContainerState(yyj4625)
if r.TryDecodeAsNil() {
- yyv4620[yyj4620] = PodAffinityTerm{}
+ yyv4625[yyj4625] = PodAffinityTerm{}
} else {
- yyv4622 := &yyv4620[yyj4620]
- yyv4622.CodecDecodeSelf(d)
+ yyv4627 := &yyv4625[yyj4625]
+ yyv4627.CodecDecodeSelf(d)
}
}
}
} else {
- yyj4620 := 0
- for ; !r.CheckBreak(); yyj4620++ {
+ yyj4625 := 0
+ for ; !r.CheckBreak(); yyj4625++ {
- if yyj4620 >= len(yyv4620) {
- yyv4620 = append(yyv4620, PodAffinityTerm{}) // var yyz4620 PodAffinityTerm
- yyc4620 = true
+ if yyj4625 >= len(yyv4625) {
+ yyv4625 = append(yyv4625, PodAffinityTerm{}) // var yyz4625 PodAffinityTerm
+ yyc4625 = true
}
- yyh4620.ElemContainerState(yyj4620)
- if yyj4620 < len(yyv4620) {
+ yyh4625.ElemContainerState(yyj4625)
+ if yyj4625 < len(yyv4625) {
if r.TryDecodeAsNil() {
- yyv4620[yyj4620] = PodAffinityTerm{}
+ yyv4625[yyj4625] = PodAffinityTerm{}
} else {
- yyv4623 := &yyv4620[yyj4620]
- yyv4623.CodecDecodeSelf(d)
+ yyv4628 := &yyv4625[yyj4625]
+ yyv4628.CodecDecodeSelf(d)
}
} else {
@@ -58179,17 +58243,17 @@ func (x codecSelfer1234) decSlicePodAffinityTerm(v *[]PodAffinityTerm, d *codec1
}
}
- if yyj4620 < len(yyv4620) {
- yyv4620 = yyv4620[:yyj4620]
- yyc4620 = true
- } else if yyj4620 == 0 && yyv4620 == nil {
- yyv4620 = []PodAffinityTerm{}
- yyc4620 = true
+ if yyj4625 < len(yyv4625) {
+ yyv4625 = yyv4625[:yyj4625]
+ yyc4625 = true
+ } else if yyj4625 == 0 && yyv4625 == nil {
+ yyv4625 = []PodAffinityTerm{}
+ yyc4625 = true
}
}
- yyh4620.End()
- if yyc4620 {
- *v = yyv4620
+ yyh4625.End()
+ if yyc4625 {
+ *v = yyv4625
}
}
@@ -58198,10 +58262,10 @@ func (x codecSelfer1234) encSliceWeightedPodAffinityTerm(v []WeightedPodAffinity
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
r.EncodeArrayStart(len(v))
- for _, yyv4624 := range v {
+ for _, yyv4629 := range v {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy4625 := &yyv4624
- yy4625.CodecEncodeSelf(e)
+ yy4630 := &yyv4629
+ yy4630.CodecEncodeSelf(e)
}
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -58211,83 +58275,83 @@ func (x codecSelfer1234) decSliceWeightedPodAffinityTerm(v *[]WeightedPodAffinit
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yyv4626 := *v
- yyh4626, yyl4626 := z.DecSliceHelperStart()
- var yyc4626 bool
- if yyl4626 == 0 {
- if yyv4626 == nil {
- yyv4626 = []WeightedPodAffinityTerm{}
- yyc4626 = true
- } else if len(yyv4626) != 0 {
- yyv4626 = yyv4626[:0]
- yyc4626 = true
+ yyv4631 := *v
+ yyh4631, yyl4631 := z.DecSliceHelperStart()
+ var yyc4631 bool
+ if yyl4631 == 0 {
+ if yyv4631 == nil {
+ yyv4631 = []WeightedPodAffinityTerm{}
+ yyc4631 = true
+ } else if len(yyv4631) != 0 {
+ yyv4631 = yyv4631[:0]
+ yyc4631 = true
}
- } else if yyl4626 > 0 {
- var yyrr4626, yyrl4626 int
- var yyrt4626 bool
- if yyl4626 > cap(yyv4626) {
+ } else if yyl4631 > 0 {
+ var yyrr4631, yyrl4631 int
+ var yyrt4631 bool
+ if yyl4631 > cap(yyv4631) {
- yyrg4626 := len(yyv4626) > 0
- yyv24626 := yyv4626
- yyrl4626, yyrt4626 = z.DecInferLen(yyl4626, z.DecBasicHandle().MaxInitLen, 56)
- if yyrt4626 {
- if yyrl4626 <= cap(yyv4626) {
- yyv4626 = yyv4626[:yyrl4626]
+ yyrg4631 := len(yyv4631) > 0
+ yyv24631 := yyv4631
+ yyrl4631, yyrt4631 = z.DecInferLen(yyl4631, z.DecBasicHandle().MaxInitLen, 56)
+ if yyrt4631 {
+ if yyrl4631 <= cap(yyv4631) {
+ yyv4631 = yyv4631[:yyrl4631]
} else {
- yyv4626 = make([]WeightedPodAffinityTerm, yyrl4626)
+ yyv4631 = make([]WeightedPodAffinityTerm, yyrl4631)
}
} else {
- yyv4626 = make([]WeightedPodAffinityTerm, yyrl4626)
+ yyv4631 = make([]WeightedPodAffinityTerm, yyrl4631)
}
- yyc4626 = true
- yyrr4626 = len(yyv4626)
- if yyrg4626 {
- copy(yyv4626, yyv24626)
+ yyc4631 = true
+ yyrr4631 = len(yyv4631)
+ if yyrg4631 {
+ copy(yyv4631, yyv24631)
}
- } else if yyl4626 != len(yyv4626) {
- yyv4626 = yyv4626[:yyl4626]
- yyc4626 = true
+ } else if yyl4631 != len(yyv4631) {
+ yyv4631 = yyv4631[:yyl4631]
+ yyc4631 = true
}
- yyj4626 := 0
- for ; yyj4626 < yyrr4626; yyj4626++ {
- yyh4626.ElemContainerState(yyj4626)
+ yyj4631 := 0
+ for ; yyj4631 < yyrr4631; yyj4631++ {
+ yyh4631.ElemContainerState(yyj4631)
if r.TryDecodeAsNil() {
- yyv4626[yyj4626] = WeightedPodAffinityTerm{}
+ yyv4631[yyj4631] = WeightedPodAffinityTerm{}
} else {
- yyv4627 := &yyv4626[yyj4626]
- yyv4627.CodecDecodeSelf(d)
+ yyv4632 := &yyv4631[yyj4631]
+ yyv4632.CodecDecodeSelf(d)
}
}
- if yyrt4626 {
- for ; yyj4626 < yyl4626; yyj4626++ {
- yyv4626 = append(yyv4626, WeightedPodAffinityTerm{})
- yyh4626.ElemContainerState(yyj4626)
+ if yyrt4631 {
+ for ; yyj4631 < yyl4631; yyj4631++ {
+ yyv4631 = append(yyv4631, WeightedPodAffinityTerm{})
+ yyh4631.ElemContainerState(yyj4631)
if r.TryDecodeAsNil() {
- yyv4626[yyj4626] = WeightedPodAffinityTerm{}
+ yyv4631[yyj4631] = WeightedPodAffinityTerm{}
} else {
- yyv4628 := &yyv4626[yyj4626]
- yyv4628.CodecDecodeSelf(d)
+ yyv4633 := &yyv4631[yyj4631]
+ yyv4633.CodecDecodeSelf(d)
}
}
}
} else {
- yyj4626 := 0
- for ; !r.CheckBreak(); yyj4626++ {
+ yyj4631 := 0
+ for ; !r.CheckBreak(); yyj4631++ {
- if yyj4626 >= len(yyv4626) {
- yyv4626 = append(yyv4626, WeightedPodAffinityTerm{}) // var yyz4626 WeightedPodAffinityTerm
- yyc4626 = true
+ if yyj4631 >= len(yyv4631) {
+ yyv4631 = append(yyv4631, WeightedPodAffinityTerm{}) // var yyz4631 WeightedPodAffinityTerm
+ yyc4631 = true
}
- yyh4626.ElemContainerState(yyj4626)
- if yyj4626 < len(yyv4626) {
+ yyh4631.ElemContainerState(yyj4631)
+ if yyj4631 < len(yyv4631) {
if r.TryDecodeAsNil() {
- yyv4626[yyj4626] = WeightedPodAffinityTerm{}
+ yyv4631[yyj4631] = WeightedPodAffinityTerm{}
} else {
- yyv4629 := &yyv4626[yyj4626]
- yyv4629.CodecDecodeSelf(d)
+ yyv4634 := &yyv4631[yyj4631]
+ yyv4634.CodecDecodeSelf(d)
}
} else {
@@ -58295,17 +58359,17 @@ func (x codecSelfer1234) decSliceWeightedPodAffinityTerm(v *[]WeightedPodAffinit
}
}
- if yyj4626 < len(yyv4626) {
- yyv4626 = yyv4626[:yyj4626]
- yyc4626 = true
- } else if yyj4626 == 0 && yyv4626 == nil {
- yyv4626 = []WeightedPodAffinityTerm{}
- yyc4626 = true
+ if yyj4631 < len(yyv4631) {
+ yyv4631 = yyv4631[:yyj4631]
+ yyc4631 = true
+ } else if yyj4631 == 0 && yyv4631 == nil {
+ yyv4631 = []WeightedPodAffinityTerm{}
+ yyc4631 = true
}
}
- yyh4626.End()
- if yyc4626 {
- *v = yyv4626
+ yyh4631.End()
+ if yyc4631 {
+ *v = yyv4631
}
}
@@ -58314,10 +58378,10 @@ func (x codecSelfer1234) encSlicePreferredSchedulingTerm(v []PreferredScheduling
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
r.EncodeArrayStart(len(v))
- for _, yyv4630 := range v {
+ for _, yyv4635 := range v {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy4631 := &yyv4630
- yy4631.CodecEncodeSelf(e)
+ yy4636 := &yyv4635
+ yy4636.CodecEncodeSelf(e)
}
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -58327,83 +58391,83 @@ func (x codecSelfer1234) decSlicePreferredSchedulingTerm(v *[]PreferredSchedulin
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yyv4632 := *v
- yyh4632, yyl4632 := z.DecSliceHelperStart()
- var yyc4632 bool
- if yyl4632 == 0 {
- if yyv4632 == nil {
- yyv4632 = []PreferredSchedulingTerm{}
- yyc4632 = true
- } else if len(yyv4632) != 0 {
- yyv4632 = yyv4632[:0]
- yyc4632 = true
+ yyv4637 := *v
+ yyh4637, yyl4637 := z.DecSliceHelperStart()
+ var yyc4637 bool
+ if yyl4637 == 0 {
+ if yyv4637 == nil {
+ yyv4637 = []PreferredSchedulingTerm{}
+ yyc4637 = true
+ } else if len(yyv4637) != 0 {
+ yyv4637 = yyv4637[:0]
+ yyc4637 = true
}
- } else if yyl4632 > 0 {
- var yyrr4632, yyrl4632 int
- var yyrt4632 bool
- if yyl4632 > cap(yyv4632) {
+ } else if yyl4637 > 0 {
+ var yyrr4637, yyrl4637 int
+ var yyrt4637 bool
+ if yyl4637 > cap(yyv4637) {
- yyrg4632 := len(yyv4632) > 0
- yyv24632 := yyv4632
- yyrl4632, yyrt4632 = z.DecInferLen(yyl4632, z.DecBasicHandle().MaxInitLen, 32)
- if yyrt4632 {
- if yyrl4632 <= cap(yyv4632) {
- yyv4632 = yyv4632[:yyrl4632]
+ yyrg4637 := len(yyv4637) > 0
+ yyv24637 := yyv4637
+ yyrl4637, yyrt4637 = z.DecInferLen(yyl4637, z.DecBasicHandle().MaxInitLen, 32)
+ if yyrt4637 {
+ if yyrl4637 <= cap(yyv4637) {
+ yyv4637 = yyv4637[:yyrl4637]
} else {
- yyv4632 = make([]PreferredSchedulingTerm, yyrl4632)
+ yyv4637 = make([]PreferredSchedulingTerm, yyrl4637)
}
} else {
- yyv4632 = make([]PreferredSchedulingTerm, yyrl4632)
+ yyv4637 = make([]PreferredSchedulingTerm, yyrl4637)
}
- yyc4632 = true
- yyrr4632 = len(yyv4632)
- if yyrg4632 {
- copy(yyv4632, yyv24632)
+ yyc4637 = true
+ yyrr4637 = len(yyv4637)
+ if yyrg4637 {
+ copy(yyv4637, yyv24637)
}
- } else if yyl4632 != len(yyv4632) {
- yyv4632 = yyv4632[:yyl4632]
- yyc4632 = true
+ } else if yyl4637 != len(yyv4637) {
+ yyv4637 = yyv4637[:yyl4637]
+ yyc4637 = true
}
- yyj4632 := 0
- for ; yyj4632 < yyrr4632; yyj4632++ {
- yyh4632.ElemContainerState(yyj4632)
+ yyj4637 := 0
+ for ; yyj4637 < yyrr4637; yyj4637++ {
+ yyh4637.ElemContainerState(yyj4637)
if r.TryDecodeAsNil() {
- yyv4632[yyj4632] = PreferredSchedulingTerm{}
+ yyv4637[yyj4637] = PreferredSchedulingTerm{}
} else {
- yyv4633 := &yyv4632[yyj4632]
- yyv4633.CodecDecodeSelf(d)
+ yyv4638 := &yyv4637[yyj4637]
+ yyv4638.CodecDecodeSelf(d)
}
}
- if yyrt4632 {
- for ; yyj4632 < yyl4632; yyj4632++ {
- yyv4632 = append(yyv4632, PreferredSchedulingTerm{})
- yyh4632.ElemContainerState(yyj4632)
+ if yyrt4637 {
+ for ; yyj4637 < yyl4637; yyj4637++ {
+ yyv4637 = append(yyv4637, PreferredSchedulingTerm{})
+ yyh4637.ElemContainerState(yyj4637)
if r.TryDecodeAsNil() {
- yyv4632[yyj4632] = PreferredSchedulingTerm{}
+ yyv4637[yyj4637] = PreferredSchedulingTerm{}
} else {
- yyv4634 := &yyv4632[yyj4632]
- yyv4634.CodecDecodeSelf(d)
+ yyv4639 := &yyv4637[yyj4637]
+ yyv4639.CodecDecodeSelf(d)
}
}
}
} else {
- yyj4632 := 0
- for ; !r.CheckBreak(); yyj4632++ {
+ yyj4637 := 0
+ for ; !r.CheckBreak(); yyj4637++ {
- if yyj4632 >= len(yyv4632) {
- yyv4632 = append(yyv4632, PreferredSchedulingTerm{}) // var yyz4632 PreferredSchedulingTerm
- yyc4632 = true
+ if yyj4637 >= len(yyv4637) {
+ yyv4637 = append(yyv4637, PreferredSchedulingTerm{}) // var yyz4637 PreferredSchedulingTerm
+ yyc4637 = true
}
- yyh4632.ElemContainerState(yyj4632)
- if yyj4632 < len(yyv4632) {
+ yyh4637.ElemContainerState(yyj4637)
+ if yyj4637 < len(yyv4637) {
if r.TryDecodeAsNil() {
- yyv4632[yyj4632] = PreferredSchedulingTerm{}
+ yyv4637[yyj4637] = PreferredSchedulingTerm{}
} else {
- yyv4635 := &yyv4632[yyj4632]
- yyv4635.CodecDecodeSelf(d)
+ yyv4640 := &yyv4637[yyj4637]
+ yyv4640.CodecDecodeSelf(d)
}
} else {
@@ -58411,17 +58475,17 @@ func (x codecSelfer1234) decSlicePreferredSchedulingTerm(v *[]PreferredSchedulin
}
}
- if yyj4632 < len(yyv4632) {
- yyv4632 = yyv4632[:yyj4632]
- yyc4632 = true
- } else if yyj4632 == 0 && yyv4632 == nil {
- yyv4632 = []PreferredSchedulingTerm{}
- yyc4632 = true
+ if yyj4637 < len(yyv4637) {
+ yyv4637 = yyv4637[:yyj4637]
+ yyc4637 = true
+ } else if yyj4637 == 0 && yyv4637 == nil {
+ yyv4637 = []PreferredSchedulingTerm{}
+ yyc4637 = true
}
}
- yyh4632.End()
- if yyc4632 {
- *v = yyv4632
+ yyh4637.End()
+ if yyc4637 {
+ *v = yyv4637
}
}
@@ -58430,10 +58494,10 @@ func (x codecSelfer1234) encSliceVolume(v []Volume, e *codec1978.Encoder) {
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
r.EncodeArrayStart(len(v))
- for _, yyv4636 := range v {
+ for _, yyv4641 := range v {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy4637 := &yyv4636
- yy4637.CodecEncodeSelf(e)
+ yy4642 := &yyv4641
+ yy4642.CodecEncodeSelf(e)
}
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -58443,83 +58507,83 @@ func (x codecSelfer1234) decSliceVolume(v *[]Volume, d *codec1978.Decoder) {
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yyv4638 := *v
- yyh4638, yyl4638 := z.DecSliceHelperStart()
- var yyc4638 bool
- if yyl4638 == 0 {
- if yyv4638 == nil {
- yyv4638 = []Volume{}
- yyc4638 = true
- } else if len(yyv4638) != 0 {
- yyv4638 = yyv4638[:0]
- yyc4638 = true
+ yyv4643 := *v
+ yyh4643, yyl4643 := z.DecSliceHelperStart()
+ var yyc4643 bool
+ if yyl4643 == 0 {
+ if yyv4643 == nil {
+ yyv4643 = []Volume{}
+ yyc4643 = true
+ } else if len(yyv4643) != 0 {
+ yyv4643 = yyv4643[:0]
+ yyc4643 = true
}
- } else if yyl4638 > 0 {
- var yyrr4638, yyrl4638 int
- var yyrt4638 bool
- if yyl4638 > cap(yyv4638) {
+ } else if yyl4643 > 0 {
+ var yyrr4643, yyrl4643 int
+ var yyrt4643 bool
+ if yyl4643 > cap(yyv4643) {
- yyrg4638 := len(yyv4638) > 0
- yyv24638 := yyv4638
- yyrl4638, yyrt4638 = z.DecInferLen(yyl4638, z.DecBasicHandle().MaxInitLen, 200)
- if yyrt4638 {
- if yyrl4638 <= cap(yyv4638) {
- yyv4638 = yyv4638[:yyrl4638]
+ yyrg4643 := len(yyv4643) > 0
+ yyv24643 := yyv4643
+ yyrl4643, yyrt4643 = z.DecInferLen(yyl4643, z.DecBasicHandle().MaxInitLen, 200)
+ if yyrt4643 {
+ if yyrl4643 <= cap(yyv4643) {
+ yyv4643 = yyv4643[:yyrl4643]
} else {
- yyv4638 = make([]Volume, yyrl4638)
+ yyv4643 = make([]Volume, yyrl4643)
}
} else {
- yyv4638 = make([]Volume, yyrl4638)
+ yyv4643 = make([]Volume, yyrl4643)
}
- yyc4638 = true
- yyrr4638 = len(yyv4638)
- if yyrg4638 {
- copy(yyv4638, yyv24638)
+ yyc4643 = true
+ yyrr4643 = len(yyv4643)
+ if yyrg4643 {
+ copy(yyv4643, yyv24643)
}
- } else if yyl4638 != len(yyv4638) {
- yyv4638 = yyv4638[:yyl4638]
- yyc4638 = true
+ } else if yyl4643 != len(yyv4643) {
+ yyv4643 = yyv4643[:yyl4643]
+ yyc4643 = true
}
- yyj4638 := 0
- for ; yyj4638 < yyrr4638; yyj4638++ {
- yyh4638.ElemContainerState(yyj4638)
+ yyj4643 := 0
+ for ; yyj4643 < yyrr4643; yyj4643++ {
+ yyh4643.ElemContainerState(yyj4643)
if r.TryDecodeAsNil() {
- yyv4638[yyj4638] = Volume{}
+ yyv4643[yyj4643] = Volume{}
} else {
- yyv4639 := &yyv4638[yyj4638]
- yyv4639.CodecDecodeSelf(d)
+ yyv4644 := &yyv4643[yyj4643]
+ yyv4644.CodecDecodeSelf(d)
}
}
- if yyrt4638 {
- for ; yyj4638 < yyl4638; yyj4638++ {
- yyv4638 = append(yyv4638, Volume{})
- yyh4638.ElemContainerState(yyj4638)
+ if yyrt4643 {
+ for ; yyj4643 < yyl4643; yyj4643++ {
+ yyv4643 = append(yyv4643, Volume{})
+ yyh4643.ElemContainerState(yyj4643)
if r.TryDecodeAsNil() {
- yyv4638[yyj4638] = Volume{}
+ yyv4643[yyj4643] = Volume{}
} else {
- yyv4640 := &yyv4638[yyj4638]
- yyv4640.CodecDecodeSelf(d)
+ yyv4645 := &yyv4643[yyj4643]
+ yyv4645.CodecDecodeSelf(d)
}
}
}
} else {
- yyj4638 := 0
- for ; !r.CheckBreak(); yyj4638++ {
+ yyj4643 := 0
+ for ; !r.CheckBreak(); yyj4643++ {
- if yyj4638 >= len(yyv4638) {
- yyv4638 = append(yyv4638, Volume{}) // var yyz4638 Volume
- yyc4638 = true
+ if yyj4643 >= len(yyv4643) {
+ yyv4643 = append(yyv4643, Volume{}) // var yyz4643 Volume
+ yyc4643 = true
}
- yyh4638.ElemContainerState(yyj4638)
- if yyj4638 < len(yyv4638) {
+ yyh4643.ElemContainerState(yyj4643)
+ if yyj4643 < len(yyv4643) {
if r.TryDecodeAsNil() {
- yyv4638[yyj4638] = Volume{}
+ yyv4643[yyj4643] = Volume{}
} else {
- yyv4641 := &yyv4638[yyj4638]
- yyv4641.CodecDecodeSelf(d)
+ yyv4646 := &yyv4643[yyj4643]
+ yyv4646.CodecDecodeSelf(d)
}
} else {
@@ -58527,17 +58591,17 @@ func (x codecSelfer1234) decSliceVolume(v *[]Volume, d *codec1978.Decoder) {
}
}
- if yyj4638 < len(yyv4638) {
- yyv4638 = yyv4638[:yyj4638]
- yyc4638 = true
- } else if yyj4638 == 0 && yyv4638 == nil {
- yyv4638 = []Volume{}
- yyc4638 = true
+ if yyj4643 < len(yyv4643) {
+ yyv4643 = yyv4643[:yyj4643]
+ yyc4643 = true
+ } else if yyj4643 == 0 && yyv4643 == nil {
+ yyv4643 = []Volume{}
+ yyc4643 = true
}
}
- yyh4638.End()
- if yyc4638 {
- *v = yyv4638
+ yyh4643.End()
+ if yyc4643 {
+ *v = yyv4643
}
}
@@ -58546,10 +58610,10 @@ func (x codecSelfer1234) encSliceContainer(v []Container, e *codec1978.Encoder)
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
r.EncodeArrayStart(len(v))
- for _, yyv4642 := range v {
+ for _, yyv4647 := range v {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy4643 := &yyv4642
- yy4643.CodecEncodeSelf(e)
+ yy4648 := &yyv4647
+ yy4648.CodecEncodeSelf(e)
}
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -58559,83 +58623,83 @@ func (x codecSelfer1234) decSliceContainer(v *[]Container, d *codec1978.Decoder)
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yyv4644 := *v
- yyh4644, yyl4644 := z.DecSliceHelperStart()
- var yyc4644 bool
- if yyl4644 == 0 {
- if yyv4644 == nil {
- yyv4644 = []Container{}
- yyc4644 = true
- } else if len(yyv4644) != 0 {
- yyv4644 = yyv4644[:0]
- yyc4644 = true
+ yyv4649 := *v
+ yyh4649, yyl4649 := z.DecSliceHelperStart()
+ var yyc4649 bool
+ if yyl4649 == 0 {
+ if yyv4649 == nil {
+ yyv4649 = []Container{}
+ yyc4649 = true
+ } else if len(yyv4649) != 0 {
+ yyv4649 = yyv4649[:0]
+ yyc4649 = true
}
- } else if yyl4644 > 0 {
- var yyrr4644, yyrl4644 int
- var yyrt4644 bool
- if yyl4644 > cap(yyv4644) {
+ } else if yyl4649 > 0 {
+ var yyrr4649, yyrl4649 int
+ var yyrt4649 bool
+ if yyl4649 > cap(yyv4649) {
- yyrg4644 := len(yyv4644) > 0
- yyv24644 := yyv4644
- yyrl4644, yyrt4644 = z.DecInferLen(yyl4644, z.DecBasicHandle().MaxInitLen, 256)
- if yyrt4644 {
- if yyrl4644 <= cap(yyv4644) {
- yyv4644 = yyv4644[:yyrl4644]
+ yyrg4649 := len(yyv4649) > 0
+ yyv24649 := yyv4649
+ yyrl4649, yyrt4649 = z.DecInferLen(yyl4649, z.DecBasicHandle().MaxInitLen, 256)
+ if yyrt4649 {
+ if yyrl4649 <= cap(yyv4649) {
+ yyv4649 = yyv4649[:yyrl4649]
} else {
- yyv4644 = make([]Container, yyrl4644)
+ yyv4649 = make([]Container, yyrl4649)
}
} else {
- yyv4644 = make([]Container, yyrl4644)
+ yyv4649 = make([]Container, yyrl4649)
}
- yyc4644 = true
- yyrr4644 = len(yyv4644)
- if yyrg4644 {
- copy(yyv4644, yyv24644)
+ yyc4649 = true
+ yyrr4649 = len(yyv4649)
+ if yyrg4649 {
+ copy(yyv4649, yyv24649)
}
- } else if yyl4644 != len(yyv4644) {
- yyv4644 = yyv4644[:yyl4644]
- yyc4644 = true
+ } else if yyl4649 != len(yyv4649) {
+ yyv4649 = yyv4649[:yyl4649]
+ yyc4649 = true
}
- yyj4644 := 0
- for ; yyj4644 < yyrr4644; yyj4644++ {
- yyh4644.ElemContainerState(yyj4644)
+ yyj4649 := 0
+ for ; yyj4649 < yyrr4649; yyj4649++ {
+ yyh4649.ElemContainerState(yyj4649)
if r.TryDecodeAsNil() {
- yyv4644[yyj4644] = Container{}
+ yyv4649[yyj4649] = Container{}
} else {
- yyv4645 := &yyv4644[yyj4644]
- yyv4645.CodecDecodeSelf(d)
+ yyv4650 := &yyv4649[yyj4649]
+ yyv4650.CodecDecodeSelf(d)
}
}
- if yyrt4644 {
- for ; yyj4644 < yyl4644; yyj4644++ {
- yyv4644 = append(yyv4644, Container{})
- yyh4644.ElemContainerState(yyj4644)
+ if yyrt4649 {
+ for ; yyj4649 < yyl4649; yyj4649++ {
+ yyv4649 = append(yyv4649, Container{})
+ yyh4649.ElemContainerState(yyj4649)
if r.TryDecodeAsNil() {
- yyv4644[yyj4644] = Container{}
+ yyv4649[yyj4649] = Container{}
} else {
- yyv4646 := &yyv4644[yyj4644]
- yyv4646.CodecDecodeSelf(d)
+ yyv4651 := &yyv4649[yyj4649]
+ yyv4651.CodecDecodeSelf(d)
}
}
}
} else {
- yyj4644 := 0
- for ; !r.CheckBreak(); yyj4644++ {
+ yyj4649 := 0
+ for ; !r.CheckBreak(); yyj4649++ {
- if yyj4644 >= len(yyv4644) {
- yyv4644 = append(yyv4644, Container{}) // var yyz4644 Container
- yyc4644 = true
+ if yyj4649 >= len(yyv4649) {
+ yyv4649 = append(yyv4649, Container{}) // var yyz4649 Container
+ yyc4649 = true
}
- yyh4644.ElemContainerState(yyj4644)
- if yyj4644 < len(yyv4644) {
+ yyh4649.ElemContainerState(yyj4649)
+ if yyj4649 < len(yyv4649) {
if r.TryDecodeAsNil() {
- yyv4644[yyj4644] = Container{}
+ yyv4649[yyj4649] = Container{}
} else {
- yyv4647 := &yyv4644[yyj4644]
- yyv4647.CodecDecodeSelf(d)
+ yyv4652 := &yyv4649[yyj4649]
+ yyv4652.CodecDecodeSelf(d)
}
} else {
@@ -58643,17 +58707,17 @@ func (x codecSelfer1234) decSliceContainer(v *[]Container, d *codec1978.Decoder)
}
}
- if yyj4644 < len(yyv4644) {
- yyv4644 = yyv4644[:yyj4644]
- yyc4644 = true
- } else if yyj4644 == 0 && yyv4644 == nil {
- yyv4644 = []Container{}
- yyc4644 = true
+ if yyj4649 < len(yyv4649) {
+ yyv4649 = yyv4649[:yyj4649]
+ yyc4649 = true
+ } else if yyj4649 == 0 && yyv4649 == nil {
+ yyv4649 = []Container{}
+ yyc4649 = true
}
}
- yyh4644.End()
- if yyc4644 {
- *v = yyv4644
+ yyh4649.End()
+ if yyc4649 {
+ *v = yyv4649
}
}
@@ -58662,10 +58726,10 @@ func (x codecSelfer1234) encSliceLocalObjectReference(v []LocalObjectReference,
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
r.EncodeArrayStart(len(v))
- for _, yyv4648 := range v {
+ for _, yyv4653 := range v {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy4649 := &yyv4648
- yy4649.CodecEncodeSelf(e)
+ yy4654 := &yyv4653
+ yy4654.CodecEncodeSelf(e)
}
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -58675,83 +58739,83 @@ func (x codecSelfer1234) decSliceLocalObjectReference(v *[]LocalObjectReference,
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yyv4650 := *v
- yyh4650, yyl4650 := z.DecSliceHelperStart()
- var yyc4650 bool
- if yyl4650 == 0 {
- if yyv4650 == nil {
- yyv4650 = []LocalObjectReference{}
- yyc4650 = true
- } else if len(yyv4650) != 0 {
- yyv4650 = yyv4650[:0]
- yyc4650 = true
+ yyv4655 := *v
+ yyh4655, yyl4655 := z.DecSliceHelperStart()
+ var yyc4655 bool
+ if yyl4655 == 0 {
+ if yyv4655 == nil {
+ yyv4655 = []LocalObjectReference{}
+ yyc4655 = true
+ } else if len(yyv4655) != 0 {
+ yyv4655 = yyv4655[:0]
+ yyc4655 = true
}
- } else if yyl4650 > 0 {
- var yyrr4650, yyrl4650 int
- var yyrt4650 bool
- if yyl4650 > cap(yyv4650) {
+ } else if yyl4655 > 0 {
+ var yyrr4655, yyrl4655 int
+ var yyrt4655 bool
+ if yyl4655 > cap(yyv4655) {
- yyrg4650 := len(yyv4650) > 0
- yyv24650 := yyv4650
- yyrl4650, yyrt4650 = z.DecInferLen(yyl4650, z.DecBasicHandle().MaxInitLen, 16)
- if yyrt4650 {
- if yyrl4650 <= cap(yyv4650) {
- yyv4650 = yyv4650[:yyrl4650]
+ yyrg4655 := len(yyv4655) > 0
+ yyv24655 := yyv4655
+ yyrl4655, yyrt4655 = z.DecInferLen(yyl4655, z.DecBasicHandle().MaxInitLen, 16)
+ if yyrt4655 {
+ if yyrl4655 <= cap(yyv4655) {
+ yyv4655 = yyv4655[:yyrl4655]
} else {
- yyv4650 = make([]LocalObjectReference, yyrl4650)
+ yyv4655 = make([]LocalObjectReference, yyrl4655)
}
} else {
- yyv4650 = make([]LocalObjectReference, yyrl4650)
+ yyv4655 = make([]LocalObjectReference, yyrl4655)
}
- yyc4650 = true
- yyrr4650 = len(yyv4650)
- if yyrg4650 {
- copy(yyv4650, yyv24650)
+ yyc4655 = true
+ yyrr4655 = len(yyv4655)
+ if yyrg4655 {
+ copy(yyv4655, yyv24655)
}
- } else if yyl4650 != len(yyv4650) {
- yyv4650 = yyv4650[:yyl4650]
- yyc4650 = true
+ } else if yyl4655 != len(yyv4655) {
+ yyv4655 = yyv4655[:yyl4655]
+ yyc4655 = true
}
- yyj4650 := 0
- for ; yyj4650 < yyrr4650; yyj4650++ {
- yyh4650.ElemContainerState(yyj4650)
+ yyj4655 := 0
+ for ; yyj4655 < yyrr4655; yyj4655++ {
+ yyh4655.ElemContainerState(yyj4655)
if r.TryDecodeAsNil() {
- yyv4650[yyj4650] = LocalObjectReference{}
+ yyv4655[yyj4655] = LocalObjectReference{}
} else {
- yyv4651 := &yyv4650[yyj4650]
- yyv4651.CodecDecodeSelf(d)
+ yyv4656 := &yyv4655[yyj4655]
+ yyv4656.CodecDecodeSelf(d)
}
}
- if yyrt4650 {
- for ; yyj4650 < yyl4650; yyj4650++ {
- yyv4650 = append(yyv4650, LocalObjectReference{})
- yyh4650.ElemContainerState(yyj4650)
+ if yyrt4655 {
+ for ; yyj4655 < yyl4655; yyj4655++ {
+ yyv4655 = append(yyv4655, LocalObjectReference{})
+ yyh4655.ElemContainerState(yyj4655)
if r.TryDecodeAsNil() {
- yyv4650[yyj4650] = LocalObjectReference{}
+ yyv4655[yyj4655] = LocalObjectReference{}
} else {
- yyv4652 := &yyv4650[yyj4650]
- yyv4652.CodecDecodeSelf(d)
+ yyv4657 := &yyv4655[yyj4655]
+ yyv4657.CodecDecodeSelf(d)
}
}
}
} else {
- yyj4650 := 0
- for ; !r.CheckBreak(); yyj4650++ {
+ yyj4655 := 0
+ for ; !r.CheckBreak(); yyj4655++ {
- if yyj4650 >= len(yyv4650) {
- yyv4650 = append(yyv4650, LocalObjectReference{}) // var yyz4650 LocalObjectReference
- yyc4650 = true
+ if yyj4655 >= len(yyv4655) {
+ yyv4655 = append(yyv4655, LocalObjectReference{}) // var yyz4655 LocalObjectReference
+ yyc4655 = true
}
- yyh4650.ElemContainerState(yyj4650)
- if yyj4650 < len(yyv4650) {
+ yyh4655.ElemContainerState(yyj4655)
+ if yyj4655 < len(yyv4655) {
if r.TryDecodeAsNil() {
- yyv4650[yyj4650] = LocalObjectReference{}
+ yyv4655[yyj4655] = LocalObjectReference{}
} else {
- yyv4653 := &yyv4650[yyj4650]
- yyv4653.CodecDecodeSelf(d)
+ yyv4658 := &yyv4655[yyj4655]
+ yyv4658.CodecDecodeSelf(d)
}
} else {
@@ -58759,17 +58823,17 @@ func (x codecSelfer1234) decSliceLocalObjectReference(v *[]LocalObjectReference,
}
}
- if yyj4650 < len(yyv4650) {
- yyv4650 = yyv4650[:yyj4650]
- yyc4650 = true
- } else if yyj4650 == 0 && yyv4650 == nil {
- yyv4650 = []LocalObjectReference{}
- yyc4650 = true
+ if yyj4655 < len(yyv4655) {
+ yyv4655 = yyv4655[:yyj4655]
+ yyc4655 = true
+ } else if yyj4655 == 0 && yyv4655 == nil {
+ yyv4655 = []LocalObjectReference{}
+ yyc4655 = true
}
}
- yyh4650.End()
- if yyc4650 {
- *v = yyv4650
+ yyh4655.End()
+ if yyc4655 {
+ *v = yyv4655
}
}
@@ -58778,10 +58842,10 @@ func (x codecSelfer1234) encSlicePodCondition(v []PodCondition, e *codec1978.Enc
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
r.EncodeArrayStart(len(v))
- for _, yyv4654 := range v {
+ for _, yyv4659 := range v {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy4655 := &yyv4654
- yy4655.CodecEncodeSelf(e)
+ yy4660 := &yyv4659
+ yy4660.CodecEncodeSelf(e)
}
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -58791,83 +58855,83 @@ func (x codecSelfer1234) decSlicePodCondition(v *[]PodCondition, d *codec1978.De
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yyv4656 := *v
- yyh4656, yyl4656 := z.DecSliceHelperStart()
- var yyc4656 bool
- if yyl4656 == 0 {
- if yyv4656 == nil {
- yyv4656 = []PodCondition{}
- yyc4656 = true
- } else if len(yyv4656) != 0 {
- yyv4656 = yyv4656[:0]
- yyc4656 = true
+ yyv4661 := *v
+ yyh4661, yyl4661 := z.DecSliceHelperStart()
+ var yyc4661 bool
+ if yyl4661 == 0 {
+ if yyv4661 == nil {
+ yyv4661 = []PodCondition{}
+ yyc4661 = true
+ } else if len(yyv4661) != 0 {
+ yyv4661 = yyv4661[:0]
+ yyc4661 = true
}
- } else if yyl4656 > 0 {
- var yyrr4656, yyrl4656 int
- var yyrt4656 bool
- if yyl4656 > cap(yyv4656) {
+ } else if yyl4661 > 0 {
+ var yyrr4661, yyrl4661 int
+ var yyrt4661 bool
+ if yyl4661 > cap(yyv4661) {
- yyrg4656 := len(yyv4656) > 0
- yyv24656 := yyv4656
- yyrl4656, yyrt4656 = z.DecInferLen(yyl4656, z.DecBasicHandle().MaxInitLen, 112)
- if yyrt4656 {
- if yyrl4656 <= cap(yyv4656) {
- yyv4656 = yyv4656[:yyrl4656]
+ yyrg4661 := len(yyv4661) > 0
+ yyv24661 := yyv4661
+ yyrl4661, yyrt4661 = z.DecInferLen(yyl4661, z.DecBasicHandle().MaxInitLen, 112)
+ if yyrt4661 {
+ if yyrl4661 <= cap(yyv4661) {
+ yyv4661 = yyv4661[:yyrl4661]
} else {
- yyv4656 = make([]PodCondition, yyrl4656)
+ yyv4661 = make([]PodCondition, yyrl4661)
}
} else {
- yyv4656 = make([]PodCondition, yyrl4656)
+ yyv4661 = make([]PodCondition, yyrl4661)
}
- yyc4656 = true
- yyrr4656 = len(yyv4656)
- if yyrg4656 {
- copy(yyv4656, yyv24656)
+ yyc4661 = true
+ yyrr4661 = len(yyv4661)
+ if yyrg4661 {
+ copy(yyv4661, yyv24661)
}
- } else if yyl4656 != len(yyv4656) {
- yyv4656 = yyv4656[:yyl4656]
- yyc4656 = true
+ } else if yyl4661 != len(yyv4661) {
+ yyv4661 = yyv4661[:yyl4661]
+ yyc4661 = true
}
- yyj4656 := 0
- for ; yyj4656 < yyrr4656; yyj4656++ {
- yyh4656.ElemContainerState(yyj4656)
+ yyj4661 := 0
+ for ; yyj4661 < yyrr4661; yyj4661++ {
+ yyh4661.ElemContainerState(yyj4661)
if r.TryDecodeAsNil() {
- yyv4656[yyj4656] = PodCondition{}
+ yyv4661[yyj4661] = PodCondition{}
} else {
- yyv4657 := &yyv4656[yyj4656]
- yyv4657.CodecDecodeSelf(d)
+ yyv4662 := &yyv4661[yyj4661]
+ yyv4662.CodecDecodeSelf(d)
}
}
- if yyrt4656 {
- for ; yyj4656 < yyl4656; yyj4656++ {
- yyv4656 = append(yyv4656, PodCondition{})
- yyh4656.ElemContainerState(yyj4656)
+ if yyrt4661 {
+ for ; yyj4661 < yyl4661; yyj4661++ {
+ yyv4661 = append(yyv4661, PodCondition{})
+ yyh4661.ElemContainerState(yyj4661)
if r.TryDecodeAsNil() {
- yyv4656[yyj4656] = PodCondition{}
+ yyv4661[yyj4661] = PodCondition{}
} else {
- yyv4658 := &yyv4656[yyj4656]
- yyv4658.CodecDecodeSelf(d)
+ yyv4663 := &yyv4661[yyj4661]
+ yyv4663.CodecDecodeSelf(d)
}
}
}
} else {
- yyj4656 := 0
- for ; !r.CheckBreak(); yyj4656++ {
+ yyj4661 := 0
+ for ; !r.CheckBreak(); yyj4661++ {
- if yyj4656 >= len(yyv4656) {
- yyv4656 = append(yyv4656, PodCondition{}) // var yyz4656 PodCondition
- yyc4656 = true
+ if yyj4661 >= len(yyv4661) {
+ yyv4661 = append(yyv4661, PodCondition{}) // var yyz4661 PodCondition
+ yyc4661 = true
}
- yyh4656.ElemContainerState(yyj4656)
- if yyj4656 < len(yyv4656) {
+ yyh4661.ElemContainerState(yyj4661)
+ if yyj4661 < len(yyv4661) {
if r.TryDecodeAsNil() {
- yyv4656[yyj4656] = PodCondition{}
+ yyv4661[yyj4661] = PodCondition{}
} else {
- yyv4659 := &yyv4656[yyj4656]
- yyv4659.CodecDecodeSelf(d)
+ yyv4664 := &yyv4661[yyj4661]
+ yyv4664.CodecDecodeSelf(d)
}
} else {
@@ -58875,17 +58939,17 @@ func (x codecSelfer1234) decSlicePodCondition(v *[]PodCondition, d *codec1978.De
}
}
- if yyj4656 < len(yyv4656) {
- yyv4656 = yyv4656[:yyj4656]
- yyc4656 = true
- } else if yyj4656 == 0 && yyv4656 == nil {
- yyv4656 = []PodCondition{}
- yyc4656 = true
+ if yyj4661 < len(yyv4661) {
+ yyv4661 = yyv4661[:yyj4661]
+ yyc4661 = true
+ } else if yyj4661 == 0 && yyv4661 == nil {
+ yyv4661 = []PodCondition{}
+ yyc4661 = true
}
}
- yyh4656.End()
- if yyc4656 {
- *v = yyv4656
+ yyh4661.End()
+ if yyc4661 {
+ *v = yyv4661
}
}
@@ -58894,10 +58958,10 @@ func (x codecSelfer1234) encSliceContainerStatus(v []ContainerStatus, e *codec19
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
r.EncodeArrayStart(len(v))
- for _, yyv4660 := range v {
+ for _, yyv4665 := range v {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy4661 := &yyv4660
- yy4661.CodecEncodeSelf(e)
+ yy4666 := &yyv4665
+ yy4666.CodecEncodeSelf(e)
}
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -58907,83 +58971,83 @@ func (x codecSelfer1234) decSliceContainerStatus(v *[]ContainerStatus, d *codec1
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yyv4662 := *v
- yyh4662, yyl4662 := z.DecSliceHelperStart()
- var yyc4662 bool
- if yyl4662 == 0 {
- if yyv4662 == nil {
- yyv4662 = []ContainerStatus{}
- yyc4662 = true
- } else if len(yyv4662) != 0 {
- yyv4662 = yyv4662[:0]
- yyc4662 = true
+ yyv4667 := *v
+ yyh4667, yyl4667 := z.DecSliceHelperStart()
+ var yyc4667 bool
+ if yyl4667 == 0 {
+ if yyv4667 == nil {
+ yyv4667 = []ContainerStatus{}
+ yyc4667 = true
+ } else if len(yyv4667) != 0 {
+ yyv4667 = yyv4667[:0]
+ yyc4667 = true
}
- } else if yyl4662 > 0 {
- var yyrr4662, yyrl4662 int
- var yyrt4662 bool
- if yyl4662 > cap(yyv4662) {
+ } else if yyl4667 > 0 {
+ var yyrr4667, yyrl4667 int
+ var yyrt4667 bool
+ if yyl4667 > cap(yyv4667) {
- yyrg4662 := len(yyv4662) > 0
- yyv24662 := yyv4662
- yyrl4662, yyrt4662 = z.DecInferLen(yyl4662, z.DecBasicHandle().MaxInitLen, 120)
- if yyrt4662 {
- if yyrl4662 <= cap(yyv4662) {
- yyv4662 = yyv4662[:yyrl4662]
+ yyrg4667 := len(yyv4667) > 0
+ yyv24667 := yyv4667
+ yyrl4667, yyrt4667 = z.DecInferLen(yyl4667, z.DecBasicHandle().MaxInitLen, 120)
+ if yyrt4667 {
+ if yyrl4667 <= cap(yyv4667) {
+ yyv4667 = yyv4667[:yyrl4667]
} else {
- yyv4662 = make([]ContainerStatus, yyrl4662)
+ yyv4667 = make([]ContainerStatus, yyrl4667)
}
} else {
- yyv4662 = make([]ContainerStatus, yyrl4662)
+ yyv4667 = make([]ContainerStatus, yyrl4667)
}
- yyc4662 = true
- yyrr4662 = len(yyv4662)
- if yyrg4662 {
- copy(yyv4662, yyv24662)
+ yyc4667 = true
+ yyrr4667 = len(yyv4667)
+ if yyrg4667 {
+ copy(yyv4667, yyv24667)
}
- } else if yyl4662 != len(yyv4662) {
- yyv4662 = yyv4662[:yyl4662]
- yyc4662 = true
+ } else if yyl4667 != len(yyv4667) {
+ yyv4667 = yyv4667[:yyl4667]
+ yyc4667 = true
}
- yyj4662 := 0
- for ; yyj4662 < yyrr4662; yyj4662++ {
- yyh4662.ElemContainerState(yyj4662)
+ yyj4667 := 0
+ for ; yyj4667 < yyrr4667; yyj4667++ {
+ yyh4667.ElemContainerState(yyj4667)
if r.TryDecodeAsNil() {
- yyv4662[yyj4662] = ContainerStatus{}
+ yyv4667[yyj4667] = ContainerStatus{}
} else {
- yyv4663 := &yyv4662[yyj4662]
- yyv4663.CodecDecodeSelf(d)
+ yyv4668 := &yyv4667[yyj4667]
+ yyv4668.CodecDecodeSelf(d)
}
}
- if yyrt4662 {
- for ; yyj4662 < yyl4662; yyj4662++ {
- yyv4662 = append(yyv4662, ContainerStatus{})
- yyh4662.ElemContainerState(yyj4662)
+ if yyrt4667 {
+ for ; yyj4667 < yyl4667; yyj4667++ {
+ yyv4667 = append(yyv4667, ContainerStatus{})
+ yyh4667.ElemContainerState(yyj4667)
if r.TryDecodeAsNil() {
- yyv4662[yyj4662] = ContainerStatus{}
+ yyv4667[yyj4667] = ContainerStatus{}
} else {
- yyv4664 := &yyv4662[yyj4662]
- yyv4664.CodecDecodeSelf(d)
+ yyv4669 := &yyv4667[yyj4667]
+ yyv4669.CodecDecodeSelf(d)
}
}
}
} else {
- yyj4662 := 0
- for ; !r.CheckBreak(); yyj4662++ {
+ yyj4667 := 0
+ for ; !r.CheckBreak(); yyj4667++ {
- if yyj4662 >= len(yyv4662) {
- yyv4662 = append(yyv4662, ContainerStatus{}) // var yyz4662 ContainerStatus
- yyc4662 = true
+ if yyj4667 >= len(yyv4667) {
+ yyv4667 = append(yyv4667, ContainerStatus{}) // var yyz4667 ContainerStatus
+ yyc4667 = true
}
- yyh4662.ElemContainerState(yyj4662)
- if yyj4662 < len(yyv4662) {
+ yyh4667.ElemContainerState(yyj4667)
+ if yyj4667 < len(yyv4667) {
if r.TryDecodeAsNil() {
- yyv4662[yyj4662] = ContainerStatus{}
+ yyv4667[yyj4667] = ContainerStatus{}
} else {
- yyv4665 := &yyv4662[yyj4662]
- yyv4665.CodecDecodeSelf(d)
+ yyv4670 := &yyv4667[yyj4667]
+ yyv4670.CodecDecodeSelf(d)
}
} else {
@@ -58991,17 +59055,17 @@ func (x codecSelfer1234) decSliceContainerStatus(v *[]ContainerStatus, d *codec1
}
}
- if yyj4662 < len(yyv4662) {
- yyv4662 = yyv4662[:yyj4662]
- yyc4662 = true
- } else if yyj4662 == 0 && yyv4662 == nil {
- yyv4662 = []ContainerStatus{}
- yyc4662 = true
+ if yyj4667 < len(yyv4667) {
+ yyv4667 = yyv4667[:yyj4667]
+ yyc4667 = true
+ } else if yyj4667 == 0 && yyv4667 == nil {
+ yyv4667 = []ContainerStatus{}
+ yyc4667 = true
}
}
- yyh4662.End()
- if yyc4662 {
- *v = yyv4662
+ yyh4667.End()
+ if yyc4667 {
+ *v = yyv4667
}
}
@@ -59010,10 +59074,10 @@ func (x codecSelfer1234) encSlicePod(v []Pod, e *codec1978.Encoder) {
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
r.EncodeArrayStart(len(v))
- for _, yyv4666 := range v {
+ for _, yyv4671 := range v {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy4667 := &yyv4666
- yy4667.CodecEncodeSelf(e)
+ yy4672 := &yyv4671
+ yy4672.CodecEncodeSelf(e)
}
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -59023,83 +59087,83 @@ func (x codecSelfer1234) decSlicePod(v *[]Pod, d *codec1978.Decoder) {
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yyv4668 := *v
- yyh4668, yyl4668 := z.DecSliceHelperStart()
- var yyc4668 bool
- if yyl4668 == 0 {
- if yyv4668 == nil {
- yyv4668 = []Pod{}
- yyc4668 = true
- } else if len(yyv4668) != 0 {
- yyv4668 = yyv4668[:0]
- yyc4668 = true
+ yyv4673 := *v
+ yyh4673, yyl4673 := z.DecSliceHelperStart()
+ var yyc4673 bool
+ if yyl4673 == 0 {
+ if yyv4673 == nil {
+ yyv4673 = []Pod{}
+ yyc4673 = true
+ } else if len(yyv4673) != 0 {
+ yyv4673 = yyv4673[:0]
+ yyc4673 = true
}
- } else if yyl4668 > 0 {
- var yyrr4668, yyrl4668 int
- var yyrt4668 bool
- if yyl4668 > cap(yyv4668) {
+ } else if yyl4673 > 0 {
+ var yyrr4673, yyrl4673 int
+ var yyrt4673 bool
+ if yyl4673 > cap(yyv4673) {
- yyrg4668 := len(yyv4668) > 0
- yyv24668 := yyv4668
- yyrl4668, yyrt4668 = z.DecInferLen(yyl4668, z.DecBasicHandle().MaxInitLen, 664)
- if yyrt4668 {
- if yyrl4668 <= cap(yyv4668) {
- yyv4668 = yyv4668[:yyrl4668]
+ yyrg4673 := len(yyv4673) > 0
+ yyv24673 := yyv4673
+ yyrl4673, yyrt4673 = z.DecInferLen(yyl4673, z.DecBasicHandle().MaxInitLen, 680)
+ if yyrt4673 {
+ if yyrl4673 <= cap(yyv4673) {
+ yyv4673 = yyv4673[:yyrl4673]
} else {
- yyv4668 = make([]Pod, yyrl4668)
+ yyv4673 = make([]Pod, yyrl4673)
}
} else {
- yyv4668 = make([]Pod, yyrl4668)
+ yyv4673 = make([]Pod, yyrl4673)
}
- yyc4668 = true
- yyrr4668 = len(yyv4668)
- if yyrg4668 {
- copy(yyv4668, yyv24668)
+ yyc4673 = true
+ yyrr4673 = len(yyv4673)
+ if yyrg4673 {
+ copy(yyv4673, yyv24673)
}
- } else if yyl4668 != len(yyv4668) {
- yyv4668 = yyv4668[:yyl4668]
- yyc4668 = true
+ } else if yyl4673 != len(yyv4673) {
+ yyv4673 = yyv4673[:yyl4673]
+ yyc4673 = true
}
- yyj4668 := 0
- for ; yyj4668 < yyrr4668; yyj4668++ {
- yyh4668.ElemContainerState(yyj4668)
+ yyj4673 := 0
+ for ; yyj4673 < yyrr4673; yyj4673++ {
+ yyh4673.ElemContainerState(yyj4673)
if r.TryDecodeAsNil() {
- yyv4668[yyj4668] = Pod{}
+ yyv4673[yyj4673] = Pod{}
} else {
- yyv4669 := &yyv4668[yyj4668]
- yyv4669.CodecDecodeSelf(d)
+ yyv4674 := &yyv4673[yyj4673]
+ yyv4674.CodecDecodeSelf(d)
}
}
- if yyrt4668 {
- for ; yyj4668 < yyl4668; yyj4668++ {
- yyv4668 = append(yyv4668, Pod{})
- yyh4668.ElemContainerState(yyj4668)
+ if yyrt4673 {
+ for ; yyj4673 < yyl4673; yyj4673++ {
+ yyv4673 = append(yyv4673, Pod{})
+ yyh4673.ElemContainerState(yyj4673)
if r.TryDecodeAsNil() {
- yyv4668[yyj4668] = Pod{}
+ yyv4673[yyj4673] = Pod{}
} else {
- yyv4670 := &yyv4668[yyj4668]
- yyv4670.CodecDecodeSelf(d)
+ yyv4675 := &yyv4673[yyj4673]
+ yyv4675.CodecDecodeSelf(d)
}
}
}
} else {
- yyj4668 := 0
- for ; !r.CheckBreak(); yyj4668++ {
+ yyj4673 := 0
+ for ; !r.CheckBreak(); yyj4673++ {
- if yyj4668 >= len(yyv4668) {
- yyv4668 = append(yyv4668, Pod{}) // var yyz4668 Pod
- yyc4668 = true
+ if yyj4673 >= len(yyv4673) {
+ yyv4673 = append(yyv4673, Pod{}) // var yyz4673 Pod
+ yyc4673 = true
}
- yyh4668.ElemContainerState(yyj4668)
- if yyj4668 < len(yyv4668) {
+ yyh4673.ElemContainerState(yyj4673)
+ if yyj4673 < len(yyv4673) {
if r.TryDecodeAsNil() {
- yyv4668[yyj4668] = Pod{}
+ yyv4673[yyj4673] = Pod{}
} else {
- yyv4671 := &yyv4668[yyj4668]
- yyv4671.CodecDecodeSelf(d)
+ yyv4676 := &yyv4673[yyj4673]
+ yyv4676.CodecDecodeSelf(d)
}
} else {
@@ -59107,17 +59171,17 @@ func (x codecSelfer1234) decSlicePod(v *[]Pod, d *codec1978.Decoder) {
}
}
- if yyj4668 < len(yyv4668) {
- yyv4668 = yyv4668[:yyj4668]
- yyc4668 = true
- } else if yyj4668 == 0 && yyv4668 == nil {
- yyv4668 = []Pod{}
- yyc4668 = true
+ if yyj4673 < len(yyv4673) {
+ yyv4673 = yyv4673[:yyj4673]
+ yyc4673 = true
+ } else if yyj4673 == 0 && yyv4673 == nil {
+ yyv4673 = []Pod{}
+ yyc4673 = true
}
}
- yyh4668.End()
- if yyc4668 {
- *v = yyv4668
+ yyh4673.End()
+ if yyc4673 {
+ *v = yyv4673
}
}
@@ -59126,10 +59190,10 @@ func (x codecSelfer1234) encSlicePodTemplate(v []PodTemplate, e *codec1978.Encod
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
r.EncodeArrayStart(len(v))
- for _, yyv4672 := range v {
+ for _, yyv4677 := range v {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy4673 := &yyv4672
- yy4673.CodecEncodeSelf(e)
+ yy4678 := &yyv4677
+ yy4678.CodecEncodeSelf(e)
}
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -59139,83 +59203,83 @@ func (x codecSelfer1234) decSlicePodTemplate(v *[]PodTemplate, d *codec1978.Deco
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yyv4674 := *v
- yyh4674, yyl4674 := z.DecSliceHelperStart()
- var yyc4674 bool
- if yyl4674 == 0 {
- if yyv4674 == nil {
- yyv4674 = []PodTemplate{}
- yyc4674 = true
- } else if len(yyv4674) != 0 {
- yyv4674 = yyv4674[:0]
- yyc4674 = true
+ yyv4679 := *v
+ yyh4679, yyl4679 := z.DecSliceHelperStart()
+ var yyc4679 bool
+ if yyl4679 == 0 {
+ if yyv4679 == nil {
+ yyv4679 = []PodTemplate{}
+ yyc4679 = true
+ } else if len(yyv4679) != 0 {
+ yyv4679 = yyv4679[:0]
+ yyc4679 = true
}
- } else if yyl4674 > 0 {
- var yyrr4674, yyrl4674 int
- var yyrt4674 bool
- if yyl4674 > cap(yyv4674) {
+ } else if yyl4679 > 0 {
+ var yyrr4679, yyrl4679 int
+ var yyrt4679 bool
+ if yyl4679 > cap(yyv4679) {
- yyrg4674 := len(yyv4674) > 0
- yyv24674 := yyv4674
- yyrl4674, yyrt4674 = z.DecInferLen(yyl4674, z.DecBasicHandle().MaxInitLen, 728)
- if yyrt4674 {
- if yyrl4674 <= cap(yyv4674) {
- yyv4674 = yyv4674[:yyrl4674]
+ yyrg4679 := len(yyv4679) > 0
+ yyv24679 := yyv4679
+ yyrl4679, yyrt4679 = z.DecInferLen(yyl4679, z.DecBasicHandle().MaxInitLen, 728)
+ if yyrt4679 {
+ if yyrl4679 <= cap(yyv4679) {
+ yyv4679 = yyv4679[:yyrl4679]
} else {
- yyv4674 = make([]PodTemplate, yyrl4674)
+ yyv4679 = make([]PodTemplate, yyrl4679)
}
} else {
- yyv4674 = make([]PodTemplate, yyrl4674)
+ yyv4679 = make([]PodTemplate, yyrl4679)
}
- yyc4674 = true
- yyrr4674 = len(yyv4674)
- if yyrg4674 {
- copy(yyv4674, yyv24674)
+ yyc4679 = true
+ yyrr4679 = len(yyv4679)
+ if yyrg4679 {
+ copy(yyv4679, yyv24679)
}
- } else if yyl4674 != len(yyv4674) {
- yyv4674 = yyv4674[:yyl4674]
- yyc4674 = true
+ } else if yyl4679 != len(yyv4679) {
+ yyv4679 = yyv4679[:yyl4679]
+ yyc4679 = true
}
- yyj4674 := 0
- for ; yyj4674 < yyrr4674; yyj4674++ {
- yyh4674.ElemContainerState(yyj4674)
+ yyj4679 := 0
+ for ; yyj4679 < yyrr4679; yyj4679++ {
+ yyh4679.ElemContainerState(yyj4679)
if r.TryDecodeAsNil() {
- yyv4674[yyj4674] = PodTemplate{}
+ yyv4679[yyj4679] = PodTemplate{}
} else {
- yyv4675 := &yyv4674[yyj4674]
- yyv4675.CodecDecodeSelf(d)
+ yyv4680 := &yyv4679[yyj4679]
+ yyv4680.CodecDecodeSelf(d)
}
}
- if yyrt4674 {
- for ; yyj4674 < yyl4674; yyj4674++ {
- yyv4674 = append(yyv4674, PodTemplate{})
- yyh4674.ElemContainerState(yyj4674)
+ if yyrt4679 {
+ for ; yyj4679 < yyl4679; yyj4679++ {
+ yyv4679 = append(yyv4679, PodTemplate{})
+ yyh4679.ElemContainerState(yyj4679)
if r.TryDecodeAsNil() {
- yyv4674[yyj4674] = PodTemplate{}
+ yyv4679[yyj4679] = PodTemplate{}
} else {
- yyv4676 := &yyv4674[yyj4674]
- yyv4676.CodecDecodeSelf(d)
+ yyv4681 := &yyv4679[yyj4679]
+ yyv4681.CodecDecodeSelf(d)
}
}
}
} else {
- yyj4674 := 0
- for ; !r.CheckBreak(); yyj4674++ {
+ yyj4679 := 0
+ for ; !r.CheckBreak(); yyj4679++ {
- if yyj4674 >= len(yyv4674) {
- yyv4674 = append(yyv4674, PodTemplate{}) // var yyz4674 PodTemplate
- yyc4674 = true
+ if yyj4679 >= len(yyv4679) {
+ yyv4679 = append(yyv4679, PodTemplate{}) // var yyz4679 PodTemplate
+ yyc4679 = true
}
- yyh4674.ElemContainerState(yyj4674)
- if yyj4674 < len(yyv4674) {
+ yyh4679.ElemContainerState(yyj4679)
+ if yyj4679 < len(yyv4679) {
if r.TryDecodeAsNil() {
- yyv4674[yyj4674] = PodTemplate{}
+ yyv4679[yyj4679] = PodTemplate{}
} else {
- yyv4677 := &yyv4674[yyj4674]
- yyv4677.CodecDecodeSelf(d)
+ yyv4682 := &yyv4679[yyj4679]
+ yyv4682.CodecDecodeSelf(d)
}
} else {
@@ -59223,17 +59287,17 @@ func (x codecSelfer1234) decSlicePodTemplate(v *[]PodTemplate, d *codec1978.Deco
}
}
- if yyj4674 < len(yyv4674) {
- yyv4674 = yyv4674[:yyj4674]
- yyc4674 = true
- } else if yyj4674 == 0 && yyv4674 == nil {
- yyv4674 = []PodTemplate{}
- yyc4674 = true
+ if yyj4679 < len(yyv4679) {
+ yyv4679 = yyv4679[:yyj4679]
+ yyc4679 = true
+ } else if yyj4679 == 0 && yyv4679 == nil {
+ yyv4679 = []PodTemplate{}
+ yyc4679 = true
}
}
- yyh4674.End()
- if yyc4674 {
- *v = yyv4674
+ yyh4679.End()
+ if yyc4679 {
+ *v = yyv4679
}
}
@@ -59242,10 +59306,10 @@ func (x codecSelfer1234) encSliceReplicationControllerCondition(v []ReplicationC
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
r.EncodeArrayStart(len(v))
- for _, yyv4678 := range v {
+ for _, yyv4683 := range v {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy4679 := &yyv4678
- yy4679.CodecEncodeSelf(e)
+ yy4684 := &yyv4683
+ yy4684.CodecEncodeSelf(e)
}
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -59255,83 +59319,83 @@ func (x codecSelfer1234) decSliceReplicationControllerCondition(v *[]Replication
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yyv4680 := *v
- yyh4680, yyl4680 := z.DecSliceHelperStart()
- var yyc4680 bool
- if yyl4680 == 0 {
- if yyv4680 == nil {
- yyv4680 = []ReplicationControllerCondition{}
- yyc4680 = true
- } else if len(yyv4680) != 0 {
- yyv4680 = yyv4680[:0]
- yyc4680 = true
+ yyv4685 := *v
+ yyh4685, yyl4685 := z.DecSliceHelperStart()
+ var yyc4685 bool
+ if yyl4685 == 0 {
+ if yyv4685 == nil {
+ yyv4685 = []ReplicationControllerCondition{}
+ yyc4685 = true
+ } else if len(yyv4685) != 0 {
+ yyv4685 = yyv4685[:0]
+ yyc4685 = true
}
- } else if yyl4680 > 0 {
- var yyrr4680, yyrl4680 int
- var yyrt4680 bool
- if yyl4680 > cap(yyv4680) {
+ } else if yyl4685 > 0 {
+ var yyrr4685, yyrl4685 int
+ var yyrt4685 bool
+ if yyl4685 > cap(yyv4685) {
- yyrg4680 := len(yyv4680) > 0
- yyv24680 := yyv4680
- yyrl4680, yyrt4680 = z.DecInferLen(yyl4680, z.DecBasicHandle().MaxInitLen, 88)
- if yyrt4680 {
- if yyrl4680 <= cap(yyv4680) {
- yyv4680 = yyv4680[:yyrl4680]
+ yyrg4685 := len(yyv4685) > 0
+ yyv24685 := yyv4685
+ yyrl4685, yyrt4685 = z.DecInferLen(yyl4685, z.DecBasicHandle().MaxInitLen, 88)
+ if yyrt4685 {
+ if yyrl4685 <= cap(yyv4685) {
+ yyv4685 = yyv4685[:yyrl4685]
} else {
- yyv4680 = make([]ReplicationControllerCondition, yyrl4680)
+ yyv4685 = make([]ReplicationControllerCondition, yyrl4685)
}
} else {
- yyv4680 = make([]ReplicationControllerCondition, yyrl4680)
+ yyv4685 = make([]ReplicationControllerCondition, yyrl4685)
}
- yyc4680 = true
- yyrr4680 = len(yyv4680)
- if yyrg4680 {
- copy(yyv4680, yyv24680)
+ yyc4685 = true
+ yyrr4685 = len(yyv4685)
+ if yyrg4685 {
+ copy(yyv4685, yyv24685)
}
- } else if yyl4680 != len(yyv4680) {
- yyv4680 = yyv4680[:yyl4680]
- yyc4680 = true
+ } else if yyl4685 != len(yyv4685) {
+ yyv4685 = yyv4685[:yyl4685]
+ yyc4685 = true
}
- yyj4680 := 0
- for ; yyj4680 < yyrr4680; yyj4680++ {
- yyh4680.ElemContainerState(yyj4680)
+ yyj4685 := 0
+ for ; yyj4685 < yyrr4685; yyj4685++ {
+ yyh4685.ElemContainerState(yyj4685)
if r.TryDecodeAsNil() {
- yyv4680[yyj4680] = ReplicationControllerCondition{}
+ yyv4685[yyj4685] = ReplicationControllerCondition{}
} else {
- yyv4681 := &yyv4680[yyj4680]
- yyv4681.CodecDecodeSelf(d)
+ yyv4686 := &yyv4685[yyj4685]
+ yyv4686.CodecDecodeSelf(d)
}
}
- if yyrt4680 {
- for ; yyj4680 < yyl4680; yyj4680++ {
- yyv4680 = append(yyv4680, ReplicationControllerCondition{})
- yyh4680.ElemContainerState(yyj4680)
+ if yyrt4685 {
+ for ; yyj4685 < yyl4685; yyj4685++ {
+ yyv4685 = append(yyv4685, ReplicationControllerCondition{})
+ yyh4685.ElemContainerState(yyj4685)
if r.TryDecodeAsNil() {
- yyv4680[yyj4680] = ReplicationControllerCondition{}
+ yyv4685[yyj4685] = ReplicationControllerCondition{}
} else {
- yyv4682 := &yyv4680[yyj4680]
- yyv4682.CodecDecodeSelf(d)
+ yyv4687 := &yyv4685[yyj4685]
+ yyv4687.CodecDecodeSelf(d)
}
}
}
} else {
- yyj4680 := 0
- for ; !r.CheckBreak(); yyj4680++ {
+ yyj4685 := 0
+ for ; !r.CheckBreak(); yyj4685++ {
- if yyj4680 >= len(yyv4680) {
- yyv4680 = append(yyv4680, ReplicationControllerCondition{}) // var yyz4680 ReplicationControllerCondition
- yyc4680 = true
+ if yyj4685 >= len(yyv4685) {
+ yyv4685 = append(yyv4685, ReplicationControllerCondition{}) // var yyz4685 ReplicationControllerCondition
+ yyc4685 = true
}
- yyh4680.ElemContainerState(yyj4680)
- if yyj4680 < len(yyv4680) {
+ yyh4685.ElemContainerState(yyj4685)
+ if yyj4685 < len(yyv4685) {
if r.TryDecodeAsNil() {
- yyv4680[yyj4680] = ReplicationControllerCondition{}
+ yyv4685[yyj4685] = ReplicationControllerCondition{}
} else {
- yyv4683 := &yyv4680[yyj4680]
- yyv4683.CodecDecodeSelf(d)
+ yyv4688 := &yyv4685[yyj4685]
+ yyv4688.CodecDecodeSelf(d)
}
} else {
@@ -59339,17 +59403,17 @@ func (x codecSelfer1234) decSliceReplicationControllerCondition(v *[]Replication
}
}
- if yyj4680 < len(yyv4680) {
- yyv4680 = yyv4680[:yyj4680]
- yyc4680 = true
- } else if yyj4680 == 0 && yyv4680 == nil {
- yyv4680 = []ReplicationControllerCondition{}
- yyc4680 = true
+ if yyj4685 < len(yyv4685) {
+ yyv4685 = yyv4685[:yyj4685]
+ yyc4685 = true
+ } else if yyj4685 == 0 && yyv4685 == nil {
+ yyv4685 = []ReplicationControllerCondition{}
+ yyc4685 = true
}
}
- yyh4680.End()
- if yyc4680 {
- *v = yyv4680
+ yyh4685.End()
+ if yyc4685 {
+ *v = yyv4685
}
}
@@ -59358,10 +59422,10 @@ func (x codecSelfer1234) encSliceReplicationController(v []ReplicationController
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
r.EncodeArrayStart(len(v))
- for _, yyv4684 := range v {
+ for _, yyv4689 := range v {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy4685 := &yyv4684
- yy4685.CodecEncodeSelf(e)
+ yy4690 := &yyv4689
+ yy4690.CodecEncodeSelf(e)
}
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -59371,83 +59435,83 @@ func (x codecSelfer1234) decSliceReplicationController(v *[]ReplicationControlle
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yyv4686 := *v
- yyh4686, yyl4686 := z.DecSliceHelperStart()
- var yyc4686 bool
- if yyl4686 == 0 {
- if yyv4686 == nil {
- yyv4686 = []ReplicationController{}
- yyc4686 = true
- } else if len(yyv4686) != 0 {
- yyv4686 = yyv4686[:0]
- yyc4686 = true
+ yyv4691 := *v
+ yyh4691, yyl4691 := z.DecSliceHelperStart()
+ var yyc4691 bool
+ if yyl4691 == 0 {
+ if yyv4691 == nil {
+ yyv4691 = []ReplicationController{}
+ yyc4691 = true
+ } else if len(yyv4691) != 0 {
+ yyv4691 = yyv4691[:0]
+ yyc4691 = true
}
- } else if yyl4686 > 0 {
- var yyrr4686, yyrl4686 int
- var yyrt4686 bool
- if yyl4686 > cap(yyv4686) {
+ } else if yyl4691 > 0 {
+ var yyrr4691, yyrl4691 int
+ var yyrt4691 bool
+ if yyl4691 > cap(yyv4691) {
- yyrg4686 := len(yyv4686) > 0
- yyv24686 := yyv4686
- yyrl4686, yyrt4686 = z.DecInferLen(yyl4686, z.DecBasicHandle().MaxInitLen, 336)
- if yyrt4686 {
- if yyrl4686 <= cap(yyv4686) {
- yyv4686 = yyv4686[:yyrl4686]
+ yyrg4691 := len(yyv4691) > 0
+ yyv24691 := yyv4691
+ yyrl4691, yyrt4691 = z.DecInferLen(yyl4691, z.DecBasicHandle().MaxInitLen, 336)
+ if yyrt4691 {
+ if yyrl4691 <= cap(yyv4691) {
+ yyv4691 = yyv4691[:yyrl4691]
} else {
- yyv4686 = make([]ReplicationController, yyrl4686)
+ yyv4691 = make([]ReplicationController, yyrl4691)
}
} else {
- yyv4686 = make([]ReplicationController, yyrl4686)
+ yyv4691 = make([]ReplicationController, yyrl4691)
}
- yyc4686 = true
- yyrr4686 = len(yyv4686)
- if yyrg4686 {
- copy(yyv4686, yyv24686)
+ yyc4691 = true
+ yyrr4691 = len(yyv4691)
+ if yyrg4691 {
+ copy(yyv4691, yyv24691)
}
- } else if yyl4686 != len(yyv4686) {
- yyv4686 = yyv4686[:yyl4686]
- yyc4686 = true
+ } else if yyl4691 != len(yyv4691) {
+ yyv4691 = yyv4691[:yyl4691]
+ yyc4691 = true
}
- yyj4686 := 0
- for ; yyj4686 < yyrr4686; yyj4686++ {
- yyh4686.ElemContainerState(yyj4686)
+ yyj4691 := 0
+ for ; yyj4691 < yyrr4691; yyj4691++ {
+ yyh4691.ElemContainerState(yyj4691)
if r.TryDecodeAsNil() {
- yyv4686[yyj4686] = ReplicationController{}
+ yyv4691[yyj4691] = ReplicationController{}
} else {
- yyv4687 := &yyv4686[yyj4686]
- yyv4687.CodecDecodeSelf(d)
+ yyv4692 := &yyv4691[yyj4691]
+ yyv4692.CodecDecodeSelf(d)
}
}
- if yyrt4686 {
- for ; yyj4686 < yyl4686; yyj4686++ {
- yyv4686 = append(yyv4686, ReplicationController{})
- yyh4686.ElemContainerState(yyj4686)
+ if yyrt4691 {
+ for ; yyj4691 < yyl4691; yyj4691++ {
+ yyv4691 = append(yyv4691, ReplicationController{})
+ yyh4691.ElemContainerState(yyj4691)
if r.TryDecodeAsNil() {
- yyv4686[yyj4686] = ReplicationController{}
+ yyv4691[yyj4691] = ReplicationController{}
} else {
- yyv4688 := &yyv4686[yyj4686]
- yyv4688.CodecDecodeSelf(d)
+ yyv4693 := &yyv4691[yyj4691]
+ yyv4693.CodecDecodeSelf(d)
}
}
}
} else {
- yyj4686 := 0
- for ; !r.CheckBreak(); yyj4686++ {
+ yyj4691 := 0
+ for ; !r.CheckBreak(); yyj4691++ {
- if yyj4686 >= len(yyv4686) {
- yyv4686 = append(yyv4686, ReplicationController{}) // var yyz4686 ReplicationController
- yyc4686 = true
+ if yyj4691 >= len(yyv4691) {
+ yyv4691 = append(yyv4691, ReplicationController{}) // var yyz4691 ReplicationController
+ yyc4691 = true
}
- yyh4686.ElemContainerState(yyj4686)
- if yyj4686 < len(yyv4686) {
+ yyh4691.ElemContainerState(yyj4691)
+ if yyj4691 < len(yyv4691) {
if r.TryDecodeAsNil() {
- yyv4686[yyj4686] = ReplicationController{}
+ yyv4691[yyj4691] = ReplicationController{}
} else {
- yyv4689 := &yyv4686[yyj4686]
- yyv4689.CodecDecodeSelf(d)
+ yyv4694 := &yyv4691[yyj4691]
+ yyv4694.CodecDecodeSelf(d)
}
} else {
@@ -59455,17 +59519,17 @@ func (x codecSelfer1234) decSliceReplicationController(v *[]ReplicationControlle
}
}
- if yyj4686 < len(yyv4686) {
- yyv4686 = yyv4686[:yyj4686]
- yyc4686 = true
- } else if yyj4686 == 0 && yyv4686 == nil {
- yyv4686 = []ReplicationController{}
- yyc4686 = true
+ if yyj4691 < len(yyv4691) {
+ yyv4691 = yyv4691[:yyj4691]
+ yyc4691 = true
+ } else if yyj4691 == 0 && yyv4691 == nil {
+ yyv4691 = []ReplicationController{}
+ yyc4691 = true
}
}
- yyh4686.End()
- if yyc4686 {
- *v = yyv4686
+ yyh4691.End()
+ if yyc4691 {
+ *v = yyv4691
}
}
@@ -59474,10 +59538,10 @@ func (x codecSelfer1234) encSliceLoadBalancerIngress(v []LoadBalancerIngress, e
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
r.EncodeArrayStart(len(v))
- for _, yyv4690 := range v {
+ for _, yyv4695 := range v {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy4691 := &yyv4690
- yy4691.CodecEncodeSelf(e)
+ yy4696 := &yyv4695
+ yy4696.CodecEncodeSelf(e)
}
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -59487,83 +59551,83 @@ func (x codecSelfer1234) decSliceLoadBalancerIngress(v *[]LoadBalancerIngress, d
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yyv4692 := *v
- yyh4692, yyl4692 := z.DecSliceHelperStart()
- var yyc4692 bool
- if yyl4692 == 0 {
- if yyv4692 == nil {
- yyv4692 = []LoadBalancerIngress{}
- yyc4692 = true
- } else if len(yyv4692) != 0 {
- yyv4692 = yyv4692[:0]
- yyc4692 = true
+ yyv4697 := *v
+ yyh4697, yyl4697 := z.DecSliceHelperStart()
+ var yyc4697 bool
+ if yyl4697 == 0 {
+ if yyv4697 == nil {
+ yyv4697 = []LoadBalancerIngress{}
+ yyc4697 = true
+ } else if len(yyv4697) != 0 {
+ yyv4697 = yyv4697[:0]
+ yyc4697 = true
}
- } else if yyl4692 > 0 {
- var yyrr4692, yyrl4692 int
- var yyrt4692 bool
- if yyl4692 > cap(yyv4692) {
+ } else if yyl4697 > 0 {
+ var yyrr4697, yyrl4697 int
+ var yyrt4697 bool
+ if yyl4697 > cap(yyv4697) {
- yyrg4692 := len(yyv4692) > 0
- yyv24692 := yyv4692
- yyrl4692, yyrt4692 = z.DecInferLen(yyl4692, z.DecBasicHandle().MaxInitLen, 32)
- if yyrt4692 {
- if yyrl4692 <= cap(yyv4692) {
- yyv4692 = yyv4692[:yyrl4692]
+ yyrg4697 := len(yyv4697) > 0
+ yyv24697 := yyv4697
+ yyrl4697, yyrt4697 = z.DecInferLen(yyl4697, z.DecBasicHandle().MaxInitLen, 32)
+ if yyrt4697 {
+ if yyrl4697 <= cap(yyv4697) {
+ yyv4697 = yyv4697[:yyrl4697]
} else {
- yyv4692 = make([]LoadBalancerIngress, yyrl4692)
+ yyv4697 = make([]LoadBalancerIngress, yyrl4697)
}
} else {
- yyv4692 = make([]LoadBalancerIngress, yyrl4692)
+ yyv4697 = make([]LoadBalancerIngress, yyrl4697)
}
- yyc4692 = true
- yyrr4692 = len(yyv4692)
- if yyrg4692 {
- copy(yyv4692, yyv24692)
+ yyc4697 = true
+ yyrr4697 = len(yyv4697)
+ if yyrg4697 {
+ copy(yyv4697, yyv24697)
}
- } else if yyl4692 != len(yyv4692) {
- yyv4692 = yyv4692[:yyl4692]
- yyc4692 = true
+ } else if yyl4697 != len(yyv4697) {
+ yyv4697 = yyv4697[:yyl4697]
+ yyc4697 = true
}
- yyj4692 := 0
- for ; yyj4692 < yyrr4692; yyj4692++ {
- yyh4692.ElemContainerState(yyj4692)
+ yyj4697 := 0
+ for ; yyj4697 < yyrr4697; yyj4697++ {
+ yyh4697.ElemContainerState(yyj4697)
if r.TryDecodeAsNil() {
- yyv4692[yyj4692] = LoadBalancerIngress{}
+ yyv4697[yyj4697] = LoadBalancerIngress{}
} else {
- yyv4693 := &yyv4692[yyj4692]
- yyv4693.CodecDecodeSelf(d)
+ yyv4698 := &yyv4697[yyj4697]
+ yyv4698.CodecDecodeSelf(d)
}
}
- if yyrt4692 {
- for ; yyj4692 < yyl4692; yyj4692++ {
- yyv4692 = append(yyv4692, LoadBalancerIngress{})
- yyh4692.ElemContainerState(yyj4692)
+ if yyrt4697 {
+ for ; yyj4697 < yyl4697; yyj4697++ {
+ yyv4697 = append(yyv4697, LoadBalancerIngress{})
+ yyh4697.ElemContainerState(yyj4697)
if r.TryDecodeAsNil() {
- yyv4692[yyj4692] = LoadBalancerIngress{}
+ yyv4697[yyj4697] = LoadBalancerIngress{}
} else {
- yyv4694 := &yyv4692[yyj4692]
- yyv4694.CodecDecodeSelf(d)
+ yyv4699 := &yyv4697[yyj4697]
+ yyv4699.CodecDecodeSelf(d)
}
}
}
} else {
- yyj4692 := 0
- for ; !r.CheckBreak(); yyj4692++ {
+ yyj4697 := 0
+ for ; !r.CheckBreak(); yyj4697++ {
- if yyj4692 >= len(yyv4692) {
- yyv4692 = append(yyv4692, LoadBalancerIngress{}) // var yyz4692 LoadBalancerIngress
- yyc4692 = true
+ if yyj4697 >= len(yyv4697) {
+ yyv4697 = append(yyv4697, LoadBalancerIngress{}) // var yyz4697 LoadBalancerIngress
+ yyc4697 = true
}
- yyh4692.ElemContainerState(yyj4692)
- if yyj4692 < len(yyv4692) {
+ yyh4697.ElemContainerState(yyj4697)
+ if yyj4697 < len(yyv4697) {
if r.TryDecodeAsNil() {
- yyv4692[yyj4692] = LoadBalancerIngress{}
+ yyv4697[yyj4697] = LoadBalancerIngress{}
} else {
- yyv4695 := &yyv4692[yyj4692]
- yyv4695.CodecDecodeSelf(d)
+ yyv4700 := &yyv4697[yyj4697]
+ yyv4700.CodecDecodeSelf(d)
}
} else {
@@ -59571,17 +59635,17 @@ func (x codecSelfer1234) decSliceLoadBalancerIngress(v *[]LoadBalancerIngress, d
}
}
- if yyj4692 < len(yyv4692) {
- yyv4692 = yyv4692[:yyj4692]
- yyc4692 = true
- } else if yyj4692 == 0 && yyv4692 == nil {
- yyv4692 = []LoadBalancerIngress{}
- yyc4692 = true
+ if yyj4697 < len(yyv4697) {
+ yyv4697 = yyv4697[:yyj4697]
+ yyc4697 = true
+ } else if yyj4697 == 0 && yyv4697 == nil {
+ yyv4697 = []LoadBalancerIngress{}
+ yyc4697 = true
}
}
- yyh4692.End()
- if yyc4692 {
- *v = yyv4692
+ yyh4697.End()
+ if yyc4697 {
+ *v = yyv4697
}
}
@@ -59590,10 +59654,10 @@ func (x codecSelfer1234) encSliceServicePort(v []ServicePort, e *codec1978.Encod
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
r.EncodeArrayStart(len(v))
- for _, yyv4696 := range v {
+ for _, yyv4701 := range v {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy4697 := &yyv4696
- yy4697.CodecEncodeSelf(e)
+ yy4702 := &yyv4701
+ yy4702.CodecEncodeSelf(e)
}
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -59603,83 +59667,83 @@ func (x codecSelfer1234) decSliceServicePort(v *[]ServicePort, d *codec1978.Deco
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yyv4698 := *v
- yyh4698, yyl4698 := z.DecSliceHelperStart()
- var yyc4698 bool
- if yyl4698 == 0 {
- if yyv4698 == nil {
- yyv4698 = []ServicePort{}
- yyc4698 = true
- } else if len(yyv4698) != 0 {
- yyv4698 = yyv4698[:0]
- yyc4698 = true
+ yyv4703 := *v
+ yyh4703, yyl4703 := z.DecSliceHelperStart()
+ var yyc4703 bool
+ if yyl4703 == 0 {
+ if yyv4703 == nil {
+ yyv4703 = []ServicePort{}
+ yyc4703 = true
+ } else if len(yyv4703) != 0 {
+ yyv4703 = yyv4703[:0]
+ yyc4703 = true
}
- } else if yyl4698 > 0 {
- var yyrr4698, yyrl4698 int
- var yyrt4698 bool
- if yyl4698 > cap(yyv4698) {
+ } else if yyl4703 > 0 {
+ var yyrr4703, yyrl4703 int
+ var yyrt4703 bool
+ if yyl4703 > cap(yyv4703) {
- yyrg4698 := len(yyv4698) > 0
- yyv24698 := yyv4698
- yyrl4698, yyrt4698 = z.DecInferLen(yyl4698, z.DecBasicHandle().MaxInitLen, 80)
- if yyrt4698 {
- if yyrl4698 <= cap(yyv4698) {
- yyv4698 = yyv4698[:yyrl4698]
+ yyrg4703 := len(yyv4703) > 0
+ yyv24703 := yyv4703
+ yyrl4703, yyrt4703 = z.DecInferLen(yyl4703, z.DecBasicHandle().MaxInitLen, 80)
+ if yyrt4703 {
+ if yyrl4703 <= cap(yyv4703) {
+ yyv4703 = yyv4703[:yyrl4703]
} else {
- yyv4698 = make([]ServicePort, yyrl4698)
+ yyv4703 = make([]ServicePort, yyrl4703)
}
} else {
- yyv4698 = make([]ServicePort, yyrl4698)
+ yyv4703 = make([]ServicePort, yyrl4703)
}
- yyc4698 = true
- yyrr4698 = len(yyv4698)
- if yyrg4698 {
- copy(yyv4698, yyv24698)
+ yyc4703 = true
+ yyrr4703 = len(yyv4703)
+ if yyrg4703 {
+ copy(yyv4703, yyv24703)
}
- } else if yyl4698 != len(yyv4698) {
- yyv4698 = yyv4698[:yyl4698]
- yyc4698 = true
+ } else if yyl4703 != len(yyv4703) {
+ yyv4703 = yyv4703[:yyl4703]
+ yyc4703 = true
}
- yyj4698 := 0
- for ; yyj4698 < yyrr4698; yyj4698++ {
- yyh4698.ElemContainerState(yyj4698)
+ yyj4703 := 0
+ for ; yyj4703 < yyrr4703; yyj4703++ {
+ yyh4703.ElemContainerState(yyj4703)
if r.TryDecodeAsNil() {
- yyv4698[yyj4698] = ServicePort{}
+ yyv4703[yyj4703] = ServicePort{}
} else {
- yyv4699 := &yyv4698[yyj4698]
- yyv4699.CodecDecodeSelf(d)
+ yyv4704 := &yyv4703[yyj4703]
+ yyv4704.CodecDecodeSelf(d)
}
}
- if yyrt4698 {
- for ; yyj4698 < yyl4698; yyj4698++ {
- yyv4698 = append(yyv4698, ServicePort{})
- yyh4698.ElemContainerState(yyj4698)
+ if yyrt4703 {
+ for ; yyj4703 < yyl4703; yyj4703++ {
+ yyv4703 = append(yyv4703, ServicePort{})
+ yyh4703.ElemContainerState(yyj4703)
if r.TryDecodeAsNil() {
- yyv4698[yyj4698] = ServicePort{}
+ yyv4703[yyj4703] = ServicePort{}
} else {
- yyv4700 := &yyv4698[yyj4698]
- yyv4700.CodecDecodeSelf(d)
+ yyv4705 := &yyv4703[yyj4703]
+ yyv4705.CodecDecodeSelf(d)
}
}
}
} else {
- yyj4698 := 0
- for ; !r.CheckBreak(); yyj4698++ {
+ yyj4703 := 0
+ for ; !r.CheckBreak(); yyj4703++ {
- if yyj4698 >= len(yyv4698) {
- yyv4698 = append(yyv4698, ServicePort{}) // var yyz4698 ServicePort
- yyc4698 = true
+ if yyj4703 >= len(yyv4703) {
+ yyv4703 = append(yyv4703, ServicePort{}) // var yyz4703 ServicePort
+ yyc4703 = true
}
- yyh4698.ElemContainerState(yyj4698)
- if yyj4698 < len(yyv4698) {
+ yyh4703.ElemContainerState(yyj4703)
+ if yyj4703 < len(yyv4703) {
if r.TryDecodeAsNil() {
- yyv4698[yyj4698] = ServicePort{}
+ yyv4703[yyj4703] = ServicePort{}
} else {
- yyv4701 := &yyv4698[yyj4698]
- yyv4701.CodecDecodeSelf(d)
+ yyv4706 := &yyv4703[yyj4703]
+ yyv4706.CodecDecodeSelf(d)
}
} else {
@@ -59687,17 +59751,17 @@ func (x codecSelfer1234) decSliceServicePort(v *[]ServicePort, d *codec1978.Deco
}
}
- if yyj4698 < len(yyv4698) {
- yyv4698 = yyv4698[:yyj4698]
- yyc4698 = true
- } else if yyj4698 == 0 && yyv4698 == nil {
- yyv4698 = []ServicePort{}
- yyc4698 = true
+ if yyj4703 < len(yyv4703) {
+ yyv4703 = yyv4703[:yyj4703]
+ yyc4703 = true
+ } else if yyj4703 == 0 && yyv4703 == nil {
+ yyv4703 = []ServicePort{}
+ yyc4703 = true
}
}
- yyh4698.End()
- if yyc4698 {
- *v = yyv4698
+ yyh4703.End()
+ if yyc4703 {
+ *v = yyv4703
}
}
@@ -59706,10 +59770,10 @@ func (x codecSelfer1234) encSliceService(v []Service, e *codec1978.Encoder) {
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
r.EncodeArrayStart(len(v))
- for _, yyv4702 := range v {
+ for _, yyv4707 := range v {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy4703 := &yyv4702
- yy4703.CodecEncodeSelf(e)
+ yy4708 := &yyv4707
+ yy4708.CodecEncodeSelf(e)
}
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -59719,83 +59783,83 @@ func (x codecSelfer1234) decSliceService(v *[]Service, d *codec1978.Decoder) {
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yyv4704 := *v
- yyh4704, yyl4704 := z.DecSliceHelperStart()
- var yyc4704 bool
- if yyl4704 == 0 {
- if yyv4704 == nil {
- yyv4704 = []Service{}
- yyc4704 = true
- } else if len(yyv4704) != 0 {
- yyv4704 = yyv4704[:0]
- yyc4704 = true
+ yyv4709 := *v
+ yyh4709, yyl4709 := z.DecSliceHelperStart()
+ var yyc4709 bool
+ if yyl4709 == 0 {
+ if yyv4709 == nil {
+ yyv4709 = []Service{}
+ yyc4709 = true
+ } else if len(yyv4709) != 0 {
+ yyv4709 = yyv4709[:0]
+ yyc4709 = true
}
- } else if yyl4704 > 0 {
- var yyrr4704, yyrl4704 int
- var yyrt4704 bool
- if yyl4704 > cap(yyv4704) {
+ } else if yyl4709 > 0 {
+ var yyrr4709, yyrl4709 int
+ var yyrt4709 bool
+ if yyl4709 > cap(yyv4709) {
- yyrg4704 := len(yyv4704) > 0
- yyv24704 := yyv4704
- yyrl4704, yyrt4704 = z.DecInferLen(yyl4704, z.DecBasicHandle().MaxInitLen, 464)
- if yyrt4704 {
- if yyrl4704 <= cap(yyv4704) {
- yyv4704 = yyv4704[:yyrl4704]
+ yyrg4709 := len(yyv4709) > 0
+ yyv24709 := yyv4709
+ yyrl4709, yyrt4709 = z.DecInferLen(yyl4709, z.DecBasicHandle().MaxInitLen, 464)
+ if yyrt4709 {
+ if yyrl4709 <= cap(yyv4709) {
+ yyv4709 = yyv4709[:yyrl4709]
} else {
- yyv4704 = make([]Service, yyrl4704)
+ yyv4709 = make([]Service, yyrl4709)
}
} else {
- yyv4704 = make([]Service, yyrl4704)
+ yyv4709 = make([]Service, yyrl4709)
}
- yyc4704 = true
- yyrr4704 = len(yyv4704)
- if yyrg4704 {
- copy(yyv4704, yyv24704)
+ yyc4709 = true
+ yyrr4709 = len(yyv4709)
+ if yyrg4709 {
+ copy(yyv4709, yyv24709)
}
- } else if yyl4704 != len(yyv4704) {
- yyv4704 = yyv4704[:yyl4704]
- yyc4704 = true
+ } else if yyl4709 != len(yyv4709) {
+ yyv4709 = yyv4709[:yyl4709]
+ yyc4709 = true
}
- yyj4704 := 0
- for ; yyj4704 < yyrr4704; yyj4704++ {
- yyh4704.ElemContainerState(yyj4704)
+ yyj4709 := 0
+ for ; yyj4709 < yyrr4709; yyj4709++ {
+ yyh4709.ElemContainerState(yyj4709)
if r.TryDecodeAsNil() {
- yyv4704[yyj4704] = Service{}
+ yyv4709[yyj4709] = Service{}
} else {
- yyv4705 := &yyv4704[yyj4704]
- yyv4705.CodecDecodeSelf(d)
+ yyv4710 := &yyv4709[yyj4709]
+ yyv4710.CodecDecodeSelf(d)
}
}
- if yyrt4704 {
- for ; yyj4704 < yyl4704; yyj4704++ {
- yyv4704 = append(yyv4704, Service{})
- yyh4704.ElemContainerState(yyj4704)
+ if yyrt4709 {
+ for ; yyj4709 < yyl4709; yyj4709++ {
+ yyv4709 = append(yyv4709, Service{})
+ yyh4709.ElemContainerState(yyj4709)
if r.TryDecodeAsNil() {
- yyv4704[yyj4704] = Service{}
+ yyv4709[yyj4709] = Service{}
} else {
- yyv4706 := &yyv4704[yyj4704]
- yyv4706.CodecDecodeSelf(d)
+ yyv4711 := &yyv4709[yyj4709]
+ yyv4711.CodecDecodeSelf(d)
}
}
}
} else {
- yyj4704 := 0
- for ; !r.CheckBreak(); yyj4704++ {
+ yyj4709 := 0
+ for ; !r.CheckBreak(); yyj4709++ {
- if yyj4704 >= len(yyv4704) {
- yyv4704 = append(yyv4704, Service{}) // var yyz4704 Service
- yyc4704 = true
+ if yyj4709 >= len(yyv4709) {
+ yyv4709 = append(yyv4709, Service{}) // var yyz4709 Service
+ yyc4709 = true
}
- yyh4704.ElemContainerState(yyj4704)
- if yyj4704 < len(yyv4704) {
+ yyh4709.ElemContainerState(yyj4709)
+ if yyj4709 < len(yyv4709) {
if r.TryDecodeAsNil() {
- yyv4704[yyj4704] = Service{}
+ yyv4709[yyj4709] = Service{}
} else {
- yyv4707 := &yyv4704[yyj4704]
- yyv4707.CodecDecodeSelf(d)
+ yyv4712 := &yyv4709[yyj4709]
+ yyv4712.CodecDecodeSelf(d)
}
} else {
@@ -59803,17 +59867,17 @@ func (x codecSelfer1234) decSliceService(v *[]Service, d *codec1978.Decoder) {
}
}
- if yyj4704 < len(yyv4704) {
- yyv4704 = yyv4704[:yyj4704]
- yyc4704 = true
- } else if yyj4704 == 0 && yyv4704 == nil {
- yyv4704 = []Service{}
- yyc4704 = true
+ if yyj4709 < len(yyv4709) {
+ yyv4709 = yyv4709[:yyj4709]
+ yyc4709 = true
+ } else if yyj4709 == 0 && yyv4709 == nil {
+ yyv4709 = []Service{}
+ yyc4709 = true
}
}
- yyh4704.End()
- if yyc4704 {
- *v = yyv4704
+ yyh4709.End()
+ if yyc4709 {
+ *v = yyv4709
}
}
@@ -59822,10 +59886,10 @@ func (x codecSelfer1234) encSliceObjectReference(v []ObjectReference, e *codec19
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
r.EncodeArrayStart(len(v))
- for _, yyv4708 := range v {
+ for _, yyv4713 := range v {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy4709 := &yyv4708
- yy4709.CodecEncodeSelf(e)
+ yy4714 := &yyv4713
+ yy4714.CodecEncodeSelf(e)
}
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -59835,83 +59899,83 @@ func (x codecSelfer1234) decSliceObjectReference(v *[]ObjectReference, d *codec1
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yyv4710 := *v
- yyh4710, yyl4710 := z.DecSliceHelperStart()
- var yyc4710 bool
- if yyl4710 == 0 {
- if yyv4710 == nil {
- yyv4710 = []ObjectReference{}
- yyc4710 = true
- } else if len(yyv4710) != 0 {
- yyv4710 = yyv4710[:0]
- yyc4710 = true
+ yyv4715 := *v
+ yyh4715, yyl4715 := z.DecSliceHelperStart()
+ var yyc4715 bool
+ if yyl4715 == 0 {
+ if yyv4715 == nil {
+ yyv4715 = []ObjectReference{}
+ yyc4715 = true
+ } else if len(yyv4715) != 0 {
+ yyv4715 = yyv4715[:0]
+ yyc4715 = true
}
- } else if yyl4710 > 0 {
- var yyrr4710, yyrl4710 int
- var yyrt4710 bool
- if yyl4710 > cap(yyv4710) {
+ } else if yyl4715 > 0 {
+ var yyrr4715, yyrl4715 int
+ var yyrt4715 bool
+ if yyl4715 > cap(yyv4715) {
- yyrg4710 := len(yyv4710) > 0
- yyv24710 := yyv4710
- yyrl4710, yyrt4710 = z.DecInferLen(yyl4710, z.DecBasicHandle().MaxInitLen, 112)
- if yyrt4710 {
- if yyrl4710 <= cap(yyv4710) {
- yyv4710 = yyv4710[:yyrl4710]
+ yyrg4715 := len(yyv4715) > 0
+ yyv24715 := yyv4715
+ yyrl4715, yyrt4715 = z.DecInferLen(yyl4715, z.DecBasicHandle().MaxInitLen, 112)
+ if yyrt4715 {
+ if yyrl4715 <= cap(yyv4715) {
+ yyv4715 = yyv4715[:yyrl4715]
} else {
- yyv4710 = make([]ObjectReference, yyrl4710)
+ yyv4715 = make([]ObjectReference, yyrl4715)
}
} else {
- yyv4710 = make([]ObjectReference, yyrl4710)
+ yyv4715 = make([]ObjectReference, yyrl4715)
}
- yyc4710 = true
- yyrr4710 = len(yyv4710)
- if yyrg4710 {
- copy(yyv4710, yyv24710)
+ yyc4715 = true
+ yyrr4715 = len(yyv4715)
+ if yyrg4715 {
+ copy(yyv4715, yyv24715)
}
- } else if yyl4710 != len(yyv4710) {
- yyv4710 = yyv4710[:yyl4710]
- yyc4710 = true
+ } else if yyl4715 != len(yyv4715) {
+ yyv4715 = yyv4715[:yyl4715]
+ yyc4715 = true
}
- yyj4710 := 0
- for ; yyj4710 < yyrr4710; yyj4710++ {
- yyh4710.ElemContainerState(yyj4710)
+ yyj4715 := 0
+ for ; yyj4715 < yyrr4715; yyj4715++ {
+ yyh4715.ElemContainerState(yyj4715)
if r.TryDecodeAsNil() {
- yyv4710[yyj4710] = ObjectReference{}
+ yyv4715[yyj4715] = ObjectReference{}
} else {
- yyv4711 := &yyv4710[yyj4710]
- yyv4711.CodecDecodeSelf(d)
+ yyv4716 := &yyv4715[yyj4715]
+ yyv4716.CodecDecodeSelf(d)
}
}
- if yyrt4710 {
- for ; yyj4710 < yyl4710; yyj4710++ {
- yyv4710 = append(yyv4710, ObjectReference{})
- yyh4710.ElemContainerState(yyj4710)
+ if yyrt4715 {
+ for ; yyj4715 < yyl4715; yyj4715++ {
+ yyv4715 = append(yyv4715, ObjectReference{})
+ yyh4715.ElemContainerState(yyj4715)
if r.TryDecodeAsNil() {
- yyv4710[yyj4710] = ObjectReference{}
+ yyv4715[yyj4715] = ObjectReference{}
} else {
- yyv4712 := &yyv4710[yyj4710]
- yyv4712.CodecDecodeSelf(d)
+ yyv4717 := &yyv4715[yyj4715]
+ yyv4717.CodecDecodeSelf(d)
}
}
}
} else {
- yyj4710 := 0
- for ; !r.CheckBreak(); yyj4710++ {
+ yyj4715 := 0
+ for ; !r.CheckBreak(); yyj4715++ {
- if yyj4710 >= len(yyv4710) {
- yyv4710 = append(yyv4710, ObjectReference{}) // var yyz4710 ObjectReference
- yyc4710 = true
+ if yyj4715 >= len(yyv4715) {
+ yyv4715 = append(yyv4715, ObjectReference{}) // var yyz4715 ObjectReference
+ yyc4715 = true
}
- yyh4710.ElemContainerState(yyj4710)
- if yyj4710 < len(yyv4710) {
+ yyh4715.ElemContainerState(yyj4715)
+ if yyj4715 < len(yyv4715) {
if r.TryDecodeAsNil() {
- yyv4710[yyj4710] = ObjectReference{}
+ yyv4715[yyj4715] = ObjectReference{}
} else {
- yyv4713 := &yyv4710[yyj4710]
- yyv4713.CodecDecodeSelf(d)
+ yyv4718 := &yyv4715[yyj4715]
+ yyv4718.CodecDecodeSelf(d)
}
} else {
@@ -59919,17 +59983,17 @@ func (x codecSelfer1234) decSliceObjectReference(v *[]ObjectReference, d *codec1
}
}
- if yyj4710 < len(yyv4710) {
- yyv4710 = yyv4710[:yyj4710]
- yyc4710 = true
- } else if yyj4710 == 0 && yyv4710 == nil {
- yyv4710 = []ObjectReference{}
- yyc4710 = true
+ if yyj4715 < len(yyv4715) {
+ yyv4715 = yyv4715[:yyj4715]
+ yyc4715 = true
+ } else if yyj4715 == 0 && yyv4715 == nil {
+ yyv4715 = []ObjectReference{}
+ yyc4715 = true
}
}
- yyh4710.End()
- if yyc4710 {
- *v = yyv4710
+ yyh4715.End()
+ if yyc4715 {
+ *v = yyv4715
}
}
@@ -59938,10 +60002,10 @@ func (x codecSelfer1234) encSliceServiceAccount(v []ServiceAccount, e *codec1978
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
r.EncodeArrayStart(len(v))
- for _, yyv4714 := range v {
+ for _, yyv4719 := range v {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy4715 := &yyv4714
- yy4715.CodecEncodeSelf(e)
+ yy4720 := &yyv4719
+ yy4720.CodecEncodeSelf(e)
}
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -59951,83 +60015,83 @@ func (x codecSelfer1234) decSliceServiceAccount(v *[]ServiceAccount, d *codec197
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yyv4716 := *v
- yyh4716, yyl4716 := z.DecSliceHelperStart()
- var yyc4716 bool
- if yyl4716 == 0 {
- if yyv4716 == nil {
- yyv4716 = []ServiceAccount{}
- yyc4716 = true
- } else if len(yyv4716) != 0 {
- yyv4716 = yyv4716[:0]
- yyc4716 = true
+ yyv4721 := *v
+ yyh4721, yyl4721 := z.DecSliceHelperStart()
+ var yyc4721 bool
+ if yyl4721 == 0 {
+ if yyv4721 == nil {
+ yyv4721 = []ServiceAccount{}
+ yyc4721 = true
+ } else if len(yyv4721) != 0 {
+ yyv4721 = yyv4721[:0]
+ yyc4721 = true
}
- } else if yyl4716 > 0 {
- var yyrr4716, yyrl4716 int
- var yyrt4716 bool
- if yyl4716 > cap(yyv4716) {
+ } else if yyl4721 > 0 {
+ var yyrr4721, yyrl4721 int
+ var yyrt4721 bool
+ if yyl4721 > cap(yyv4721) {
- yyrg4716 := len(yyv4716) > 0
- yyv24716 := yyv4716
- yyrl4716, yyrt4716 = z.DecInferLen(yyl4716, z.DecBasicHandle().MaxInitLen, 304)
- if yyrt4716 {
- if yyrl4716 <= cap(yyv4716) {
- yyv4716 = yyv4716[:yyrl4716]
+ yyrg4721 := len(yyv4721) > 0
+ yyv24721 := yyv4721
+ yyrl4721, yyrt4721 = z.DecInferLen(yyl4721, z.DecBasicHandle().MaxInitLen, 304)
+ if yyrt4721 {
+ if yyrl4721 <= cap(yyv4721) {
+ yyv4721 = yyv4721[:yyrl4721]
} else {
- yyv4716 = make([]ServiceAccount, yyrl4716)
+ yyv4721 = make([]ServiceAccount, yyrl4721)
}
} else {
- yyv4716 = make([]ServiceAccount, yyrl4716)
+ yyv4721 = make([]ServiceAccount, yyrl4721)
}
- yyc4716 = true
- yyrr4716 = len(yyv4716)
- if yyrg4716 {
- copy(yyv4716, yyv24716)
+ yyc4721 = true
+ yyrr4721 = len(yyv4721)
+ if yyrg4721 {
+ copy(yyv4721, yyv24721)
}
- } else if yyl4716 != len(yyv4716) {
- yyv4716 = yyv4716[:yyl4716]
- yyc4716 = true
+ } else if yyl4721 != len(yyv4721) {
+ yyv4721 = yyv4721[:yyl4721]
+ yyc4721 = true
}
- yyj4716 := 0
- for ; yyj4716 < yyrr4716; yyj4716++ {
- yyh4716.ElemContainerState(yyj4716)
+ yyj4721 := 0
+ for ; yyj4721 < yyrr4721; yyj4721++ {
+ yyh4721.ElemContainerState(yyj4721)
if r.TryDecodeAsNil() {
- yyv4716[yyj4716] = ServiceAccount{}
+ yyv4721[yyj4721] = ServiceAccount{}
} else {
- yyv4717 := &yyv4716[yyj4716]
- yyv4717.CodecDecodeSelf(d)
+ yyv4722 := &yyv4721[yyj4721]
+ yyv4722.CodecDecodeSelf(d)
}
}
- if yyrt4716 {
- for ; yyj4716 < yyl4716; yyj4716++ {
- yyv4716 = append(yyv4716, ServiceAccount{})
- yyh4716.ElemContainerState(yyj4716)
+ if yyrt4721 {
+ for ; yyj4721 < yyl4721; yyj4721++ {
+ yyv4721 = append(yyv4721, ServiceAccount{})
+ yyh4721.ElemContainerState(yyj4721)
if r.TryDecodeAsNil() {
- yyv4716[yyj4716] = ServiceAccount{}
+ yyv4721[yyj4721] = ServiceAccount{}
} else {
- yyv4718 := &yyv4716[yyj4716]
- yyv4718.CodecDecodeSelf(d)
+ yyv4723 := &yyv4721[yyj4721]
+ yyv4723.CodecDecodeSelf(d)
}
}
}
} else {
- yyj4716 := 0
- for ; !r.CheckBreak(); yyj4716++ {
+ yyj4721 := 0
+ for ; !r.CheckBreak(); yyj4721++ {
- if yyj4716 >= len(yyv4716) {
- yyv4716 = append(yyv4716, ServiceAccount{}) // var yyz4716 ServiceAccount
- yyc4716 = true
+ if yyj4721 >= len(yyv4721) {
+ yyv4721 = append(yyv4721, ServiceAccount{}) // var yyz4721 ServiceAccount
+ yyc4721 = true
}
- yyh4716.ElemContainerState(yyj4716)
- if yyj4716 < len(yyv4716) {
+ yyh4721.ElemContainerState(yyj4721)
+ if yyj4721 < len(yyv4721) {
if r.TryDecodeAsNil() {
- yyv4716[yyj4716] = ServiceAccount{}
+ yyv4721[yyj4721] = ServiceAccount{}
} else {
- yyv4719 := &yyv4716[yyj4716]
- yyv4719.CodecDecodeSelf(d)
+ yyv4724 := &yyv4721[yyj4721]
+ yyv4724.CodecDecodeSelf(d)
}
} else {
@@ -60035,17 +60099,17 @@ func (x codecSelfer1234) decSliceServiceAccount(v *[]ServiceAccount, d *codec197
}
}
- if yyj4716 < len(yyv4716) {
- yyv4716 = yyv4716[:yyj4716]
- yyc4716 = true
- } else if yyj4716 == 0 && yyv4716 == nil {
- yyv4716 = []ServiceAccount{}
- yyc4716 = true
+ if yyj4721 < len(yyv4721) {
+ yyv4721 = yyv4721[:yyj4721]
+ yyc4721 = true
+ } else if yyj4721 == 0 && yyv4721 == nil {
+ yyv4721 = []ServiceAccount{}
+ yyc4721 = true
}
}
- yyh4716.End()
- if yyc4716 {
- *v = yyv4716
+ yyh4721.End()
+ if yyc4721 {
+ *v = yyv4721
}
}
@@ -60054,10 +60118,10 @@ func (x codecSelfer1234) encSliceEndpointSubset(v []EndpointSubset, e *codec1978
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
r.EncodeArrayStart(len(v))
- for _, yyv4720 := range v {
+ for _, yyv4725 := range v {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy4721 := &yyv4720
- yy4721.CodecEncodeSelf(e)
+ yy4726 := &yyv4725
+ yy4726.CodecEncodeSelf(e)
}
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -60067,83 +60131,83 @@ func (x codecSelfer1234) decSliceEndpointSubset(v *[]EndpointSubset, d *codec197
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yyv4722 := *v
- yyh4722, yyl4722 := z.DecSliceHelperStart()
- var yyc4722 bool
- if yyl4722 == 0 {
- if yyv4722 == nil {
- yyv4722 = []EndpointSubset{}
- yyc4722 = true
- } else if len(yyv4722) != 0 {
- yyv4722 = yyv4722[:0]
- yyc4722 = true
+ yyv4727 := *v
+ yyh4727, yyl4727 := z.DecSliceHelperStart()
+ var yyc4727 bool
+ if yyl4727 == 0 {
+ if yyv4727 == nil {
+ yyv4727 = []EndpointSubset{}
+ yyc4727 = true
+ } else if len(yyv4727) != 0 {
+ yyv4727 = yyv4727[:0]
+ yyc4727 = true
}
- } else if yyl4722 > 0 {
- var yyrr4722, yyrl4722 int
- var yyrt4722 bool
- if yyl4722 > cap(yyv4722) {
+ } else if yyl4727 > 0 {
+ var yyrr4727, yyrl4727 int
+ var yyrt4727 bool
+ if yyl4727 > cap(yyv4727) {
- yyrg4722 := len(yyv4722) > 0
- yyv24722 := yyv4722
- yyrl4722, yyrt4722 = z.DecInferLen(yyl4722, z.DecBasicHandle().MaxInitLen, 72)
- if yyrt4722 {
- if yyrl4722 <= cap(yyv4722) {
- yyv4722 = yyv4722[:yyrl4722]
+ yyrg4727 := len(yyv4727) > 0
+ yyv24727 := yyv4727
+ yyrl4727, yyrt4727 = z.DecInferLen(yyl4727, z.DecBasicHandle().MaxInitLen, 72)
+ if yyrt4727 {
+ if yyrl4727 <= cap(yyv4727) {
+ yyv4727 = yyv4727[:yyrl4727]
} else {
- yyv4722 = make([]EndpointSubset, yyrl4722)
+ yyv4727 = make([]EndpointSubset, yyrl4727)
}
} else {
- yyv4722 = make([]EndpointSubset, yyrl4722)
+ yyv4727 = make([]EndpointSubset, yyrl4727)
}
- yyc4722 = true
- yyrr4722 = len(yyv4722)
- if yyrg4722 {
- copy(yyv4722, yyv24722)
+ yyc4727 = true
+ yyrr4727 = len(yyv4727)
+ if yyrg4727 {
+ copy(yyv4727, yyv24727)
}
- } else if yyl4722 != len(yyv4722) {
- yyv4722 = yyv4722[:yyl4722]
- yyc4722 = true
+ } else if yyl4727 != len(yyv4727) {
+ yyv4727 = yyv4727[:yyl4727]
+ yyc4727 = true
}
- yyj4722 := 0
- for ; yyj4722 < yyrr4722; yyj4722++ {
- yyh4722.ElemContainerState(yyj4722)
+ yyj4727 := 0
+ for ; yyj4727 < yyrr4727; yyj4727++ {
+ yyh4727.ElemContainerState(yyj4727)
if r.TryDecodeAsNil() {
- yyv4722[yyj4722] = EndpointSubset{}
+ yyv4727[yyj4727] = EndpointSubset{}
} else {
- yyv4723 := &yyv4722[yyj4722]
- yyv4723.CodecDecodeSelf(d)
+ yyv4728 := &yyv4727[yyj4727]
+ yyv4728.CodecDecodeSelf(d)
}
}
- if yyrt4722 {
- for ; yyj4722 < yyl4722; yyj4722++ {
- yyv4722 = append(yyv4722, EndpointSubset{})
- yyh4722.ElemContainerState(yyj4722)
+ if yyrt4727 {
+ for ; yyj4727 < yyl4727; yyj4727++ {
+ yyv4727 = append(yyv4727, EndpointSubset{})
+ yyh4727.ElemContainerState(yyj4727)
if r.TryDecodeAsNil() {
- yyv4722[yyj4722] = EndpointSubset{}
+ yyv4727[yyj4727] = EndpointSubset{}
} else {
- yyv4724 := &yyv4722[yyj4722]
- yyv4724.CodecDecodeSelf(d)
+ yyv4729 := &yyv4727[yyj4727]
+ yyv4729.CodecDecodeSelf(d)
}
}
}
} else {
- yyj4722 := 0
- for ; !r.CheckBreak(); yyj4722++ {
+ yyj4727 := 0
+ for ; !r.CheckBreak(); yyj4727++ {
- if yyj4722 >= len(yyv4722) {
- yyv4722 = append(yyv4722, EndpointSubset{}) // var yyz4722 EndpointSubset
- yyc4722 = true
+ if yyj4727 >= len(yyv4727) {
+ yyv4727 = append(yyv4727, EndpointSubset{}) // var yyz4727 EndpointSubset
+ yyc4727 = true
}
- yyh4722.ElemContainerState(yyj4722)
- if yyj4722 < len(yyv4722) {
+ yyh4727.ElemContainerState(yyj4727)
+ if yyj4727 < len(yyv4727) {
if r.TryDecodeAsNil() {
- yyv4722[yyj4722] = EndpointSubset{}
+ yyv4727[yyj4727] = EndpointSubset{}
} else {
- yyv4725 := &yyv4722[yyj4722]
- yyv4725.CodecDecodeSelf(d)
+ yyv4730 := &yyv4727[yyj4727]
+ yyv4730.CodecDecodeSelf(d)
}
} else {
@@ -60151,17 +60215,17 @@ func (x codecSelfer1234) decSliceEndpointSubset(v *[]EndpointSubset, d *codec197
}
}
- if yyj4722 < len(yyv4722) {
- yyv4722 = yyv4722[:yyj4722]
- yyc4722 = true
- } else if yyj4722 == 0 && yyv4722 == nil {
- yyv4722 = []EndpointSubset{}
- yyc4722 = true
+ if yyj4727 < len(yyv4727) {
+ yyv4727 = yyv4727[:yyj4727]
+ yyc4727 = true
+ } else if yyj4727 == 0 && yyv4727 == nil {
+ yyv4727 = []EndpointSubset{}
+ yyc4727 = true
}
}
- yyh4722.End()
- if yyc4722 {
- *v = yyv4722
+ yyh4727.End()
+ if yyc4727 {
+ *v = yyv4727
}
}
@@ -60170,10 +60234,10 @@ func (x codecSelfer1234) encSliceEndpointAddress(v []EndpointAddress, e *codec19
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
r.EncodeArrayStart(len(v))
- for _, yyv4726 := range v {
+ for _, yyv4731 := range v {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy4727 := &yyv4726
- yy4727.CodecEncodeSelf(e)
+ yy4732 := &yyv4731
+ yy4732.CodecEncodeSelf(e)
}
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -60183,83 +60247,83 @@ func (x codecSelfer1234) decSliceEndpointAddress(v *[]EndpointAddress, d *codec1
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yyv4728 := *v
- yyh4728, yyl4728 := z.DecSliceHelperStart()
- var yyc4728 bool
- if yyl4728 == 0 {
- if yyv4728 == nil {
- yyv4728 = []EndpointAddress{}
- yyc4728 = true
- } else if len(yyv4728) != 0 {
- yyv4728 = yyv4728[:0]
- yyc4728 = true
+ yyv4733 := *v
+ yyh4733, yyl4733 := z.DecSliceHelperStart()
+ var yyc4733 bool
+ if yyl4733 == 0 {
+ if yyv4733 == nil {
+ yyv4733 = []EndpointAddress{}
+ yyc4733 = true
+ } else if len(yyv4733) != 0 {
+ yyv4733 = yyv4733[:0]
+ yyc4733 = true
}
- } else if yyl4728 > 0 {
- var yyrr4728, yyrl4728 int
- var yyrt4728 bool
- if yyl4728 > cap(yyv4728) {
+ } else if yyl4733 > 0 {
+ var yyrr4733, yyrl4733 int
+ var yyrt4733 bool
+ if yyl4733 > cap(yyv4733) {
- yyrg4728 := len(yyv4728) > 0
- yyv24728 := yyv4728
- yyrl4728, yyrt4728 = z.DecInferLen(yyl4728, z.DecBasicHandle().MaxInitLen, 48)
- if yyrt4728 {
- if yyrl4728 <= cap(yyv4728) {
- yyv4728 = yyv4728[:yyrl4728]
+ yyrg4733 := len(yyv4733) > 0
+ yyv24733 := yyv4733
+ yyrl4733, yyrt4733 = z.DecInferLen(yyl4733, z.DecBasicHandle().MaxInitLen, 48)
+ if yyrt4733 {
+ if yyrl4733 <= cap(yyv4733) {
+ yyv4733 = yyv4733[:yyrl4733]
} else {
- yyv4728 = make([]EndpointAddress, yyrl4728)
+ yyv4733 = make([]EndpointAddress, yyrl4733)
}
} else {
- yyv4728 = make([]EndpointAddress, yyrl4728)
+ yyv4733 = make([]EndpointAddress, yyrl4733)
}
- yyc4728 = true
- yyrr4728 = len(yyv4728)
- if yyrg4728 {
- copy(yyv4728, yyv24728)
+ yyc4733 = true
+ yyrr4733 = len(yyv4733)
+ if yyrg4733 {
+ copy(yyv4733, yyv24733)
}
- } else if yyl4728 != len(yyv4728) {
- yyv4728 = yyv4728[:yyl4728]
- yyc4728 = true
+ } else if yyl4733 != len(yyv4733) {
+ yyv4733 = yyv4733[:yyl4733]
+ yyc4733 = true
}
- yyj4728 := 0
- for ; yyj4728 < yyrr4728; yyj4728++ {
- yyh4728.ElemContainerState(yyj4728)
+ yyj4733 := 0
+ for ; yyj4733 < yyrr4733; yyj4733++ {
+ yyh4733.ElemContainerState(yyj4733)
if r.TryDecodeAsNil() {
- yyv4728[yyj4728] = EndpointAddress{}
+ yyv4733[yyj4733] = EndpointAddress{}
} else {
- yyv4729 := &yyv4728[yyj4728]
- yyv4729.CodecDecodeSelf(d)
+ yyv4734 := &yyv4733[yyj4733]
+ yyv4734.CodecDecodeSelf(d)
}
}
- if yyrt4728 {
- for ; yyj4728 < yyl4728; yyj4728++ {
- yyv4728 = append(yyv4728, EndpointAddress{})
- yyh4728.ElemContainerState(yyj4728)
+ if yyrt4733 {
+ for ; yyj4733 < yyl4733; yyj4733++ {
+ yyv4733 = append(yyv4733, EndpointAddress{})
+ yyh4733.ElemContainerState(yyj4733)
if r.TryDecodeAsNil() {
- yyv4728[yyj4728] = EndpointAddress{}
+ yyv4733[yyj4733] = EndpointAddress{}
} else {
- yyv4730 := &yyv4728[yyj4728]
- yyv4730.CodecDecodeSelf(d)
+ yyv4735 := &yyv4733[yyj4733]
+ yyv4735.CodecDecodeSelf(d)
}
}
}
} else {
- yyj4728 := 0
- for ; !r.CheckBreak(); yyj4728++ {
+ yyj4733 := 0
+ for ; !r.CheckBreak(); yyj4733++ {
- if yyj4728 >= len(yyv4728) {
- yyv4728 = append(yyv4728, EndpointAddress{}) // var yyz4728 EndpointAddress
- yyc4728 = true
+ if yyj4733 >= len(yyv4733) {
+ yyv4733 = append(yyv4733, EndpointAddress{}) // var yyz4733 EndpointAddress
+ yyc4733 = true
}
- yyh4728.ElemContainerState(yyj4728)
- if yyj4728 < len(yyv4728) {
+ yyh4733.ElemContainerState(yyj4733)
+ if yyj4733 < len(yyv4733) {
if r.TryDecodeAsNil() {
- yyv4728[yyj4728] = EndpointAddress{}
+ yyv4733[yyj4733] = EndpointAddress{}
} else {
- yyv4731 := &yyv4728[yyj4728]
- yyv4731.CodecDecodeSelf(d)
+ yyv4736 := &yyv4733[yyj4733]
+ yyv4736.CodecDecodeSelf(d)
}
} else {
@@ -60267,17 +60331,17 @@ func (x codecSelfer1234) decSliceEndpointAddress(v *[]EndpointAddress, d *codec1
}
}
- if yyj4728 < len(yyv4728) {
- yyv4728 = yyv4728[:yyj4728]
- yyc4728 = true
- } else if yyj4728 == 0 && yyv4728 == nil {
- yyv4728 = []EndpointAddress{}
- yyc4728 = true
+ if yyj4733 < len(yyv4733) {
+ yyv4733 = yyv4733[:yyj4733]
+ yyc4733 = true
+ } else if yyj4733 == 0 && yyv4733 == nil {
+ yyv4733 = []EndpointAddress{}
+ yyc4733 = true
}
}
- yyh4728.End()
- if yyc4728 {
- *v = yyv4728
+ yyh4733.End()
+ if yyc4733 {
+ *v = yyv4733
}
}
@@ -60286,10 +60350,10 @@ func (x codecSelfer1234) encSliceEndpointPort(v []EndpointPort, e *codec1978.Enc
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
r.EncodeArrayStart(len(v))
- for _, yyv4732 := range v {
+ for _, yyv4737 := range v {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy4733 := &yyv4732
- yy4733.CodecEncodeSelf(e)
+ yy4738 := &yyv4737
+ yy4738.CodecEncodeSelf(e)
}
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -60299,83 +60363,83 @@ func (x codecSelfer1234) decSliceEndpointPort(v *[]EndpointPort, d *codec1978.De
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yyv4734 := *v
- yyh4734, yyl4734 := z.DecSliceHelperStart()
- var yyc4734 bool
- if yyl4734 == 0 {
- if yyv4734 == nil {
- yyv4734 = []EndpointPort{}
- yyc4734 = true
- } else if len(yyv4734) != 0 {
- yyv4734 = yyv4734[:0]
- yyc4734 = true
+ yyv4739 := *v
+ yyh4739, yyl4739 := z.DecSliceHelperStart()
+ var yyc4739 bool
+ if yyl4739 == 0 {
+ if yyv4739 == nil {
+ yyv4739 = []EndpointPort{}
+ yyc4739 = true
+ } else if len(yyv4739) != 0 {
+ yyv4739 = yyv4739[:0]
+ yyc4739 = true
}
- } else if yyl4734 > 0 {
- var yyrr4734, yyrl4734 int
- var yyrt4734 bool
- if yyl4734 > cap(yyv4734) {
+ } else if yyl4739 > 0 {
+ var yyrr4739, yyrl4739 int
+ var yyrt4739 bool
+ if yyl4739 > cap(yyv4739) {
- yyrg4734 := len(yyv4734) > 0
- yyv24734 := yyv4734
- yyrl4734, yyrt4734 = z.DecInferLen(yyl4734, z.DecBasicHandle().MaxInitLen, 40)
- if yyrt4734 {
- if yyrl4734 <= cap(yyv4734) {
- yyv4734 = yyv4734[:yyrl4734]
+ yyrg4739 := len(yyv4739) > 0
+ yyv24739 := yyv4739
+ yyrl4739, yyrt4739 = z.DecInferLen(yyl4739, z.DecBasicHandle().MaxInitLen, 40)
+ if yyrt4739 {
+ if yyrl4739 <= cap(yyv4739) {
+ yyv4739 = yyv4739[:yyrl4739]
} else {
- yyv4734 = make([]EndpointPort, yyrl4734)
+ yyv4739 = make([]EndpointPort, yyrl4739)
}
} else {
- yyv4734 = make([]EndpointPort, yyrl4734)
+ yyv4739 = make([]EndpointPort, yyrl4739)
}
- yyc4734 = true
- yyrr4734 = len(yyv4734)
- if yyrg4734 {
- copy(yyv4734, yyv24734)
+ yyc4739 = true
+ yyrr4739 = len(yyv4739)
+ if yyrg4739 {
+ copy(yyv4739, yyv24739)
}
- } else if yyl4734 != len(yyv4734) {
- yyv4734 = yyv4734[:yyl4734]
- yyc4734 = true
+ } else if yyl4739 != len(yyv4739) {
+ yyv4739 = yyv4739[:yyl4739]
+ yyc4739 = true
}
- yyj4734 := 0
- for ; yyj4734 < yyrr4734; yyj4734++ {
- yyh4734.ElemContainerState(yyj4734)
+ yyj4739 := 0
+ for ; yyj4739 < yyrr4739; yyj4739++ {
+ yyh4739.ElemContainerState(yyj4739)
if r.TryDecodeAsNil() {
- yyv4734[yyj4734] = EndpointPort{}
+ yyv4739[yyj4739] = EndpointPort{}
} else {
- yyv4735 := &yyv4734[yyj4734]
- yyv4735.CodecDecodeSelf(d)
+ yyv4740 := &yyv4739[yyj4739]
+ yyv4740.CodecDecodeSelf(d)
}
}
- if yyrt4734 {
- for ; yyj4734 < yyl4734; yyj4734++ {
- yyv4734 = append(yyv4734, EndpointPort{})
- yyh4734.ElemContainerState(yyj4734)
+ if yyrt4739 {
+ for ; yyj4739 < yyl4739; yyj4739++ {
+ yyv4739 = append(yyv4739, EndpointPort{})
+ yyh4739.ElemContainerState(yyj4739)
if r.TryDecodeAsNil() {
- yyv4734[yyj4734] = EndpointPort{}
+ yyv4739[yyj4739] = EndpointPort{}
} else {
- yyv4736 := &yyv4734[yyj4734]
- yyv4736.CodecDecodeSelf(d)
+ yyv4741 := &yyv4739[yyj4739]
+ yyv4741.CodecDecodeSelf(d)
}
}
}
} else {
- yyj4734 := 0
- for ; !r.CheckBreak(); yyj4734++ {
+ yyj4739 := 0
+ for ; !r.CheckBreak(); yyj4739++ {
- if yyj4734 >= len(yyv4734) {
- yyv4734 = append(yyv4734, EndpointPort{}) // var yyz4734 EndpointPort
- yyc4734 = true
+ if yyj4739 >= len(yyv4739) {
+ yyv4739 = append(yyv4739, EndpointPort{}) // var yyz4739 EndpointPort
+ yyc4739 = true
}
- yyh4734.ElemContainerState(yyj4734)
- if yyj4734 < len(yyv4734) {
+ yyh4739.ElemContainerState(yyj4739)
+ if yyj4739 < len(yyv4739) {
if r.TryDecodeAsNil() {
- yyv4734[yyj4734] = EndpointPort{}
+ yyv4739[yyj4739] = EndpointPort{}
} else {
- yyv4737 := &yyv4734[yyj4734]
- yyv4737.CodecDecodeSelf(d)
+ yyv4742 := &yyv4739[yyj4739]
+ yyv4742.CodecDecodeSelf(d)
}
} else {
@@ -60383,17 +60447,17 @@ func (x codecSelfer1234) decSliceEndpointPort(v *[]EndpointPort, d *codec1978.De
}
}
- if yyj4734 < len(yyv4734) {
- yyv4734 = yyv4734[:yyj4734]
- yyc4734 = true
- } else if yyj4734 == 0 && yyv4734 == nil {
- yyv4734 = []EndpointPort{}
- yyc4734 = true
+ if yyj4739 < len(yyv4739) {
+ yyv4739 = yyv4739[:yyj4739]
+ yyc4739 = true
+ } else if yyj4739 == 0 && yyv4739 == nil {
+ yyv4739 = []EndpointPort{}
+ yyc4739 = true
}
}
- yyh4734.End()
- if yyc4734 {
- *v = yyv4734
+ yyh4739.End()
+ if yyc4739 {
+ *v = yyv4739
}
}
@@ -60402,10 +60466,10 @@ func (x codecSelfer1234) encSliceEndpoints(v []Endpoints, e *codec1978.Encoder)
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
r.EncodeArrayStart(len(v))
- for _, yyv4738 := range v {
+ for _, yyv4743 := range v {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy4739 := &yyv4738
- yy4739.CodecEncodeSelf(e)
+ yy4744 := &yyv4743
+ yy4744.CodecEncodeSelf(e)
}
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -60415,83 +60479,83 @@ func (x codecSelfer1234) decSliceEndpoints(v *[]Endpoints, d *codec1978.Decoder)
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yyv4740 := *v
- yyh4740, yyl4740 := z.DecSliceHelperStart()
- var yyc4740 bool
- if yyl4740 == 0 {
- if yyv4740 == nil {
- yyv4740 = []Endpoints{}
- yyc4740 = true
- } else if len(yyv4740) != 0 {
- yyv4740 = yyv4740[:0]
- yyc4740 = true
+ yyv4745 := *v
+ yyh4745, yyl4745 := z.DecSliceHelperStart()
+ var yyc4745 bool
+ if yyl4745 == 0 {
+ if yyv4745 == nil {
+ yyv4745 = []Endpoints{}
+ yyc4745 = true
+ } else if len(yyv4745) != 0 {
+ yyv4745 = yyv4745[:0]
+ yyc4745 = true
}
- } else if yyl4740 > 0 {
- var yyrr4740, yyrl4740 int
- var yyrt4740 bool
- if yyl4740 > cap(yyv4740) {
+ } else if yyl4745 > 0 {
+ var yyrr4745, yyrl4745 int
+ var yyrt4745 bool
+ if yyl4745 > cap(yyv4745) {
- yyrg4740 := len(yyv4740) > 0
- yyv24740 := yyv4740
- yyrl4740, yyrt4740 = z.DecInferLen(yyl4740, z.DecBasicHandle().MaxInitLen, 280)
- if yyrt4740 {
- if yyrl4740 <= cap(yyv4740) {
- yyv4740 = yyv4740[:yyrl4740]
+ yyrg4745 := len(yyv4745) > 0
+ yyv24745 := yyv4745
+ yyrl4745, yyrt4745 = z.DecInferLen(yyl4745, z.DecBasicHandle().MaxInitLen, 280)
+ if yyrt4745 {
+ if yyrl4745 <= cap(yyv4745) {
+ yyv4745 = yyv4745[:yyrl4745]
} else {
- yyv4740 = make([]Endpoints, yyrl4740)
+ yyv4745 = make([]Endpoints, yyrl4745)
}
} else {
- yyv4740 = make([]Endpoints, yyrl4740)
+ yyv4745 = make([]Endpoints, yyrl4745)
}
- yyc4740 = true
- yyrr4740 = len(yyv4740)
- if yyrg4740 {
- copy(yyv4740, yyv24740)
+ yyc4745 = true
+ yyrr4745 = len(yyv4745)
+ if yyrg4745 {
+ copy(yyv4745, yyv24745)
}
- } else if yyl4740 != len(yyv4740) {
- yyv4740 = yyv4740[:yyl4740]
- yyc4740 = true
+ } else if yyl4745 != len(yyv4745) {
+ yyv4745 = yyv4745[:yyl4745]
+ yyc4745 = true
}
- yyj4740 := 0
- for ; yyj4740 < yyrr4740; yyj4740++ {
- yyh4740.ElemContainerState(yyj4740)
+ yyj4745 := 0
+ for ; yyj4745 < yyrr4745; yyj4745++ {
+ yyh4745.ElemContainerState(yyj4745)
if r.TryDecodeAsNil() {
- yyv4740[yyj4740] = Endpoints{}
+ yyv4745[yyj4745] = Endpoints{}
} else {
- yyv4741 := &yyv4740[yyj4740]
- yyv4741.CodecDecodeSelf(d)
+ yyv4746 := &yyv4745[yyj4745]
+ yyv4746.CodecDecodeSelf(d)
}
}
- if yyrt4740 {
- for ; yyj4740 < yyl4740; yyj4740++ {
- yyv4740 = append(yyv4740, Endpoints{})
- yyh4740.ElemContainerState(yyj4740)
+ if yyrt4745 {
+ for ; yyj4745 < yyl4745; yyj4745++ {
+ yyv4745 = append(yyv4745, Endpoints{})
+ yyh4745.ElemContainerState(yyj4745)
if r.TryDecodeAsNil() {
- yyv4740[yyj4740] = Endpoints{}
+ yyv4745[yyj4745] = Endpoints{}
} else {
- yyv4742 := &yyv4740[yyj4740]
- yyv4742.CodecDecodeSelf(d)
+ yyv4747 := &yyv4745[yyj4745]
+ yyv4747.CodecDecodeSelf(d)
}
}
}
} else {
- yyj4740 := 0
- for ; !r.CheckBreak(); yyj4740++ {
+ yyj4745 := 0
+ for ; !r.CheckBreak(); yyj4745++ {
- if yyj4740 >= len(yyv4740) {
- yyv4740 = append(yyv4740, Endpoints{}) // var yyz4740 Endpoints
- yyc4740 = true
+ if yyj4745 >= len(yyv4745) {
+ yyv4745 = append(yyv4745, Endpoints{}) // var yyz4745 Endpoints
+ yyc4745 = true
}
- yyh4740.ElemContainerState(yyj4740)
- if yyj4740 < len(yyv4740) {
+ yyh4745.ElemContainerState(yyj4745)
+ if yyj4745 < len(yyv4745) {
if r.TryDecodeAsNil() {
- yyv4740[yyj4740] = Endpoints{}
+ yyv4745[yyj4745] = Endpoints{}
} else {
- yyv4743 := &yyv4740[yyj4740]
- yyv4743.CodecDecodeSelf(d)
+ yyv4748 := &yyv4745[yyj4745]
+ yyv4748.CodecDecodeSelf(d)
}
} else {
@@ -60499,17 +60563,17 @@ func (x codecSelfer1234) decSliceEndpoints(v *[]Endpoints, d *codec1978.Decoder)
}
}
- if yyj4740 < len(yyv4740) {
- yyv4740 = yyv4740[:yyj4740]
- yyc4740 = true
- } else if yyj4740 == 0 && yyv4740 == nil {
- yyv4740 = []Endpoints{}
- yyc4740 = true
+ if yyj4745 < len(yyv4745) {
+ yyv4745 = yyv4745[:yyj4745]
+ yyc4745 = true
+ } else if yyj4745 == 0 && yyv4745 == nil {
+ yyv4745 = []Endpoints{}
+ yyc4745 = true
}
}
- yyh4740.End()
- if yyc4740 {
- *v = yyv4740
+ yyh4745.End()
+ if yyc4745 {
+ *v = yyv4745
}
}
@@ -60518,10 +60582,10 @@ func (x codecSelfer1234) encSliceNodeCondition(v []NodeCondition, e *codec1978.E
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
r.EncodeArrayStart(len(v))
- for _, yyv4744 := range v {
+ for _, yyv4749 := range v {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy4745 := &yyv4744
- yy4745.CodecEncodeSelf(e)
+ yy4750 := &yyv4749
+ yy4750.CodecEncodeSelf(e)
}
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -60531,83 +60595,83 @@ func (x codecSelfer1234) decSliceNodeCondition(v *[]NodeCondition, d *codec1978.
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yyv4746 := *v
- yyh4746, yyl4746 := z.DecSliceHelperStart()
- var yyc4746 bool
- if yyl4746 == 0 {
- if yyv4746 == nil {
- yyv4746 = []NodeCondition{}
- yyc4746 = true
- } else if len(yyv4746) != 0 {
- yyv4746 = yyv4746[:0]
- yyc4746 = true
+ yyv4751 := *v
+ yyh4751, yyl4751 := z.DecSliceHelperStart()
+ var yyc4751 bool
+ if yyl4751 == 0 {
+ if yyv4751 == nil {
+ yyv4751 = []NodeCondition{}
+ yyc4751 = true
+ } else if len(yyv4751) != 0 {
+ yyv4751 = yyv4751[:0]
+ yyc4751 = true
}
- } else if yyl4746 > 0 {
- var yyrr4746, yyrl4746 int
- var yyrt4746 bool
- if yyl4746 > cap(yyv4746) {
+ } else if yyl4751 > 0 {
+ var yyrr4751, yyrl4751 int
+ var yyrt4751 bool
+ if yyl4751 > cap(yyv4751) {
- yyrg4746 := len(yyv4746) > 0
- yyv24746 := yyv4746
- yyrl4746, yyrt4746 = z.DecInferLen(yyl4746, z.DecBasicHandle().MaxInitLen, 112)
- if yyrt4746 {
- if yyrl4746 <= cap(yyv4746) {
- yyv4746 = yyv4746[:yyrl4746]
+ yyrg4751 := len(yyv4751) > 0
+ yyv24751 := yyv4751
+ yyrl4751, yyrt4751 = z.DecInferLen(yyl4751, z.DecBasicHandle().MaxInitLen, 112)
+ if yyrt4751 {
+ if yyrl4751 <= cap(yyv4751) {
+ yyv4751 = yyv4751[:yyrl4751]
} else {
- yyv4746 = make([]NodeCondition, yyrl4746)
+ yyv4751 = make([]NodeCondition, yyrl4751)
}
} else {
- yyv4746 = make([]NodeCondition, yyrl4746)
+ yyv4751 = make([]NodeCondition, yyrl4751)
}
- yyc4746 = true
- yyrr4746 = len(yyv4746)
- if yyrg4746 {
- copy(yyv4746, yyv24746)
+ yyc4751 = true
+ yyrr4751 = len(yyv4751)
+ if yyrg4751 {
+ copy(yyv4751, yyv24751)
}
- } else if yyl4746 != len(yyv4746) {
- yyv4746 = yyv4746[:yyl4746]
- yyc4746 = true
+ } else if yyl4751 != len(yyv4751) {
+ yyv4751 = yyv4751[:yyl4751]
+ yyc4751 = true
}
- yyj4746 := 0
- for ; yyj4746 < yyrr4746; yyj4746++ {
- yyh4746.ElemContainerState(yyj4746)
+ yyj4751 := 0
+ for ; yyj4751 < yyrr4751; yyj4751++ {
+ yyh4751.ElemContainerState(yyj4751)
if r.TryDecodeAsNil() {
- yyv4746[yyj4746] = NodeCondition{}
+ yyv4751[yyj4751] = NodeCondition{}
} else {
- yyv4747 := &yyv4746[yyj4746]
- yyv4747.CodecDecodeSelf(d)
+ yyv4752 := &yyv4751[yyj4751]
+ yyv4752.CodecDecodeSelf(d)
}
}
- if yyrt4746 {
- for ; yyj4746 < yyl4746; yyj4746++ {
- yyv4746 = append(yyv4746, NodeCondition{})
- yyh4746.ElemContainerState(yyj4746)
+ if yyrt4751 {
+ for ; yyj4751 < yyl4751; yyj4751++ {
+ yyv4751 = append(yyv4751, NodeCondition{})
+ yyh4751.ElemContainerState(yyj4751)
if r.TryDecodeAsNil() {
- yyv4746[yyj4746] = NodeCondition{}
+ yyv4751[yyj4751] = NodeCondition{}
} else {
- yyv4748 := &yyv4746[yyj4746]
- yyv4748.CodecDecodeSelf(d)
+ yyv4753 := &yyv4751[yyj4751]
+ yyv4753.CodecDecodeSelf(d)
}
}
}
} else {
- yyj4746 := 0
- for ; !r.CheckBreak(); yyj4746++ {
+ yyj4751 := 0
+ for ; !r.CheckBreak(); yyj4751++ {
- if yyj4746 >= len(yyv4746) {
- yyv4746 = append(yyv4746, NodeCondition{}) // var yyz4746 NodeCondition
- yyc4746 = true
+ if yyj4751 >= len(yyv4751) {
+ yyv4751 = append(yyv4751, NodeCondition{}) // var yyz4751 NodeCondition
+ yyc4751 = true
}
- yyh4746.ElemContainerState(yyj4746)
- if yyj4746 < len(yyv4746) {
+ yyh4751.ElemContainerState(yyj4751)
+ if yyj4751 < len(yyv4751) {
if r.TryDecodeAsNil() {
- yyv4746[yyj4746] = NodeCondition{}
+ yyv4751[yyj4751] = NodeCondition{}
} else {
- yyv4749 := &yyv4746[yyj4746]
- yyv4749.CodecDecodeSelf(d)
+ yyv4754 := &yyv4751[yyj4751]
+ yyv4754.CodecDecodeSelf(d)
}
} else {
@@ -60615,17 +60679,17 @@ func (x codecSelfer1234) decSliceNodeCondition(v *[]NodeCondition, d *codec1978.
}
}
- if yyj4746 < len(yyv4746) {
- yyv4746 = yyv4746[:yyj4746]
- yyc4746 = true
- } else if yyj4746 == 0 && yyv4746 == nil {
- yyv4746 = []NodeCondition{}
- yyc4746 = true
+ if yyj4751 < len(yyv4751) {
+ yyv4751 = yyv4751[:yyj4751]
+ yyc4751 = true
+ } else if yyj4751 == 0 && yyv4751 == nil {
+ yyv4751 = []NodeCondition{}
+ yyc4751 = true
}
}
- yyh4746.End()
- if yyc4746 {
- *v = yyv4746
+ yyh4751.End()
+ if yyc4751 {
+ *v = yyv4751
}
}
@@ -60634,10 +60698,10 @@ func (x codecSelfer1234) encSliceNodeAddress(v []NodeAddress, e *codec1978.Encod
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
r.EncodeArrayStart(len(v))
- for _, yyv4750 := range v {
+ for _, yyv4755 := range v {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy4751 := &yyv4750
- yy4751.CodecEncodeSelf(e)
+ yy4756 := &yyv4755
+ yy4756.CodecEncodeSelf(e)
}
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -60647,83 +60711,83 @@ func (x codecSelfer1234) decSliceNodeAddress(v *[]NodeAddress, d *codec1978.Deco
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yyv4752 := *v
- yyh4752, yyl4752 := z.DecSliceHelperStart()
- var yyc4752 bool
- if yyl4752 == 0 {
- if yyv4752 == nil {
- yyv4752 = []NodeAddress{}
- yyc4752 = true
- } else if len(yyv4752) != 0 {
- yyv4752 = yyv4752[:0]
- yyc4752 = true
+ yyv4757 := *v
+ yyh4757, yyl4757 := z.DecSliceHelperStart()
+ var yyc4757 bool
+ if yyl4757 == 0 {
+ if yyv4757 == nil {
+ yyv4757 = []NodeAddress{}
+ yyc4757 = true
+ } else if len(yyv4757) != 0 {
+ yyv4757 = yyv4757[:0]
+ yyc4757 = true
}
- } else if yyl4752 > 0 {
- var yyrr4752, yyrl4752 int
- var yyrt4752 bool
- if yyl4752 > cap(yyv4752) {
+ } else if yyl4757 > 0 {
+ var yyrr4757, yyrl4757 int
+ var yyrt4757 bool
+ if yyl4757 > cap(yyv4757) {
- yyrg4752 := len(yyv4752) > 0
- yyv24752 := yyv4752
- yyrl4752, yyrt4752 = z.DecInferLen(yyl4752, z.DecBasicHandle().MaxInitLen, 32)
- if yyrt4752 {
- if yyrl4752 <= cap(yyv4752) {
- yyv4752 = yyv4752[:yyrl4752]
+ yyrg4757 := len(yyv4757) > 0
+ yyv24757 := yyv4757
+ yyrl4757, yyrt4757 = z.DecInferLen(yyl4757, z.DecBasicHandle().MaxInitLen, 32)
+ if yyrt4757 {
+ if yyrl4757 <= cap(yyv4757) {
+ yyv4757 = yyv4757[:yyrl4757]
} else {
- yyv4752 = make([]NodeAddress, yyrl4752)
+ yyv4757 = make([]NodeAddress, yyrl4757)
}
} else {
- yyv4752 = make([]NodeAddress, yyrl4752)
+ yyv4757 = make([]NodeAddress, yyrl4757)
}
- yyc4752 = true
- yyrr4752 = len(yyv4752)
- if yyrg4752 {
- copy(yyv4752, yyv24752)
+ yyc4757 = true
+ yyrr4757 = len(yyv4757)
+ if yyrg4757 {
+ copy(yyv4757, yyv24757)
}
- } else if yyl4752 != len(yyv4752) {
- yyv4752 = yyv4752[:yyl4752]
- yyc4752 = true
+ } else if yyl4757 != len(yyv4757) {
+ yyv4757 = yyv4757[:yyl4757]
+ yyc4757 = true
}
- yyj4752 := 0
- for ; yyj4752 < yyrr4752; yyj4752++ {
- yyh4752.ElemContainerState(yyj4752)
+ yyj4757 := 0
+ for ; yyj4757 < yyrr4757; yyj4757++ {
+ yyh4757.ElemContainerState(yyj4757)
if r.TryDecodeAsNil() {
- yyv4752[yyj4752] = NodeAddress{}
+ yyv4757[yyj4757] = NodeAddress{}
} else {
- yyv4753 := &yyv4752[yyj4752]
- yyv4753.CodecDecodeSelf(d)
+ yyv4758 := &yyv4757[yyj4757]
+ yyv4758.CodecDecodeSelf(d)
}
}
- if yyrt4752 {
- for ; yyj4752 < yyl4752; yyj4752++ {
- yyv4752 = append(yyv4752, NodeAddress{})
- yyh4752.ElemContainerState(yyj4752)
+ if yyrt4757 {
+ for ; yyj4757 < yyl4757; yyj4757++ {
+ yyv4757 = append(yyv4757, NodeAddress{})
+ yyh4757.ElemContainerState(yyj4757)
if r.TryDecodeAsNil() {
- yyv4752[yyj4752] = NodeAddress{}
+ yyv4757[yyj4757] = NodeAddress{}
} else {
- yyv4754 := &yyv4752[yyj4752]
- yyv4754.CodecDecodeSelf(d)
+ yyv4759 := &yyv4757[yyj4757]
+ yyv4759.CodecDecodeSelf(d)
}
}
}
} else {
- yyj4752 := 0
- for ; !r.CheckBreak(); yyj4752++ {
+ yyj4757 := 0
+ for ; !r.CheckBreak(); yyj4757++ {
- if yyj4752 >= len(yyv4752) {
- yyv4752 = append(yyv4752, NodeAddress{}) // var yyz4752 NodeAddress
- yyc4752 = true
+ if yyj4757 >= len(yyv4757) {
+ yyv4757 = append(yyv4757, NodeAddress{}) // var yyz4757 NodeAddress
+ yyc4757 = true
}
- yyh4752.ElemContainerState(yyj4752)
- if yyj4752 < len(yyv4752) {
+ yyh4757.ElemContainerState(yyj4757)
+ if yyj4757 < len(yyv4757) {
if r.TryDecodeAsNil() {
- yyv4752[yyj4752] = NodeAddress{}
+ yyv4757[yyj4757] = NodeAddress{}
} else {
- yyv4755 := &yyv4752[yyj4752]
- yyv4755.CodecDecodeSelf(d)
+ yyv4760 := &yyv4757[yyj4757]
+ yyv4760.CodecDecodeSelf(d)
}
} else {
@@ -60731,17 +60795,17 @@ func (x codecSelfer1234) decSliceNodeAddress(v *[]NodeAddress, d *codec1978.Deco
}
}
- if yyj4752 < len(yyv4752) {
- yyv4752 = yyv4752[:yyj4752]
- yyc4752 = true
- } else if yyj4752 == 0 && yyv4752 == nil {
- yyv4752 = []NodeAddress{}
- yyc4752 = true
+ if yyj4757 < len(yyv4757) {
+ yyv4757 = yyv4757[:yyj4757]
+ yyc4757 = true
+ } else if yyj4757 == 0 && yyv4757 == nil {
+ yyv4757 = []NodeAddress{}
+ yyc4757 = true
}
}
- yyh4752.End()
- if yyc4752 {
- *v = yyv4752
+ yyh4757.End()
+ if yyc4757 {
+ *v = yyv4757
}
}
@@ -60750,10 +60814,10 @@ func (x codecSelfer1234) encSliceContainerImage(v []ContainerImage, e *codec1978
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
r.EncodeArrayStart(len(v))
- for _, yyv4756 := range v {
+ for _, yyv4761 := range v {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy4757 := &yyv4756
- yy4757.CodecEncodeSelf(e)
+ yy4762 := &yyv4761
+ yy4762.CodecEncodeSelf(e)
}
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -60763,127 +60827,12 @@ func (x codecSelfer1234) decSliceContainerImage(v *[]ContainerImage, d *codec197
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yyv4758 := *v
- yyh4758, yyl4758 := z.DecSliceHelperStart()
- var yyc4758 bool
- if yyl4758 == 0 {
- if yyv4758 == nil {
- yyv4758 = []ContainerImage{}
- yyc4758 = true
- } else if len(yyv4758) != 0 {
- yyv4758 = yyv4758[:0]
- yyc4758 = true
- }
- } else if yyl4758 > 0 {
- var yyrr4758, yyrl4758 int
- var yyrt4758 bool
- if yyl4758 > cap(yyv4758) {
-
- yyrg4758 := len(yyv4758) > 0
- yyv24758 := yyv4758
- yyrl4758, yyrt4758 = z.DecInferLen(yyl4758, z.DecBasicHandle().MaxInitLen, 32)
- if yyrt4758 {
- if yyrl4758 <= cap(yyv4758) {
- yyv4758 = yyv4758[:yyrl4758]
- } else {
- yyv4758 = make([]ContainerImage, yyrl4758)
- }
- } else {
- yyv4758 = make([]ContainerImage, yyrl4758)
- }
- yyc4758 = true
- yyrr4758 = len(yyv4758)
- if yyrg4758 {
- copy(yyv4758, yyv24758)
- }
- } else if yyl4758 != len(yyv4758) {
- yyv4758 = yyv4758[:yyl4758]
- yyc4758 = true
- }
- yyj4758 := 0
- for ; yyj4758 < yyrr4758; yyj4758++ {
- yyh4758.ElemContainerState(yyj4758)
- if r.TryDecodeAsNil() {
- yyv4758[yyj4758] = ContainerImage{}
- } else {
- yyv4759 := &yyv4758[yyj4758]
- yyv4759.CodecDecodeSelf(d)
- }
-
- }
- if yyrt4758 {
- for ; yyj4758 < yyl4758; yyj4758++ {
- yyv4758 = append(yyv4758, ContainerImage{})
- yyh4758.ElemContainerState(yyj4758)
- if r.TryDecodeAsNil() {
- yyv4758[yyj4758] = ContainerImage{}
- } else {
- yyv4760 := &yyv4758[yyj4758]
- yyv4760.CodecDecodeSelf(d)
- }
-
- }
- }
-
- } else {
- yyj4758 := 0
- for ; !r.CheckBreak(); yyj4758++ {
-
- if yyj4758 >= len(yyv4758) {
- yyv4758 = append(yyv4758, ContainerImage{}) // var yyz4758 ContainerImage
- yyc4758 = true
- }
- yyh4758.ElemContainerState(yyj4758)
- if yyj4758 < len(yyv4758) {
- if r.TryDecodeAsNil() {
- yyv4758[yyj4758] = ContainerImage{}
- } else {
- yyv4761 := &yyv4758[yyj4758]
- yyv4761.CodecDecodeSelf(d)
- }
-
- } else {
- z.DecSwallow()
- }
-
- }
- if yyj4758 < len(yyv4758) {
- yyv4758 = yyv4758[:yyj4758]
- yyc4758 = true
- } else if yyj4758 == 0 && yyv4758 == nil {
- yyv4758 = []ContainerImage{}
- yyc4758 = true
- }
- }
- yyh4758.End()
- if yyc4758 {
- *v = yyv4758
- }
-}
-
-func (x codecSelfer1234) encSliceUniqueVolumeName(v []UniqueVolumeName, e *codec1978.Encoder) {
- var h codecSelfer1234
- z, r := codec1978.GenHelperEncoder(e)
- _, _, _ = h, z, r
- r.EncodeArrayStart(len(v))
- for _, yyv4762 := range v {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yyv4762.CodecEncodeSelf(e)
- }
- z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
-}
-
-func (x codecSelfer1234) decSliceUniqueVolumeName(v *[]UniqueVolumeName, d *codec1978.Decoder) {
- var h codecSelfer1234
- z, r := codec1978.GenHelperDecoder(d)
- _, _, _ = h, z, r
-
yyv4763 := *v
yyh4763, yyl4763 := z.DecSliceHelperStart()
var yyc4763 bool
if yyl4763 == 0 {
if yyv4763 == nil {
- yyv4763 = []UniqueVolumeName{}
+ yyv4763 = []ContainerImage{}
yyc4763 = true
} else if len(yyv4763) != 0 {
yyv4763 = yyv4763[:0]
@@ -60894,18 +60843,23 @@ func (x codecSelfer1234) decSliceUniqueVolumeName(v *[]UniqueVolumeName, d *code
var yyrt4763 bool
if yyl4763 > cap(yyv4763) {
- yyrl4763, yyrt4763 = z.DecInferLen(yyl4763, z.DecBasicHandle().MaxInitLen, 16)
+ yyrg4763 := len(yyv4763) > 0
+ yyv24763 := yyv4763
+ yyrl4763, yyrt4763 = z.DecInferLen(yyl4763, z.DecBasicHandle().MaxInitLen, 32)
if yyrt4763 {
if yyrl4763 <= cap(yyv4763) {
yyv4763 = yyv4763[:yyrl4763]
} else {
- yyv4763 = make([]UniqueVolumeName, yyrl4763)
+ yyv4763 = make([]ContainerImage, yyrl4763)
}
} else {
- yyv4763 = make([]UniqueVolumeName, yyrl4763)
+ yyv4763 = make([]ContainerImage, yyrl4763)
}
yyc4763 = true
yyrr4763 = len(yyv4763)
+ if yyrg4763 {
+ copy(yyv4763, yyv24763)
+ }
} else if yyl4763 != len(yyv4763) {
yyv4763 = yyv4763[:yyl4763]
yyc4763 = true
@@ -60914,20 +60868,22 @@ func (x codecSelfer1234) decSliceUniqueVolumeName(v *[]UniqueVolumeName, d *code
for ; yyj4763 < yyrr4763; yyj4763++ {
yyh4763.ElemContainerState(yyj4763)
if r.TryDecodeAsNil() {
- yyv4763[yyj4763] = ""
+ yyv4763[yyj4763] = ContainerImage{}
} else {
- yyv4763[yyj4763] = UniqueVolumeName(r.DecodeString())
+ yyv4764 := &yyv4763[yyj4763]
+ yyv4764.CodecDecodeSelf(d)
}
}
if yyrt4763 {
for ; yyj4763 < yyl4763; yyj4763++ {
- yyv4763 = append(yyv4763, "")
+ yyv4763 = append(yyv4763, ContainerImage{})
yyh4763.ElemContainerState(yyj4763)
if r.TryDecodeAsNil() {
- yyv4763[yyj4763] = ""
+ yyv4763[yyj4763] = ContainerImage{}
} else {
- yyv4763[yyj4763] = UniqueVolumeName(r.DecodeString())
+ yyv4765 := &yyv4763[yyj4763]
+ yyv4765.CodecDecodeSelf(d)
}
}
@@ -60938,15 +60894,16 @@ func (x codecSelfer1234) decSliceUniqueVolumeName(v *[]UniqueVolumeName, d *code
for ; !r.CheckBreak(); yyj4763++ {
if yyj4763 >= len(yyv4763) {
- yyv4763 = append(yyv4763, "") // var yyz4763 UniqueVolumeName
+ yyv4763 = append(yyv4763, ContainerImage{}) // var yyz4763 ContainerImage
yyc4763 = true
}
yyh4763.ElemContainerState(yyj4763)
if yyj4763 < len(yyv4763) {
if r.TryDecodeAsNil() {
- yyv4763[yyj4763] = ""
+ yyv4763[yyj4763] = ContainerImage{}
} else {
- yyv4763[yyj4763] = UniqueVolumeName(r.DecodeString())
+ yyv4766 := &yyv4763[yyj4763]
+ yyv4766.CodecDecodeSelf(d)
}
} else {
@@ -60958,7 +60915,7 @@ func (x codecSelfer1234) decSliceUniqueVolumeName(v *[]UniqueVolumeName, d *code
yyv4763 = yyv4763[:yyj4763]
yyc4763 = true
} else if yyj4763 == 0 && yyv4763 == nil {
- yyv4763 = []UniqueVolumeName{}
+ yyv4763 = []ContainerImage{}
yyc4763 = true
}
}
@@ -60968,15 +60925,122 @@ func (x codecSelfer1234) decSliceUniqueVolumeName(v *[]UniqueVolumeName, d *code
}
}
-func (x codecSelfer1234) encSliceAttachedVolume(v []AttachedVolume, e *codec1978.Encoder) {
+func (x codecSelfer1234) encSliceUniqueVolumeName(v []UniqueVolumeName, e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
r.EncodeArrayStart(len(v))
for _, yyv4767 := range v {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy4768 := &yyv4767
- yy4768.CodecEncodeSelf(e)
+ yyv4767.CodecEncodeSelf(e)
+ }
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x codecSelfer1234) decSliceUniqueVolumeName(v *[]UniqueVolumeName, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+
+ yyv4768 := *v
+ yyh4768, yyl4768 := z.DecSliceHelperStart()
+ var yyc4768 bool
+ if yyl4768 == 0 {
+ if yyv4768 == nil {
+ yyv4768 = []UniqueVolumeName{}
+ yyc4768 = true
+ } else if len(yyv4768) != 0 {
+ yyv4768 = yyv4768[:0]
+ yyc4768 = true
+ }
+ } else if yyl4768 > 0 {
+ var yyrr4768, yyrl4768 int
+ var yyrt4768 bool
+ if yyl4768 > cap(yyv4768) {
+
+ yyrl4768, yyrt4768 = z.DecInferLen(yyl4768, z.DecBasicHandle().MaxInitLen, 16)
+ if yyrt4768 {
+ if yyrl4768 <= cap(yyv4768) {
+ yyv4768 = yyv4768[:yyrl4768]
+ } else {
+ yyv4768 = make([]UniqueVolumeName, yyrl4768)
+ }
+ } else {
+ yyv4768 = make([]UniqueVolumeName, yyrl4768)
+ }
+ yyc4768 = true
+ yyrr4768 = len(yyv4768)
+ } else if yyl4768 != len(yyv4768) {
+ yyv4768 = yyv4768[:yyl4768]
+ yyc4768 = true
+ }
+ yyj4768 := 0
+ for ; yyj4768 < yyrr4768; yyj4768++ {
+ yyh4768.ElemContainerState(yyj4768)
+ if r.TryDecodeAsNil() {
+ yyv4768[yyj4768] = ""
+ } else {
+ yyv4768[yyj4768] = UniqueVolumeName(r.DecodeString())
+ }
+
+ }
+ if yyrt4768 {
+ for ; yyj4768 < yyl4768; yyj4768++ {
+ yyv4768 = append(yyv4768, "")
+ yyh4768.ElemContainerState(yyj4768)
+ if r.TryDecodeAsNil() {
+ yyv4768[yyj4768] = ""
+ } else {
+ yyv4768[yyj4768] = UniqueVolumeName(r.DecodeString())
+ }
+
+ }
+ }
+
+ } else {
+ yyj4768 := 0
+ for ; !r.CheckBreak(); yyj4768++ {
+
+ if yyj4768 >= len(yyv4768) {
+ yyv4768 = append(yyv4768, "") // var yyz4768 UniqueVolumeName
+ yyc4768 = true
+ }
+ yyh4768.ElemContainerState(yyj4768)
+ if yyj4768 < len(yyv4768) {
+ if r.TryDecodeAsNil() {
+ yyv4768[yyj4768] = ""
+ } else {
+ yyv4768[yyj4768] = UniqueVolumeName(r.DecodeString())
+ }
+
+ } else {
+ z.DecSwallow()
+ }
+
+ }
+ if yyj4768 < len(yyv4768) {
+ yyv4768 = yyv4768[:yyj4768]
+ yyc4768 = true
+ } else if yyj4768 == 0 && yyv4768 == nil {
+ yyv4768 = []UniqueVolumeName{}
+ yyc4768 = true
+ }
+ }
+ yyh4768.End()
+ if yyc4768 {
+ *v = yyv4768
+ }
+}
+
+func (x codecSelfer1234) encSliceAttachedVolume(v []AttachedVolume, e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ r.EncodeArrayStart(len(v))
+ for _, yyv4772 := range v {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy4773 := &yyv4772
+ yy4773.CodecEncodeSelf(e)
}
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -60986,83 +61050,83 @@ func (x codecSelfer1234) decSliceAttachedVolume(v *[]AttachedVolume, d *codec197
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yyv4769 := *v
- yyh4769, yyl4769 := z.DecSliceHelperStart()
- var yyc4769 bool
- if yyl4769 == 0 {
- if yyv4769 == nil {
- yyv4769 = []AttachedVolume{}
- yyc4769 = true
- } else if len(yyv4769) != 0 {
- yyv4769 = yyv4769[:0]
- yyc4769 = true
+ yyv4774 := *v
+ yyh4774, yyl4774 := z.DecSliceHelperStart()
+ var yyc4774 bool
+ if yyl4774 == 0 {
+ if yyv4774 == nil {
+ yyv4774 = []AttachedVolume{}
+ yyc4774 = true
+ } else if len(yyv4774) != 0 {
+ yyv4774 = yyv4774[:0]
+ yyc4774 = true
}
- } else if yyl4769 > 0 {
- var yyrr4769, yyrl4769 int
- var yyrt4769 bool
- if yyl4769 > cap(yyv4769) {
+ } else if yyl4774 > 0 {
+ var yyrr4774, yyrl4774 int
+ var yyrt4774 bool
+ if yyl4774 > cap(yyv4774) {
- yyrg4769 := len(yyv4769) > 0
- yyv24769 := yyv4769
- yyrl4769, yyrt4769 = z.DecInferLen(yyl4769, z.DecBasicHandle().MaxInitLen, 32)
- if yyrt4769 {
- if yyrl4769 <= cap(yyv4769) {
- yyv4769 = yyv4769[:yyrl4769]
+ yyrg4774 := len(yyv4774) > 0
+ yyv24774 := yyv4774
+ yyrl4774, yyrt4774 = z.DecInferLen(yyl4774, z.DecBasicHandle().MaxInitLen, 32)
+ if yyrt4774 {
+ if yyrl4774 <= cap(yyv4774) {
+ yyv4774 = yyv4774[:yyrl4774]
} else {
- yyv4769 = make([]AttachedVolume, yyrl4769)
+ yyv4774 = make([]AttachedVolume, yyrl4774)
}
} else {
- yyv4769 = make([]AttachedVolume, yyrl4769)
+ yyv4774 = make([]AttachedVolume, yyrl4774)
}
- yyc4769 = true
- yyrr4769 = len(yyv4769)
- if yyrg4769 {
- copy(yyv4769, yyv24769)
+ yyc4774 = true
+ yyrr4774 = len(yyv4774)
+ if yyrg4774 {
+ copy(yyv4774, yyv24774)
}
- } else if yyl4769 != len(yyv4769) {
- yyv4769 = yyv4769[:yyl4769]
- yyc4769 = true
+ } else if yyl4774 != len(yyv4774) {
+ yyv4774 = yyv4774[:yyl4774]
+ yyc4774 = true
}
- yyj4769 := 0
- for ; yyj4769 < yyrr4769; yyj4769++ {
- yyh4769.ElemContainerState(yyj4769)
+ yyj4774 := 0
+ for ; yyj4774 < yyrr4774; yyj4774++ {
+ yyh4774.ElemContainerState(yyj4774)
if r.TryDecodeAsNil() {
- yyv4769[yyj4769] = AttachedVolume{}
+ yyv4774[yyj4774] = AttachedVolume{}
} else {
- yyv4770 := &yyv4769[yyj4769]
- yyv4770.CodecDecodeSelf(d)
+ yyv4775 := &yyv4774[yyj4774]
+ yyv4775.CodecDecodeSelf(d)
}
}
- if yyrt4769 {
- for ; yyj4769 < yyl4769; yyj4769++ {
- yyv4769 = append(yyv4769, AttachedVolume{})
- yyh4769.ElemContainerState(yyj4769)
+ if yyrt4774 {
+ for ; yyj4774 < yyl4774; yyj4774++ {
+ yyv4774 = append(yyv4774, AttachedVolume{})
+ yyh4774.ElemContainerState(yyj4774)
if r.TryDecodeAsNil() {
- yyv4769[yyj4769] = AttachedVolume{}
+ yyv4774[yyj4774] = AttachedVolume{}
} else {
- yyv4771 := &yyv4769[yyj4769]
- yyv4771.CodecDecodeSelf(d)
+ yyv4776 := &yyv4774[yyj4774]
+ yyv4776.CodecDecodeSelf(d)
}
}
}
} else {
- yyj4769 := 0
- for ; !r.CheckBreak(); yyj4769++ {
+ yyj4774 := 0
+ for ; !r.CheckBreak(); yyj4774++ {
- if yyj4769 >= len(yyv4769) {
- yyv4769 = append(yyv4769, AttachedVolume{}) // var yyz4769 AttachedVolume
- yyc4769 = true
+ if yyj4774 >= len(yyv4774) {
+ yyv4774 = append(yyv4774, AttachedVolume{}) // var yyz4774 AttachedVolume
+ yyc4774 = true
}
- yyh4769.ElemContainerState(yyj4769)
- if yyj4769 < len(yyv4769) {
+ yyh4774.ElemContainerState(yyj4774)
+ if yyj4774 < len(yyv4774) {
if r.TryDecodeAsNil() {
- yyv4769[yyj4769] = AttachedVolume{}
+ yyv4774[yyj4774] = AttachedVolume{}
} else {
- yyv4772 := &yyv4769[yyj4769]
- yyv4772.CodecDecodeSelf(d)
+ yyv4777 := &yyv4774[yyj4774]
+ yyv4777.CodecDecodeSelf(d)
}
} else {
@@ -61070,17 +61134,17 @@ func (x codecSelfer1234) decSliceAttachedVolume(v *[]AttachedVolume, d *codec197
}
}
- if yyj4769 < len(yyv4769) {
- yyv4769 = yyv4769[:yyj4769]
- yyc4769 = true
- } else if yyj4769 == 0 && yyv4769 == nil {
- yyv4769 = []AttachedVolume{}
- yyc4769 = true
+ if yyj4774 < len(yyv4774) {
+ yyv4774 = yyv4774[:yyj4774]
+ yyc4774 = true
+ } else if yyj4774 == 0 && yyv4774 == nil {
+ yyv4774 = []AttachedVolume{}
+ yyc4774 = true
}
}
- yyh4769.End()
- if yyc4769 {
- *v = yyv4769
+ yyh4774.End()
+ if yyc4774 {
+ *v = yyv4774
}
}
@@ -61089,10 +61153,10 @@ func (x codecSelfer1234) encSlicePreferAvoidPodsEntry(v []PreferAvoidPodsEntry,
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
r.EncodeArrayStart(len(v))
- for _, yyv4773 := range v {
+ for _, yyv4778 := range v {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy4774 := &yyv4773
- yy4774.CodecEncodeSelf(e)
+ yy4779 := &yyv4778
+ yy4779.CodecEncodeSelf(e)
}
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -61102,83 +61166,83 @@ func (x codecSelfer1234) decSlicePreferAvoidPodsEntry(v *[]PreferAvoidPodsEntry,
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yyv4775 := *v
- yyh4775, yyl4775 := z.DecSliceHelperStart()
- var yyc4775 bool
- if yyl4775 == 0 {
- if yyv4775 == nil {
- yyv4775 = []PreferAvoidPodsEntry{}
- yyc4775 = true
- } else if len(yyv4775) != 0 {
- yyv4775 = yyv4775[:0]
- yyc4775 = true
+ yyv4780 := *v
+ yyh4780, yyl4780 := z.DecSliceHelperStart()
+ var yyc4780 bool
+ if yyl4780 == 0 {
+ if yyv4780 == nil {
+ yyv4780 = []PreferAvoidPodsEntry{}
+ yyc4780 = true
+ } else if len(yyv4780) != 0 {
+ yyv4780 = yyv4780[:0]
+ yyc4780 = true
}
- } else if yyl4775 > 0 {
- var yyrr4775, yyrl4775 int
- var yyrt4775 bool
- if yyl4775 > cap(yyv4775) {
+ } else if yyl4780 > 0 {
+ var yyrr4780, yyrl4780 int
+ var yyrt4780 bool
+ if yyl4780 > cap(yyv4780) {
- yyrg4775 := len(yyv4775) > 0
- yyv24775 := yyv4775
- yyrl4775, yyrt4775 = z.DecInferLen(yyl4775, z.DecBasicHandle().MaxInitLen, 64)
- if yyrt4775 {
- if yyrl4775 <= cap(yyv4775) {
- yyv4775 = yyv4775[:yyrl4775]
+ yyrg4780 := len(yyv4780) > 0
+ yyv24780 := yyv4780
+ yyrl4780, yyrt4780 = z.DecInferLen(yyl4780, z.DecBasicHandle().MaxInitLen, 64)
+ if yyrt4780 {
+ if yyrl4780 <= cap(yyv4780) {
+ yyv4780 = yyv4780[:yyrl4780]
} else {
- yyv4775 = make([]PreferAvoidPodsEntry, yyrl4775)
+ yyv4780 = make([]PreferAvoidPodsEntry, yyrl4780)
}
} else {
- yyv4775 = make([]PreferAvoidPodsEntry, yyrl4775)
+ yyv4780 = make([]PreferAvoidPodsEntry, yyrl4780)
}
- yyc4775 = true
- yyrr4775 = len(yyv4775)
- if yyrg4775 {
- copy(yyv4775, yyv24775)
+ yyc4780 = true
+ yyrr4780 = len(yyv4780)
+ if yyrg4780 {
+ copy(yyv4780, yyv24780)
}
- } else if yyl4775 != len(yyv4775) {
- yyv4775 = yyv4775[:yyl4775]
- yyc4775 = true
+ } else if yyl4780 != len(yyv4780) {
+ yyv4780 = yyv4780[:yyl4780]
+ yyc4780 = true
}
- yyj4775 := 0
- for ; yyj4775 < yyrr4775; yyj4775++ {
- yyh4775.ElemContainerState(yyj4775)
+ yyj4780 := 0
+ for ; yyj4780 < yyrr4780; yyj4780++ {
+ yyh4780.ElemContainerState(yyj4780)
if r.TryDecodeAsNil() {
- yyv4775[yyj4775] = PreferAvoidPodsEntry{}
+ yyv4780[yyj4780] = PreferAvoidPodsEntry{}
} else {
- yyv4776 := &yyv4775[yyj4775]
- yyv4776.CodecDecodeSelf(d)
+ yyv4781 := &yyv4780[yyj4780]
+ yyv4781.CodecDecodeSelf(d)
}
}
- if yyrt4775 {
- for ; yyj4775 < yyl4775; yyj4775++ {
- yyv4775 = append(yyv4775, PreferAvoidPodsEntry{})
- yyh4775.ElemContainerState(yyj4775)
+ if yyrt4780 {
+ for ; yyj4780 < yyl4780; yyj4780++ {
+ yyv4780 = append(yyv4780, PreferAvoidPodsEntry{})
+ yyh4780.ElemContainerState(yyj4780)
if r.TryDecodeAsNil() {
- yyv4775[yyj4775] = PreferAvoidPodsEntry{}
+ yyv4780[yyj4780] = PreferAvoidPodsEntry{}
} else {
- yyv4777 := &yyv4775[yyj4775]
- yyv4777.CodecDecodeSelf(d)
+ yyv4782 := &yyv4780[yyj4780]
+ yyv4782.CodecDecodeSelf(d)
}
}
}
} else {
- yyj4775 := 0
- for ; !r.CheckBreak(); yyj4775++ {
+ yyj4780 := 0
+ for ; !r.CheckBreak(); yyj4780++ {
- if yyj4775 >= len(yyv4775) {
- yyv4775 = append(yyv4775, PreferAvoidPodsEntry{}) // var yyz4775 PreferAvoidPodsEntry
- yyc4775 = true
+ if yyj4780 >= len(yyv4780) {
+ yyv4780 = append(yyv4780, PreferAvoidPodsEntry{}) // var yyz4780 PreferAvoidPodsEntry
+ yyc4780 = true
}
- yyh4775.ElemContainerState(yyj4775)
- if yyj4775 < len(yyv4775) {
+ yyh4780.ElemContainerState(yyj4780)
+ if yyj4780 < len(yyv4780) {
if r.TryDecodeAsNil() {
- yyv4775[yyj4775] = PreferAvoidPodsEntry{}
+ yyv4780[yyj4780] = PreferAvoidPodsEntry{}
} else {
- yyv4778 := &yyv4775[yyj4775]
- yyv4778.CodecDecodeSelf(d)
+ yyv4783 := &yyv4780[yyj4780]
+ yyv4783.CodecDecodeSelf(d)
}
} else {
@@ -61186,17 +61250,17 @@ func (x codecSelfer1234) decSlicePreferAvoidPodsEntry(v *[]PreferAvoidPodsEntry,
}
}
- if yyj4775 < len(yyv4775) {
- yyv4775 = yyv4775[:yyj4775]
- yyc4775 = true
- } else if yyj4775 == 0 && yyv4775 == nil {
- yyv4775 = []PreferAvoidPodsEntry{}
- yyc4775 = true
+ if yyj4780 < len(yyv4780) {
+ yyv4780 = yyv4780[:yyj4780]
+ yyc4780 = true
+ } else if yyj4780 == 0 && yyv4780 == nil {
+ yyv4780 = []PreferAvoidPodsEntry{}
+ yyc4780 = true
}
}
- yyh4775.End()
- if yyc4775 {
- *v = yyv4775
+ yyh4780.End()
+ if yyc4780 {
+ *v = yyv4780
}
}
@@ -61205,19 +61269,19 @@ func (x codecSelfer1234) encResourceList(v ResourceList, e *codec1978.Encoder) {
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
r.EncodeMapStart(len(v))
- for yyk4779, yyv4779 := range v {
+ for yyk4784, yyv4784 := range v {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- yyk4779.CodecEncodeSelf(e)
+ yyk4784.CodecEncodeSelf(e)
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- yy4780 := &yyv4779
- yym4781 := z.EncBinary()
- _ = yym4781
+ yy4785 := &yyv4784
+ yym4786 := z.EncBinary()
+ _ = yym4786
if false {
- } else if z.HasExtensions() && z.EncExt(yy4780) {
- } else if !yym4781 && z.IsJSONHandle() {
- z.EncJSONMarshal(yy4780)
+ } else if z.HasExtensions() && z.EncExt(yy4785) {
+ } else if !yym4786 && z.IsJSONHandle() {
+ z.EncJSONMarshal(yy4785)
} else {
- z.EncFallback(yy4780)
+ z.EncFallback(yy4785)
}
}
z.EncSendContainerState(codecSelfer_containerMapEnd1234)
@@ -61228,86 +61292,86 @@ func (x codecSelfer1234) decResourceList(v *ResourceList, d *codec1978.Decoder)
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yyv4782 := *v
- yyl4782 := r.ReadMapStart()
- yybh4782 := z.DecBasicHandle()
- if yyv4782 == nil {
- yyrl4782, _ := z.DecInferLen(yyl4782, yybh4782.MaxInitLen, 72)
- yyv4782 = make(map[ResourceName]pkg3_resource.Quantity, yyrl4782)
- *v = yyv4782
+ yyv4787 := *v
+ yyl4787 := r.ReadMapStart()
+ yybh4787 := z.DecBasicHandle()
+ if yyv4787 == nil {
+ yyrl4787, _ := z.DecInferLen(yyl4787, yybh4787.MaxInitLen, 72)
+ yyv4787 = make(map[ResourceName]pkg3_resource.Quantity, yyrl4787)
+ *v = yyv4787
}
- var yymk4782 ResourceName
- var yymv4782 pkg3_resource.Quantity
- var yymg4782 bool
- if yybh4782.MapValueReset {
- yymg4782 = true
+ var yymk4787 ResourceName
+ var yymv4787 pkg3_resource.Quantity
+ var yymg4787 bool
+ if yybh4787.MapValueReset {
+ yymg4787 = true
}
- if yyl4782 > 0 {
- for yyj4782 := 0; yyj4782 < yyl4782; yyj4782++ {
+ if yyl4787 > 0 {
+ for yyj4787 := 0; yyj4787 < yyl4787; yyj4787++ {
z.DecSendContainerState(codecSelfer_containerMapKey1234)
if r.TryDecodeAsNil() {
- yymk4782 = ""
+ yymk4787 = ""
} else {
- yymk4782 = ResourceName(r.DecodeString())
+ yymk4787 = ResourceName(r.DecodeString())
}
- if yymg4782 {
- yymv4782 = yyv4782[yymk4782]
+ if yymg4787 {
+ yymv4787 = yyv4787[yymk4787]
} else {
- yymv4782 = pkg3_resource.Quantity{}
+ yymv4787 = pkg3_resource.Quantity{}
}
z.DecSendContainerState(codecSelfer_containerMapValue1234)
if r.TryDecodeAsNil() {
- yymv4782 = pkg3_resource.Quantity{}
+ yymv4787 = pkg3_resource.Quantity{}
} else {
- yyv4784 := &yymv4782
- yym4785 := z.DecBinary()
- _ = yym4785
+ yyv4789 := &yymv4787
+ yym4790 := z.DecBinary()
+ _ = yym4790
if false {
- } else if z.HasExtensions() && z.DecExt(yyv4784) {
- } else if !yym4785 && z.IsJSONHandle() {
- z.DecJSONUnmarshal(yyv4784)
+ } else if z.HasExtensions() && z.DecExt(yyv4789) {
+ } else if !yym4790 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv4789)
} else {
- z.DecFallback(yyv4784, false)
+ z.DecFallback(yyv4789, false)
}
}
- if yyv4782 != nil {
- yyv4782[yymk4782] = yymv4782
+ if yyv4787 != nil {
+ yyv4787[yymk4787] = yymv4787
}
}
- } else if yyl4782 < 0 {
- for yyj4782 := 0; !r.CheckBreak(); yyj4782++ {
+ } else if yyl4787 < 0 {
+ for yyj4787 := 0; !r.CheckBreak(); yyj4787++ {
z.DecSendContainerState(codecSelfer_containerMapKey1234)
if r.TryDecodeAsNil() {
- yymk4782 = ""
+ yymk4787 = ""
} else {
- yymk4782 = ResourceName(r.DecodeString())
+ yymk4787 = ResourceName(r.DecodeString())
}
- if yymg4782 {
- yymv4782 = yyv4782[yymk4782]
+ if yymg4787 {
+ yymv4787 = yyv4787[yymk4787]
} else {
- yymv4782 = pkg3_resource.Quantity{}
+ yymv4787 = pkg3_resource.Quantity{}
}
z.DecSendContainerState(codecSelfer_containerMapValue1234)
if r.TryDecodeAsNil() {
- yymv4782 = pkg3_resource.Quantity{}
+ yymv4787 = pkg3_resource.Quantity{}
} else {
- yyv4787 := &yymv4782
- yym4788 := z.DecBinary()
- _ = yym4788
+ yyv4792 := &yymv4787
+ yym4793 := z.DecBinary()
+ _ = yym4793
if false {
- } else if z.HasExtensions() && z.DecExt(yyv4787) {
- } else if !yym4788 && z.IsJSONHandle() {
- z.DecJSONUnmarshal(yyv4787)
+ } else if z.HasExtensions() && z.DecExt(yyv4792) {
+ } else if !yym4793 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv4792)
} else {
- z.DecFallback(yyv4787, false)
+ z.DecFallback(yyv4792, false)
}
}
- if yyv4782 != nil {
- yyv4782[yymk4782] = yymv4782
+ if yyv4787 != nil {
+ yyv4787[yymk4787] = yymv4787
}
}
} // else len==0: TODO: Should we clear map entries?
@@ -61319,10 +61383,10 @@ func (x codecSelfer1234) encSliceNode(v []Node, e *codec1978.Encoder) {
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
r.EncodeArrayStart(len(v))
- for _, yyv4789 := range v {
+ for _, yyv4794 := range v {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy4790 := &yyv4789
- yy4790.CodecEncodeSelf(e)
+ yy4795 := &yyv4794
+ yy4795.CodecEncodeSelf(e)
}
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -61332,127 +61396,12 @@ func (x codecSelfer1234) decSliceNode(v *[]Node, d *codec1978.Decoder) {
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yyv4791 := *v
- yyh4791, yyl4791 := z.DecSliceHelperStart()
- var yyc4791 bool
- if yyl4791 == 0 {
- if yyv4791 == nil {
- yyv4791 = []Node{}
- yyc4791 = true
- } else if len(yyv4791) != 0 {
- yyv4791 = yyv4791[:0]
- yyc4791 = true
- }
- } else if yyl4791 > 0 {
- var yyrr4791, yyrl4791 int
- var yyrt4791 bool
- if yyl4791 > cap(yyv4791) {
-
- yyrg4791 := len(yyv4791) > 0
- yyv24791 := yyv4791
- yyrl4791, yyrt4791 = z.DecInferLen(yyl4791, z.DecBasicHandle().MaxInitLen, 632)
- if yyrt4791 {
- if yyrl4791 <= cap(yyv4791) {
- yyv4791 = yyv4791[:yyrl4791]
- } else {
- yyv4791 = make([]Node, yyrl4791)
- }
- } else {
- yyv4791 = make([]Node, yyrl4791)
- }
- yyc4791 = true
- yyrr4791 = len(yyv4791)
- if yyrg4791 {
- copy(yyv4791, yyv24791)
- }
- } else if yyl4791 != len(yyv4791) {
- yyv4791 = yyv4791[:yyl4791]
- yyc4791 = true
- }
- yyj4791 := 0
- for ; yyj4791 < yyrr4791; yyj4791++ {
- yyh4791.ElemContainerState(yyj4791)
- if r.TryDecodeAsNil() {
- yyv4791[yyj4791] = Node{}
- } else {
- yyv4792 := &yyv4791[yyj4791]
- yyv4792.CodecDecodeSelf(d)
- }
-
- }
- if yyrt4791 {
- for ; yyj4791 < yyl4791; yyj4791++ {
- yyv4791 = append(yyv4791, Node{})
- yyh4791.ElemContainerState(yyj4791)
- if r.TryDecodeAsNil() {
- yyv4791[yyj4791] = Node{}
- } else {
- yyv4793 := &yyv4791[yyj4791]
- yyv4793.CodecDecodeSelf(d)
- }
-
- }
- }
-
- } else {
- yyj4791 := 0
- for ; !r.CheckBreak(); yyj4791++ {
-
- if yyj4791 >= len(yyv4791) {
- yyv4791 = append(yyv4791, Node{}) // var yyz4791 Node
- yyc4791 = true
- }
- yyh4791.ElemContainerState(yyj4791)
- if yyj4791 < len(yyv4791) {
- if r.TryDecodeAsNil() {
- yyv4791[yyj4791] = Node{}
- } else {
- yyv4794 := &yyv4791[yyj4791]
- yyv4794.CodecDecodeSelf(d)
- }
-
- } else {
- z.DecSwallow()
- }
-
- }
- if yyj4791 < len(yyv4791) {
- yyv4791 = yyv4791[:yyj4791]
- yyc4791 = true
- } else if yyj4791 == 0 && yyv4791 == nil {
- yyv4791 = []Node{}
- yyc4791 = true
- }
- }
- yyh4791.End()
- if yyc4791 {
- *v = yyv4791
- }
-}
-
-func (x codecSelfer1234) encSliceFinalizerName(v []FinalizerName, e *codec1978.Encoder) {
- var h codecSelfer1234
- z, r := codec1978.GenHelperEncoder(e)
- _, _, _ = h, z, r
- r.EncodeArrayStart(len(v))
- for _, yyv4795 := range v {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yyv4795.CodecEncodeSelf(e)
- }
- z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
-}
-
-func (x codecSelfer1234) decSliceFinalizerName(v *[]FinalizerName, d *codec1978.Decoder) {
- var h codecSelfer1234
- z, r := codec1978.GenHelperDecoder(d)
- _, _, _ = h, z, r
-
yyv4796 := *v
yyh4796, yyl4796 := z.DecSliceHelperStart()
var yyc4796 bool
if yyl4796 == 0 {
if yyv4796 == nil {
- yyv4796 = []FinalizerName{}
+ yyv4796 = []Node{}
yyc4796 = true
} else if len(yyv4796) != 0 {
yyv4796 = yyv4796[:0]
@@ -61463,18 +61412,23 @@ func (x codecSelfer1234) decSliceFinalizerName(v *[]FinalizerName, d *codec1978.
var yyrt4796 bool
if yyl4796 > cap(yyv4796) {
- yyrl4796, yyrt4796 = z.DecInferLen(yyl4796, z.DecBasicHandle().MaxInitLen, 16)
+ yyrg4796 := len(yyv4796) > 0
+ yyv24796 := yyv4796
+ yyrl4796, yyrt4796 = z.DecInferLen(yyl4796, z.DecBasicHandle().MaxInitLen, 632)
if yyrt4796 {
if yyrl4796 <= cap(yyv4796) {
yyv4796 = yyv4796[:yyrl4796]
} else {
- yyv4796 = make([]FinalizerName, yyrl4796)
+ yyv4796 = make([]Node, yyrl4796)
}
} else {
- yyv4796 = make([]FinalizerName, yyrl4796)
+ yyv4796 = make([]Node, yyrl4796)
}
yyc4796 = true
yyrr4796 = len(yyv4796)
+ if yyrg4796 {
+ copy(yyv4796, yyv24796)
+ }
} else if yyl4796 != len(yyv4796) {
yyv4796 = yyv4796[:yyl4796]
yyc4796 = true
@@ -61483,20 +61437,22 @@ func (x codecSelfer1234) decSliceFinalizerName(v *[]FinalizerName, d *codec1978.
for ; yyj4796 < yyrr4796; yyj4796++ {
yyh4796.ElemContainerState(yyj4796)
if r.TryDecodeAsNil() {
- yyv4796[yyj4796] = ""
+ yyv4796[yyj4796] = Node{}
} else {
- yyv4796[yyj4796] = FinalizerName(r.DecodeString())
+ yyv4797 := &yyv4796[yyj4796]
+ yyv4797.CodecDecodeSelf(d)
}
}
if yyrt4796 {
for ; yyj4796 < yyl4796; yyj4796++ {
- yyv4796 = append(yyv4796, "")
+ yyv4796 = append(yyv4796, Node{})
yyh4796.ElemContainerState(yyj4796)
if r.TryDecodeAsNil() {
- yyv4796[yyj4796] = ""
+ yyv4796[yyj4796] = Node{}
} else {
- yyv4796[yyj4796] = FinalizerName(r.DecodeString())
+ yyv4798 := &yyv4796[yyj4796]
+ yyv4798.CodecDecodeSelf(d)
}
}
@@ -61507,15 +61463,16 @@ func (x codecSelfer1234) decSliceFinalizerName(v *[]FinalizerName, d *codec1978.
for ; !r.CheckBreak(); yyj4796++ {
if yyj4796 >= len(yyv4796) {
- yyv4796 = append(yyv4796, "") // var yyz4796 FinalizerName
+ yyv4796 = append(yyv4796, Node{}) // var yyz4796 Node
yyc4796 = true
}
yyh4796.ElemContainerState(yyj4796)
if yyj4796 < len(yyv4796) {
if r.TryDecodeAsNil() {
- yyv4796[yyj4796] = ""
+ yyv4796[yyj4796] = Node{}
} else {
- yyv4796[yyj4796] = FinalizerName(r.DecodeString())
+ yyv4799 := &yyv4796[yyj4796]
+ yyv4799.CodecDecodeSelf(d)
}
} else {
@@ -61527,7 +61484,7 @@ func (x codecSelfer1234) decSliceFinalizerName(v *[]FinalizerName, d *codec1978.
yyv4796 = yyv4796[:yyj4796]
yyc4796 = true
} else if yyj4796 == 0 && yyv4796 == nil {
- yyv4796 = []FinalizerName{}
+ yyv4796 = []Node{}
yyc4796 = true
}
}
@@ -61537,15 +61494,122 @@ func (x codecSelfer1234) decSliceFinalizerName(v *[]FinalizerName, d *codec1978.
}
}
-func (x codecSelfer1234) encSliceNamespace(v []Namespace, e *codec1978.Encoder) {
+func (x codecSelfer1234) encSliceFinalizerName(v []FinalizerName, e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
r.EncodeArrayStart(len(v))
for _, yyv4800 := range v {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy4801 := &yyv4800
- yy4801.CodecEncodeSelf(e)
+ yyv4800.CodecEncodeSelf(e)
+ }
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x codecSelfer1234) decSliceFinalizerName(v *[]FinalizerName, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+
+ yyv4801 := *v
+ yyh4801, yyl4801 := z.DecSliceHelperStart()
+ var yyc4801 bool
+ if yyl4801 == 0 {
+ if yyv4801 == nil {
+ yyv4801 = []FinalizerName{}
+ yyc4801 = true
+ } else if len(yyv4801) != 0 {
+ yyv4801 = yyv4801[:0]
+ yyc4801 = true
+ }
+ } else if yyl4801 > 0 {
+ var yyrr4801, yyrl4801 int
+ var yyrt4801 bool
+ if yyl4801 > cap(yyv4801) {
+
+ yyrl4801, yyrt4801 = z.DecInferLen(yyl4801, z.DecBasicHandle().MaxInitLen, 16)
+ if yyrt4801 {
+ if yyrl4801 <= cap(yyv4801) {
+ yyv4801 = yyv4801[:yyrl4801]
+ } else {
+ yyv4801 = make([]FinalizerName, yyrl4801)
+ }
+ } else {
+ yyv4801 = make([]FinalizerName, yyrl4801)
+ }
+ yyc4801 = true
+ yyrr4801 = len(yyv4801)
+ } else if yyl4801 != len(yyv4801) {
+ yyv4801 = yyv4801[:yyl4801]
+ yyc4801 = true
+ }
+ yyj4801 := 0
+ for ; yyj4801 < yyrr4801; yyj4801++ {
+ yyh4801.ElemContainerState(yyj4801)
+ if r.TryDecodeAsNil() {
+ yyv4801[yyj4801] = ""
+ } else {
+ yyv4801[yyj4801] = FinalizerName(r.DecodeString())
+ }
+
+ }
+ if yyrt4801 {
+ for ; yyj4801 < yyl4801; yyj4801++ {
+ yyv4801 = append(yyv4801, "")
+ yyh4801.ElemContainerState(yyj4801)
+ if r.TryDecodeAsNil() {
+ yyv4801[yyj4801] = ""
+ } else {
+ yyv4801[yyj4801] = FinalizerName(r.DecodeString())
+ }
+
+ }
+ }
+
+ } else {
+ yyj4801 := 0
+ for ; !r.CheckBreak(); yyj4801++ {
+
+ if yyj4801 >= len(yyv4801) {
+ yyv4801 = append(yyv4801, "") // var yyz4801 FinalizerName
+ yyc4801 = true
+ }
+ yyh4801.ElemContainerState(yyj4801)
+ if yyj4801 < len(yyv4801) {
+ if r.TryDecodeAsNil() {
+ yyv4801[yyj4801] = ""
+ } else {
+ yyv4801[yyj4801] = FinalizerName(r.DecodeString())
+ }
+
+ } else {
+ z.DecSwallow()
+ }
+
+ }
+ if yyj4801 < len(yyv4801) {
+ yyv4801 = yyv4801[:yyj4801]
+ yyc4801 = true
+ } else if yyj4801 == 0 && yyv4801 == nil {
+ yyv4801 = []FinalizerName{}
+ yyc4801 = true
+ }
+ }
+ yyh4801.End()
+ if yyc4801 {
+ *v = yyv4801
+ }
+}
+
+func (x codecSelfer1234) encSliceNamespace(v []Namespace, e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ r.EncodeArrayStart(len(v))
+ for _, yyv4805 := range v {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy4806 := &yyv4805
+ yy4806.CodecEncodeSelf(e)
}
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -61555,83 +61619,83 @@ func (x codecSelfer1234) decSliceNamespace(v *[]Namespace, d *codec1978.Decoder)
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yyv4802 := *v
- yyh4802, yyl4802 := z.DecSliceHelperStart()
- var yyc4802 bool
- if yyl4802 == 0 {
- if yyv4802 == nil {
- yyv4802 = []Namespace{}
- yyc4802 = true
- } else if len(yyv4802) != 0 {
- yyv4802 = yyv4802[:0]
- yyc4802 = true
+ yyv4807 := *v
+ yyh4807, yyl4807 := z.DecSliceHelperStart()
+ var yyc4807 bool
+ if yyl4807 == 0 {
+ if yyv4807 == nil {
+ yyv4807 = []Namespace{}
+ yyc4807 = true
+ } else if len(yyv4807) != 0 {
+ yyv4807 = yyv4807[:0]
+ yyc4807 = true
}
- } else if yyl4802 > 0 {
- var yyrr4802, yyrl4802 int
- var yyrt4802 bool
- if yyl4802 > cap(yyv4802) {
+ } else if yyl4807 > 0 {
+ var yyrr4807, yyrl4807 int
+ var yyrt4807 bool
+ if yyl4807 > cap(yyv4807) {
- yyrg4802 := len(yyv4802) > 0
- yyv24802 := yyv4802
- yyrl4802, yyrt4802 = z.DecInferLen(yyl4802, z.DecBasicHandle().MaxInitLen, 296)
- if yyrt4802 {
- if yyrl4802 <= cap(yyv4802) {
- yyv4802 = yyv4802[:yyrl4802]
+ yyrg4807 := len(yyv4807) > 0
+ yyv24807 := yyv4807
+ yyrl4807, yyrt4807 = z.DecInferLen(yyl4807, z.DecBasicHandle().MaxInitLen, 296)
+ if yyrt4807 {
+ if yyrl4807 <= cap(yyv4807) {
+ yyv4807 = yyv4807[:yyrl4807]
} else {
- yyv4802 = make([]Namespace, yyrl4802)
+ yyv4807 = make([]Namespace, yyrl4807)
}
} else {
- yyv4802 = make([]Namespace, yyrl4802)
+ yyv4807 = make([]Namespace, yyrl4807)
}
- yyc4802 = true
- yyrr4802 = len(yyv4802)
- if yyrg4802 {
- copy(yyv4802, yyv24802)
+ yyc4807 = true
+ yyrr4807 = len(yyv4807)
+ if yyrg4807 {
+ copy(yyv4807, yyv24807)
}
- } else if yyl4802 != len(yyv4802) {
- yyv4802 = yyv4802[:yyl4802]
- yyc4802 = true
+ } else if yyl4807 != len(yyv4807) {
+ yyv4807 = yyv4807[:yyl4807]
+ yyc4807 = true
}
- yyj4802 := 0
- for ; yyj4802 < yyrr4802; yyj4802++ {
- yyh4802.ElemContainerState(yyj4802)
+ yyj4807 := 0
+ for ; yyj4807 < yyrr4807; yyj4807++ {
+ yyh4807.ElemContainerState(yyj4807)
if r.TryDecodeAsNil() {
- yyv4802[yyj4802] = Namespace{}
+ yyv4807[yyj4807] = Namespace{}
} else {
- yyv4803 := &yyv4802[yyj4802]
- yyv4803.CodecDecodeSelf(d)
+ yyv4808 := &yyv4807[yyj4807]
+ yyv4808.CodecDecodeSelf(d)
}
}
- if yyrt4802 {
- for ; yyj4802 < yyl4802; yyj4802++ {
- yyv4802 = append(yyv4802, Namespace{})
- yyh4802.ElemContainerState(yyj4802)
+ if yyrt4807 {
+ for ; yyj4807 < yyl4807; yyj4807++ {
+ yyv4807 = append(yyv4807, Namespace{})
+ yyh4807.ElemContainerState(yyj4807)
if r.TryDecodeAsNil() {
- yyv4802[yyj4802] = Namespace{}
+ yyv4807[yyj4807] = Namespace{}
} else {
- yyv4804 := &yyv4802[yyj4802]
- yyv4804.CodecDecodeSelf(d)
+ yyv4809 := &yyv4807[yyj4807]
+ yyv4809.CodecDecodeSelf(d)
}
}
}
} else {
- yyj4802 := 0
- for ; !r.CheckBreak(); yyj4802++ {
+ yyj4807 := 0
+ for ; !r.CheckBreak(); yyj4807++ {
- if yyj4802 >= len(yyv4802) {
- yyv4802 = append(yyv4802, Namespace{}) // var yyz4802 Namespace
- yyc4802 = true
+ if yyj4807 >= len(yyv4807) {
+ yyv4807 = append(yyv4807, Namespace{}) // var yyz4807 Namespace
+ yyc4807 = true
}
- yyh4802.ElemContainerState(yyj4802)
- if yyj4802 < len(yyv4802) {
+ yyh4807.ElemContainerState(yyj4807)
+ if yyj4807 < len(yyv4807) {
if r.TryDecodeAsNil() {
- yyv4802[yyj4802] = Namespace{}
+ yyv4807[yyj4807] = Namespace{}
} else {
- yyv4805 := &yyv4802[yyj4802]
- yyv4805.CodecDecodeSelf(d)
+ yyv4810 := &yyv4807[yyj4807]
+ yyv4810.CodecDecodeSelf(d)
}
} else {
@@ -61639,17 +61703,17 @@ func (x codecSelfer1234) decSliceNamespace(v *[]Namespace, d *codec1978.Decoder)
}
}
- if yyj4802 < len(yyv4802) {
- yyv4802 = yyv4802[:yyj4802]
- yyc4802 = true
- } else if yyj4802 == 0 && yyv4802 == nil {
- yyv4802 = []Namespace{}
- yyc4802 = true
+ if yyj4807 < len(yyv4807) {
+ yyv4807 = yyv4807[:yyj4807]
+ yyc4807 = true
+ } else if yyj4807 == 0 && yyv4807 == nil {
+ yyv4807 = []Namespace{}
+ yyc4807 = true
}
}
- yyh4802.End()
- if yyc4802 {
- *v = yyv4802
+ yyh4807.End()
+ if yyc4807 {
+ *v = yyv4807
}
}
@@ -61658,10 +61722,10 @@ func (x codecSelfer1234) encSliceEvent(v []Event, e *codec1978.Encoder) {
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
r.EncodeArrayStart(len(v))
- for _, yyv4806 := range v {
+ for _, yyv4811 := range v {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy4807 := &yyv4806
- yy4807.CodecEncodeSelf(e)
+ yy4812 := &yyv4811
+ yy4812.CodecEncodeSelf(e)
}
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -61671,83 +61735,83 @@ func (x codecSelfer1234) decSliceEvent(v *[]Event, d *codec1978.Decoder) {
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yyv4808 := *v
- yyh4808, yyl4808 := z.DecSliceHelperStart()
- var yyc4808 bool
- if yyl4808 == 0 {
- if yyv4808 == nil {
- yyv4808 = []Event{}
- yyc4808 = true
- } else if len(yyv4808) != 0 {
- yyv4808 = yyv4808[:0]
- yyc4808 = true
+ yyv4813 := *v
+ yyh4813, yyl4813 := z.DecSliceHelperStart()
+ var yyc4813 bool
+ if yyl4813 == 0 {
+ if yyv4813 == nil {
+ yyv4813 = []Event{}
+ yyc4813 = true
+ } else if len(yyv4813) != 0 {
+ yyv4813 = yyv4813[:0]
+ yyc4813 = true
}
- } else if yyl4808 > 0 {
- var yyrr4808, yyrl4808 int
- var yyrt4808 bool
- if yyl4808 > cap(yyv4808) {
+ } else if yyl4813 > 0 {
+ var yyrr4813, yyrl4813 int
+ var yyrt4813 bool
+ if yyl4813 > cap(yyv4813) {
- yyrg4808 := len(yyv4808) > 0
- yyv24808 := yyv4808
- yyrl4808, yyrt4808 = z.DecInferLen(yyl4808, z.DecBasicHandle().MaxInitLen, 504)
- if yyrt4808 {
- if yyrl4808 <= cap(yyv4808) {
- yyv4808 = yyv4808[:yyrl4808]
+ yyrg4813 := len(yyv4813) > 0
+ yyv24813 := yyv4813
+ yyrl4813, yyrt4813 = z.DecInferLen(yyl4813, z.DecBasicHandle().MaxInitLen, 504)
+ if yyrt4813 {
+ if yyrl4813 <= cap(yyv4813) {
+ yyv4813 = yyv4813[:yyrl4813]
} else {
- yyv4808 = make([]Event, yyrl4808)
+ yyv4813 = make([]Event, yyrl4813)
}
} else {
- yyv4808 = make([]Event, yyrl4808)
+ yyv4813 = make([]Event, yyrl4813)
}
- yyc4808 = true
- yyrr4808 = len(yyv4808)
- if yyrg4808 {
- copy(yyv4808, yyv24808)
+ yyc4813 = true
+ yyrr4813 = len(yyv4813)
+ if yyrg4813 {
+ copy(yyv4813, yyv24813)
}
- } else if yyl4808 != len(yyv4808) {
- yyv4808 = yyv4808[:yyl4808]
- yyc4808 = true
+ } else if yyl4813 != len(yyv4813) {
+ yyv4813 = yyv4813[:yyl4813]
+ yyc4813 = true
}
- yyj4808 := 0
- for ; yyj4808 < yyrr4808; yyj4808++ {
- yyh4808.ElemContainerState(yyj4808)
+ yyj4813 := 0
+ for ; yyj4813 < yyrr4813; yyj4813++ {
+ yyh4813.ElemContainerState(yyj4813)
if r.TryDecodeAsNil() {
- yyv4808[yyj4808] = Event{}
+ yyv4813[yyj4813] = Event{}
} else {
- yyv4809 := &yyv4808[yyj4808]
- yyv4809.CodecDecodeSelf(d)
+ yyv4814 := &yyv4813[yyj4813]
+ yyv4814.CodecDecodeSelf(d)
}
}
- if yyrt4808 {
- for ; yyj4808 < yyl4808; yyj4808++ {
- yyv4808 = append(yyv4808, Event{})
- yyh4808.ElemContainerState(yyj4808)
+ if yyrt4813 {
+ for ; yyj4813 < yyl4813; yyj4813++ {
+ yyv4813 = append(yyv4813, Event{})
+ yyh4813.ElemContainerState(yyj4813)
if r.TryDecodeAsNil() {
- yyv4808[yyj4808] = Event{}
+ yyv4813[yyj4813] = Event{}
} else {
- yyv4810 := &yyv4808[yyj4808]
- yyv4810.CodecDecodeSelf(d)
+ yyv4815 := &yyv4813[yyj4813]
+ yyv4815.CodecDecodeSelf(d)
}
}
}
} else {
- yyj4808 := 0
- for ; !r.CheckBreak(); yyj4808++ {
+ yyj4813 := 0
+ for ; !r.CheckBreak(); yyj4813++ {
- if yyj4808 >= len(yyv4808) {
- yyv4808 = append(yyv4808, Event{}) // var yyz4808 Event
- yyc4808 = true
+ if yyj4813 >= len(yyv4813) {
+ yyv4813 = append(yyv4813, Event{}) // var yyz4813 Event
+ yyc4813 = true
}
- yyh4808.ElemContainerState(yyj4808)
- if yyj4808 < len(yyv4808) {
+ yyh4813.ElemContainerState(yyj4813)
+ if yyj4813 < len(yyv4813) {
if r.TryDecodeAsNil() {
- yyv4808[yyj4808] = Event{}
+ yyv4813[yyj4813] = Event{}
} else {
- yyv4811 := &yyv4808[yyj4808]
- yyv4811.CodecDecodeSelf(d)
+ yyv4816 := &yyv4813[yyj4813]
+ yyv4816.CodecDecodeSelf(d)
}
} else {
@@ -61755,17 +61819,17 @@ func (x codecSelfer1234) decSliceEvent(v *[]Event, d *codec1978.Decoder) {
}
}
- if yyj4808 < len(yyv4808) {
- yyv4808 = yyv4808[:yyj4808]
- yyc4808 = true
- } else if yyj4808 == 0 && yyv4808 == nil {
- yyv4808 = []Event{}
- yyc4808 = true
+ if yyj4813 < len(yyv4813) {
+ yyv4813 = yyv4813[:yyj4813]
+ yyc4813 = true
+ } else if yyj4813 == 0 && yyv4813 == nil {
+ yyv4813 = []Event{}
+ yyc4813 = true
}
}
- yyh4808.End()
- if yyc4808 {
- *v = yyv4808
+ yyh4813.End()
+ if yyc4813 {
+ *v = yyv4813
}
}
@@ -61774,17 +61838,17 @@ func (x codecSelfer1234) encSliceruntime_RawExtension(v []pkg5_runtime.RawExtens
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
r.EncodeArrayStart(len(v))
- for _, yyv4812 := range v {
+ for _, yyv4817 := range v {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy4813 := &yyv4812
- yym4814 := z.EncBinary()
- _ = yym4814
+ yy4818 := &yyv4817
+ yym4819 := z.EncBinary()
+ _ = yym4819
if false {
- } else if z.HasExtensions() && z.EncExt(yy4813) {
- } else if !yym4814 && z.IsJSONHandle() {
- z.EncJSONMarshal(yy4813)
+ } else if z.HasExtensions() && z.EncExt(yy4818) {
+ } else if !yym4819 && z.IsJSONHandle() {
+ z.EncJSONMarshal(yy4818)
} else {
- z.EncFallback(yy4813)
+ z.EncFallback(yy4818)
}
}
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
@@ -61795,78 +61859,78 @@ func (x codecSelfer1234) decSliceruntime_RawExtension(v *[]pkg5_runtime.RawExten
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yyv4815 := *v
- yyh4815, yyl4815 := z.DecSliceHelperStart()
- var yyc4815 bool
- if yyl4815 == 0 {
- if yyv4815 == nil {
- yyv4815 = []pkg5_runtime.RawExtension{}
- yyc4815 = true
- } else if len(yyv4815) != 0 {
- yyv4815 = yyv4815[:0]
- yyc4815 = true
+ yyv4820 := *v
+ yyh4820, yyl4820 := z.DecSliceHelperStart()
+ var yyc4820 bool
+ if yyl4820 == 0 {
+ if yyv4820 == nil {
+ yyv4820 = []pkg5_runtime.RawExtension{}
+ yyc4820 = true
+ } else if len(yyv4820) != 0 {
+ yyv4820 = yyv4820[:0]
+ yyc4820 = true
}
- } else if yyl4815 > 0 {
- var yyrr4815, yyrl4815 int
- var yyrt4815 bool
- if yyl4815 > cap(yyv4815) {
+ } else if yyl4820 > 0 {
+ var yyrr4820, yyrl4820 int
+ var yyrt4820 bool
+ if yyl4820 > cap(yyv4820) {
- yyrg4815 := len(yyv4815) > 0
- yyv24815 := yyv4815
- yyrl4815, yyrt4815 = z.DecInferLen(yyl4815, z.DecBasicHandle().MaxInitLen, 40)
- if yyrt4815 {
- if yyrl4815 <= cap(yyv4815) {
- yyv4815 = yyv4815[:yyrl4815]
+ yyrg4820 := len(yyv4820) > 0
+ yyv24820 := yyv4820
+ yyrl4820, yyrt4820 = z.DecInferLen(yyl4820, z.DecBasicHandle().MaxInitLen, 40)
+ if yyrt4820 {
+ if yyrl4820 <= cap(yyv4820) {
+ yyv4820 = yyv4820[:yyrl4820]
} else {
- yyv4815 = make([]pkg5_runtime.RawExtension, yyrl4815)
+ yyv4820 = make([]pkg5_runtime.RawExtension, yyrl4820)
}
} else {
- yyv4815 = make([]pkg5_runtime.RawExtension, yyrl4815)
+ yyv4820 = make([]pkg5_runtime.RawExtension, yyrl4820)
}
- yyc4815 = true
- yyrr4815 = len(yyv4815)
- if yyrg4815 {
- copy(yyv4815, yyv24815)
+ yyc4820 = true
+ yyrr4820 = len(yyv4820)
+ if yyrg4820 {
+ copy(yyv4820, yyv24820)
}
- } else if yyl4815 != len(yyv4815) {
- yyv4815 = yyv4815[:yyl4815]
- yyc4815 = true
+ } else if yyl4820 != len(yyv4820) {
+ yyv4820 = yyv4820[:yyl4820]
+ yyc4820 = true
}
- yyj4815 := 0
- for ; yyj4815 < yyrr4815; yyj4815++ {
- yyh4815.ElemContainerState(yyj4815)
+ yyj4820 := 0
+ for ; yyj4820 < yyrr4820; yyj4820++ {
+ yyh4820.ElemContainerState(yyj4820)
if r.TryDecodeAsNil() {
- yyv4815[yyj4815] = pkg5_runtime.RawExtension{}
+ yyv4820[yyj4820] = pkg5_runtime.RawExtension{}
} else {
- yyv4816 := &yyv4815[yyj4815]
- yym4817 := z.DecBinary()
- _ = yym4817
+ yyv4821 := &yyv4820[yyj4820]
+ yym4822 := z.DecBinary()
+ _ = yym4822
if false {
- } else if z.HasExtensions() && z.DecExt(yyv4816) {
- } else if !yym4817 && z.IsJSONHandle() {
- z.DecJSONUnmarshal(yyv4816)
+ } else if z.HasExtensions() && z.DecExt(yyv4821) {
+ } else if !yym4822 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv4821)
} else {
- z.DecFallback(yyv4816, false)
+ z.DecFallback(yyv4821, false)
}
}
}
- if yyrt4815 {
- for ; yyj4815 < yyl4815; yyj4815++ {
- yyv4815 = append(yyv4815, pkg5_runtime.RawExtension{})
- yyh4815.ElemContainerState(yyj4815)
+ if yyrt4820 {
+ for ; yyj4820 < yyl4820; yyj4820++ {
+ yyv4820 = append(yyv4820, pkg5_runtime.RawExtension{})
+ yyh4820.ElemContainerState(yyj4820)
if r.TryDecodeAsNil() {
- yyv4815[yyj4815] = pkg5_runtime.RawExtension{}
+ yyv4820[yyj4820] = pkg5_runtime.RawExtension{}
} else {
- yyv4818 := &yyv4815[yyj4815]
- yym4819 := z.DecBinary()
- _ = yym4819
+ yyv4823 := &yyv4820[yyj4820]
+ yym4824 := z.DecBinary()
+ _ = yym4824
if false {
- } else if z.HasExtensions() && z.DecExt(yyv4818) {
- } else if !yym4819 && z.IsJSONHandle() {
- z.DecJSONUnmarshal(yyv4818)
+ } else if z.HasExtensions() && z.DecExt(yyv4823) {
+ } else if !yym4824 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv4823)
} else {
- z.DecFallback(yyv4818, false)
+ z.DecFallback(yyv4823, false)
}
}
@@ -61874,27 +61938,27 @@ func (x codecSelfer1234) decSliceruntime_RawExtension(v *[]pkg5_runtime.RawExten
}
} else {
- yyj4815 := 0
- for ; !r.CheckBreak(); yyj4815++ {
+ yyj4820 := 0
+ for ; !r.CheckBreak(); yyj4820++ {
- if yyj4815 >= len(yyv4815) {
- yyv4815 = append(yyv4815, pkg5_runtime.RawExtension{}) // var yyz4815 pkg5_runtime.RawExtension
- yyc4815 = true
+ if yyj4820 >= len(yyv4820) {
+ yyv4820 = append(yyv4820, pkg5_runtime.RawExtension{}) // var yyz4820 pkg5_runtime.RawExtension
+ yyc4820 = true
}
- yyh4815.ElemContainerState(yyj4815)
- if yyj4815 < len(yyv4815) {
+ yyh4820.ElemContainerState(yyj4820)
+ if yyj4820 < len(yyv4820) {
if r.TryDecodeAsNil() {
- yyv4815[yyj4815] = pkg5_runtime.RawExtension{}
+ yyv4820[yyj4820] = pkg5_runtime.RawExtension{}
} else {
- yyv4820 := &yyv4815[yyj4815]
- yym4821 := z.DecBinary()
- _ = yym4821
+ yyv4825 := &yyv4820[yyj4820]
+ yym4826 := z.DecBinary()
+ _ = yym4826
if false {
- } else if z.HasExtensions() && z.DecExt(yyv4820) {
- } else if !yym4821 && z.IsJSONHandle() {
- z.DecJSONUnmarshal(yyv4820)
+ } else if z.HasExtensions() && z.DecExt(yyv4825) {
+ } else if !yym4826 && z.IsJSONHandle() {
+ z.DecJSONUnmarshal(yyv4825)
} else {
- z.DecFallback(yyv4820, false)
+ z.DecFallback(yyv4825, false)
}
}
@@ -61903,17 +61967,17 @@ func (x codecSelfer1234) decSliceruntime_RawExtension(v *[]pkg5_runtime.RawExten
}
}
- if yyj4815 < len(yyv4815) {
- yyv4815 = yyv4815[:yyj4815]
- yyc4815 = true
- } else if yyj4815 == 0 && yyv4815 == nil {
- yyv4815 = []pkg5_runtime.RawExtension{}
- yyc4815 = true
+ if yyj4820 < len(yyv4820) {
+ yyv4820 = yyv4820[:yyj4820]
+ yyc4820 = true
+ } else if yyj4820 == 0 && yyv4820 == nil {
+ yyv4820 = []pkg5_runtime.RawExtension{}
+ yyc4820 = true
}
}
- yyh4815.End()
- if yyc4815 {
- *v = yyv4815
+ yyh4820.End()
+ if yyc4820 {
+ *v = yyv4820
}
}
@@ -61922,10 +61986,10 @@ func (x codecSelfer1234) encSliceLimitRangeItem(v []LimitRangeItem, e *codec1978
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
r.EncodeArrayStart(len(v))
- for _, yyv4822 := range v {
+ for _, yyv4827 := range v {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy4823 := &yyv4822
- yy4823.CodecEncodeSelf(e)
+ yy4828 := &yyv4827
+ yy4828.CodecEncodeSelf(e)
}
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -61935,83 +61999,83 @@ func (x codecSelfer1234) decSliceLimitRangeItem(v *[]LimitRangeItem, d *codec197
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yyv4824 := *v
- yyh4824, yyl4824 := z.DecSliceHelperStart()
- var yyc4824 bool
- if yyl4824 == 0 {
- if yyv4824 == nil {
- yyv4824 = []LimitRangeItem{}
- yyc4824 = true
- } else if len(yyv4824) != 0 {
- yyv4824 = yyv4824[:0]
- yyc4824 = true
+ yyv4829 := *v
+ yyh4829, yyl4829 := z.DecSliceHelperStart()
+ var yyc4829 bool
+ if yyl4829 == 0 {
+ if yyv4829 == nil {
+ yyv4829 = []LimitRangeItem{}
+ yyc4829 = true
+ } else if len(yyv4829) != 0 {
+ yyv4829 = yyv4829[:0]
+ yyc4829 = true
}
- } else if yyl4824 > 0 {
- var yyrr4824, yyrl4824 int
- var yyrt4824 bool
- if yyl4824 > cap(yyv4824) {
+ } else if yyl4829 > 0 {
+ var yyrr4829, yyrl4829 int
+ var yyrt4829 bool
+ if yyl4829 > cap(yyv4829) {
- yyrg4824 := len(yyv4824) > 0
- yyv24824 := yyv4824
- yyrl4824, yyrt4824 = z.DecInferLen(yyl4824, z.DecBasicHandle().MaxInitLen, 56)
- if yyrt4824 {
- if yyrl4824 <= cap(yyv4824) {
- yyv4824 = yyv4824[:yyrl4824]
+ yyrg4829 := len(yyv4829) > 0
+ yyv24829 := yyv4829
+ yyrl4829, yyrt4829 = z.DecInferLen(yyl4829, z.DecBasicHandle().MaxInitLen, 56)
+ if yyrt4829 {
+ if yyrl4829 <= cap(yyv4829) {
+ yyv4829 = yyv4829[:yyrl4829]
} else {
- yyv4824 = make([]LimitRangeItem, yyrl4824)
+ yyv4829 = make([]LimitRangeItem, yyrl4829)
}
} else {
- yyv4824 = make([]LimitRangeItem, yyrl4824)
+ yyv4829 = make([]LimitRangeItem, yyrl4829)
}
- yyc4824 = true
- yyrr4824 = len(yyv4824)
- if yyrg4824 {
- copy(yyv4824, yyv24824)
+ yyc4829 = true
+ yyrr4829 = len(yyv4829)
+ if yyrg4829 {
+ copy(yyv4829, yyv24829)
}
- } else if yyl4824 != len(yyv4824) {
- yyv4824 = yyv4824[:yyl4824]
- yyc4824 = true
+ } else if yyl4829 != len(yyv4829) {
+ yyv4829 = yyv4829[:yyl4829]
+ yyc4829 = true
}
- yyj4824 := 0
- for ; yyj4824 < yyrr4824; yyj4824++ {
- yyh4824.ElemContainerState(yyj4824)
+ yyj4829 := 0
+ for ; yyj4829 < yyrr4829; yyj4829++ {
+ yyh4829.ElemContainerState(yyj4829)
if r.TryDecodeAsNil() {
- yyv4824[yyj4824] = LimitRangeItem{}
+ yyv4829[yyj4829] = LimitRangeItem{}
} else {
- yyv4825 := &yyv4824[yyj4824]
- yyv4825.CodecDecodeSelf(d)
+ yyv4830 := &yyv4829[yyj4829]
+ yyv4830.CodecDecodeSelf(d)
}
}
- if yyrt4824 {
- for ; yyj4824 < yyl4824; yyj4824++ {
- yyv4824 = append(yyv4824, LimitRangeItem{})
- yyh4824.ElemContainerState(yyj4824)
+ if yyrt4829 {
+ for ; yyj4829 < yyl4829; yyj4829++ {
+ yyv4829 = append(yyv4829, LimitRangeItem{})
+ yyh4829.ElemContainerState(yyj4829)
if r.TryDecodeAsNil() {
- yyv4824[yyj4824] = LimitRangeItem{}
+ yyv4829[yyj4829] = LimitRangeItem{}
} else {
- yyv4826 := &yyv4824[yyj4824]
- yyv4826.CodecDecodeSelf(d)
+ yyv4831 := &yyv4829[yyj4829]
+ yyv4831.CodecDecodeSelf(d)
}
}
}
} else {
- yyj4824 := 0
- for ; !r.CheckBreak(); yyj4824++ {
+ yyj4829 := 0
+ for ; !r.CheckBreak(); yyj4829++ {
- if yyj4824 >= len(yyv4824) {
- yyv4824 = append(yyv4824, LimitRangeItem{}) // var yyz4824 LimitRangeItem
- yyc4824 = true
+ if yyj4829 >= len(yyv4829) {
+ yyv4829 = append(yyv4829, LimitRangeItem{}) // var yyz4829 LimitRangeItem
+ yyc4829 = true
}
- yyh4824.ElemContainerState(yyj4824)
- if yyj4824 < len(yyv4824) {
+ yyh4829.ElemContainerState(yyj4829)
+ if yyj4829 < len(yyv4829) {
if r.TryDecodeAsNil() {
- yyv4824[yyj4824] = LimitRangeItem{}
+ yyv4829[yyj4829] = LimitRangeItem{}
} else {
- yyv4827 := &yyv4824[yyj4824]
- yyv4827.CodecDecodeSelf(d)
+ yyv4832 := &yyv4829[yyj4829]
+ yyv4832.CodecDecodeSelf(d)
}
} else {
@@ -62019,17 +62083,17 @@ func (x codecSelfer1234) decSliceLimitRangeItem(v *[]LimitRangeItem, d *codec197
}
}
- if yyj4824 < len(yyv4824) {
- yyv4824 = yyv4824[:yyj4824]
- yyc4824 = true
- } else if yyj4824 == 0 && yyv4824 == nil {
- yyv4824 = []LimitRangeItem{}
- yyc4824 = true
+ if yyj4829 < len(yyv4829) {
+ yyv4829 = yyv4829[:yyj4829]
+ yyc4829 = true
+ } else if yyj4829 == 0 && yyv4829 == nil {
+ yyv4829 = []LimitRangeItem{}
+ yyc4829 = true
}
}
- yyh4824.End()
- if yyc4824 {
- *v = yyv4824
+ yyh4829.End()
+ if yyc4829 {
+ *v = yyv4829
}
}
@@ -62038,10 +62102,10 @@ func (x codecSelfer1234) encSliceLimitRange(v []LimitRange, e *codec1978.Encoder
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
r.EncodeArrayStart(len(v))
- for _, yyv4828 := range v {
+ for _, yyv4833 := range v {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy4829 := &yyv4828
- yy4829.CodecEncodeSelf(e)
+ yy4834 := &yyv4833
+ yy4834.CodecEncodeSelf(e)
}
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -62051,127 +62115,12 @@ func (x codecSelfer1234) decSliceLimitRange(v *[]LimitRange, d *codec1978.Decode
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yyv4830 := *v
- yyh4830, yyl4830 := z.DecSliceHelperStart()
- var yyc4830 bool
- if yyl4830 == 0 {
- if yyv4830 == nil {
- yyv4830 = []LimitRange{}
- yyc4830 = true
- } else if len(yyv4830) != 0 {
- yyv4830 = yyv4830[:0]
- yyc4830 = true
- }
- } else if yyl4830 > 0 {
- var yyrr4830, yyrl4830 int
- var yyrt4830 bool
- if yyl4830 > cap(yyv4830) {
-
- yyrg4830 := len(yyv4830) > 0
- yyv24830 := yyv4830
- yyrl4830, yyrt4830 = z.DecInferLen(yyl4830, z.DecBasicHandle().MaxInitLen, 280)
- if yyrt4830 {
- if yyrl4830 <= cap(yyv4830) {
- yyv4830 = yyv4830[:yyrl4830]
- } else {
- yyv4830 = make([]LimitRange, yyrl4830)
- }
- } else {
- yyv4830 = make([]LimitRange, yyrl4830)
- }
- yyc4830 = true
- yyrr4830 = len(yyv4830)
- if yyrg4830 {
- copy(yyv4830, yyv24830)
- }
- } else if yyl4830 != len(yyv4830) {
- yyv4830 = yyv4830[:yyl4830]
- yyc4830 = true
- }
- yyj4830 := 0
- for ; yyj4830 < yyrr4830; yyj4830++ {
- yyh4830.ElemContainerState(yyj4830)
- if r.TryDecodeAsNil() {
- yyv4830[yyj4830] = LimitRange{}
- } else {
- yyv4831 := &yyv4830[yyj4830]
- yyv4831.CodecDecodeSelf(d)
- }
-
- }
- if yyrt4830 {
- for ; yyj4830 < yyl4830; yyj4830++ {
- yyv4830 = append(yyv4830, LimitRange{})
- yyh4830.ElemContainerState(yyj4830)
- if r.TryDecodeAsNil() {
- yyv4830[yyj4830] = LimitRange{}
- } else {
- yyv4832 := &yyv4830[yyj4830]
- yyv4832.CodecDecodeSelf(d)
- }
-
- }
- }
-
- } else {
- yyj4830 := 0
- for ; !r.CheckBreak(); yyj4830++ {
-
- if yyj4830 >= len(yyv4830) {
- yyv4830 = append(yyv4830, LimitRange{}) // var yyz4830 LimitRange
- yyc4830 = true
- }
- yyh4830.ElemContainerState(yyj4830)
- if yyj4830 < len(yyv4830) {
- if r.TryDecodeAsNil() {
- yyv4830[yyj4830] = LimitRange{}
- } else {
- yyv4833 := &yyv4830[yyj4830]
- yyv4833.CodecDecodeSelf(d)
- }
-
- } else {
- z.DecSwallow()
- }
-
- }
- if yyj4830 < len(yyv4830) {
- yyv4830 = yyv4830[:yyj4830]
- yyc4830 = true
- } else if yyj4830 == 0 && yyv4830 == nil {
- yyv4830 = []LimitRange{}
- yyc4830 = true
- }
- }
- yyh4830.End()
- if yyc4830 {
- *v = yyv4830
- }
-}
-
-func (x codecSelfer1234) encSliceResourceQuotaScope(v []ResourceQuotaScope, e *codec1978.Encoder) {
- var h codecSelfer1234
- z, r := codec1978.GenHelperEncoder(e)
- _, _, _ = h, z, r
- r.EncodeArrayStart(len(v))
- for _, yyv4834 := range v {
- z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yyv4834.CodecEncodeSelf(e)
- }
- z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
-}
-
-func (x codecSelfer1234) decSliceResourceQuotaScope(v *[]ResourceQuotaScope, d *codec1978.Decoder) {
- var h codecSelfer1234
- z, r := codec1978.GenHelperDecoder(d)
- _, _, _ = h, z, r
-
yyv4835 := *v
yyh4835, yyl4835 := z.DecSliceHelperStart()
var yyc4835 bool
if yyl4835 == 0 {
if yyv4835 == nil {
- yyv4835 = []ResourceQuotaScope{}
+ yyv4835 = []LimitRange{}
yyc4835 = true
} else if len(yyv4835) != 0 {
yyv4835 = yyv4835[:0]
@@ -62182,18 +62131,23 @@ func (x codecSelfer1234) decSliceResourceQuotaScope(v *[]ResourceQuotaScope, d *
var yyrt4835 bool
if yyl4835 > cap(yyv4835) {
- yyrl4835, yyrt4835 = z.DecInferLen(yyl4835, z.DecBasicHandle().MaxInitLen, 16)
+ yyrg4835 := len(yyv4835) > 0
+ yyv24835 := yyv4835
+ yyrl4835, yyrt4835 = z.DecInferLen(yyl4835, z.DecBasicHandle().MaxInitLen, 280)
if yyrt4835 {
if yyrl4835 <= cap(yyv4835) {
yyv4835 = yyv4835[:yyrl4835]
} else {
- yyv4835 = make([]ResourceQuotaScope, yyrl4835)
+ yyv4835 = make([]LimitRange, yyrl4835)
}
} else {
- yyv4835 = make([]ResourceQuotaScope, yyrl4835)
+ yyv4835 = make([]LimitRange, yyrl4835)
}
yyc4835 = true
yyrr4835 = len(yyv4835)
+ if yyrg4835 {
+ copy(yyv4835, yyv24835)
+ }
} else if yyl4835 != len(yyv4835) {
yyv4835 = yyv4835[:yyl4835]
yyc4835 = true
@@ -62202,20 +62156,22 @@ func (x codecSelfer1234) decSliceResourceQuotaScope(v *[]ResourceQuotaScope, d *
for ; yyj4835 < yyrr4835; yyj4835++ {
yyh4835.ElemContainerState(yyj4835)
if r.TryDecodeAsNil() {
- yyv4835[yyj4835] = ""
+ yyv4835[yyj4835] = LimitRange{}
} else {
- yyv4835[yyj4835] = ResourceQuotaScope(r.DecodeString())
+ yyv4836 := &yyv4835[yyj4835]
+ yyv4836.CodecDecodeSelf(d)
}
}
if yyrt4835 {
for ; yyj4835 < yyl4835; yyj4835++ {
- yyv4835 = append(yyv4835, "")
+ yyv4835 = append(yyv4835, LimitRange{})
yyh4835.ElemContainerState(yyj4835)
if r.TryDecodeAsNil() {
- yyv4835[yyj4835] = ""
+ yyv4835[yyj4835] = LimitRange{}
} else {
- yyv4835[yyj4835] = ResourceQuotaScope(r.DecodeString())
+ yyv4837 := &yyv4835[yyj4835]
+ yyv4837.CodecDecodeSelf(d)
}
}
@@ -62226,15 +62182,16 @@ func (x codecSelfer1234) decSliceResourceQuotaScope(v *[]ResourceQuotaScope, d *
for ; !r.CheckBreak(); yyj4835++ {
if yyj4835 >= len(yyv4835) {
- yyv4835 = append(yyv4835, "") // var yyz4835 ResourceQuotaScope
+ yyv4835 = append(yyv4835, LimitRange{}) // var yyz4835 LimitRange
yyc4835 = true
}
yyh4835.ElemContainerState(yyj4835)
if yyj4835 < len(yyv4835) {
if r.TryDecodeAsNil() {
- yyv4835[yyj4835] = ""
+ yyv4835[yyj4835] = LimitRange{}
} else {
- yyv4835[yyj4835] = ResourceQuotaScope(r.DecodeString())
+ yyv4838 := &yyv4835[yyj4835]
+ yyv4838.CodecDecodeSelf(d)
}
} else {
@@ -62246,7 +62203,7 @@ func (x codecSelfer1234) decSliceResourceQuotaScope(v *[]ResourceQuotaScope, d *
yyv4835 = yyv4835[:yyj4835]
yyc4835 = true
} else if yyj4835 == 0 && yyv4835 == nil {
- yyv4835 = []ResourceQuotaScope{}
+ yyv4835 = []LimitRange{}
yyc4835 = true
}
}
@@ -62256,15 +62213,122 @@ func (x codecSelfer1234) decSliceResourceQuotaScope(v *[]ResourceQuotaScope, d *
}
}
-func (x codecSelfer1234) encSliceResourceQuota(v []ResourceQuota, e *codec1978.Encoder) {
+func (x codecSelfer1234) encSliceResourceQuotaScope(v []ResourceQuotaScope, e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
r.EncodeArrayStart(len(v))
for _, yyv4839 := range v {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy4840 := &yyv4839
- yy4840.CodecEncodeSelf(e)
+ yyv4839.CodecEncodeSelf(e)
+ }
+ z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
+}
+
+func (x codecSelfer1234) decSliceResourceQuotaScope(v *[]ResourceQuotaScope, d *codec1978.Decoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperDecoder(d)
+ _, _, _ = h, z, r
+
+ yyv4840 := *v
+ yyh4840, yyl4840 := z.DecSliceHelperStart()
+ var yyc4840 bool
+ if yyl4840 == 0 {
+ if yyv4840 == nil {
+ yyv4840 = []ResourceQuotaScope{}
+ yyc4840 = true
+ } else if len(yyv4840) != 0 {
+ yyv4840 = yyv4840[:0]
+ yyc4840 = true
+ }
+ } else if yyl4840 > 0 {
+ var yyrr4840, yyrl4840 int
+ var yyrt4840 bool
+ if yyl4840 > cap(yyv4840) {
+
+ yyrl4840, yyrt4840 = z.DecInferLen(yyl4840, z.DecBasicHandle().MaxInitLen, 16)
+ if yyrt4840 {
+ if yyrl4840 <= cap(yyv4840) {
+ yyv4840 = yyv4840[:yyrl4840]
+ } else {
+ yyv4840 = make([]ResourceQuotaScope, yyrl4840)
+ }
+ } else {
+ yyv4840 = make([]ResourceQuotaScope, yyrl4840)
+ }
+ yyc4840 = true
+ yyrr4840 = len(yyv4840)
+ } else if yyl4840 != len(yyv4840) {
+ yyv4840 = yyv4840[:yyl4840]
+ yyc4840 = true
+ }
+ yyj4840 := 0
+ for ; yyj4840 < yyrr4840; yyj4840++ {
+ yyh4840.ElemContainerState(yyj4840)
+ if r.TryDecodeAsNil() {
+ yyv4840[yyj4840] = ""
+ } else {
+ yyv4840[yyj4840] = ResourceQuotaScope(r.DecodeString())
+ }
+
+ }
+ if yyrt4840 {
+ for ; yyj4840 < yyl4840; yyj4840++ {
+ yyv4840 = append(yyv4840, "")
+ yyh4840.ElemContainerState(yyj4840)
+ if r.TryDecodeAsNil() {
+ yyv4840[yyj4840] = ""
+ } else {
+ yyv4840[yyj4840] = ResourceQuotaScope(r.DecodeString())
+ }
+
+ }
+ }
+
+ } else {
+ yyj4840 := 0
+ for ; !r.CheckBreak(); yyj4840++ {
+
+ if yyj4840 >= len(yyv4840) {
+ yyv4840 = append(yyv4840, "") // var yyz4840 ResourceQuotaScope
+ yyc4840 = true
+ }
+ yyh4840.ElemContainerState(yyj4840)
+ if yyj4840 < len(yyv4840) {
+ if r.TryDecodeAsNil() {
+ yyv4840[yyj4840] = ""
+ } else {
+ yyv4840[yyj4840] = ResourceQuotaScope(r.DecodeString())
+ }
+
+ } else {
+ z.DecSwallow()
+ }
+
+ }
+ if yyj4840 < len(yyv4840) {
+ yyv4840 = yyv4840[:yyj4840]
+ yyc4840 = true
+ } else if yyj4840 == 0 && yyv4840 == nil {
+ yyv4840 = []ResourceQuotaScope{}
+ yyc4840 = true
+ }
+ }
+ yyh4840.End()
+ if yyc4840 {
+ *v = yyv4840
+ }
+}
+
+func (x codecSelfer1234) encSliceResourceQuota(v []ResourceQuota, e *codec1978.Encoder) {
+ var h codecSelfer1234
+ z, r := codec1978.GenHelperEncoder(e)
+ _, _, _ = h, z, r
+ r.EncodeArrayStart(len(v))
+ for _, yyv4844 := range v {
+ z.EncSendContainerState(codecSelfer_containerArrayElem1234)
+ yy4845 := &yyv4844
+ yy4845.CodecEncodeSelf(e)
}
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -62274,83 +62338,83 @@ func (x codecSelfer1234) decSliceResourceQuota(v *[]ResourceQuota, d *codec1978.
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yyv4841 := *v
- yyh4841, yyl4841 := z.DecSliceHelperStart()
- var yyc4841 bool
- if yyl4841 == 0 {
- if yyv4841 == nil {
- yyv4841 = []ResourceQuota{}
- yyc4841 = true
- } else if len(yyv4841) != 0 {
- yyv4841 = yyv4841[:0]
- yyc4841 = true
+ yyv4846 := *v
+ yyh4846, yyl4846 := z.DecSliceHelperStart()
+ var yyc4846 bool
+ if yyl4846 == 0 {
+ if yyv4846 == nil {
+ yyv4846 = []ResourceQuota{}
+ yyc4846 = true
+ } else if len(yyv4846) != 0 {
+ yyv4846 = yyv4846[:0]
+ yyc4846 = true
}
- } else if yyl4841 > 0 {
- var yyrr4841, yyrl4841 int
- var yyrt4841 bool
- if yyl4841 > cap(yyv4841) {
+ } else if yyl4846 > 0 {
+ var yyrr4846, yyrl4846 int
+ var yyrt4846 bool
+ if yyl4846 > cap(yyv4846) {
- yyrg4841 := len(yyv4841) > 0
- yyv24841 := yyv4841
- yyrl4841, yyrt4841 = z.DecInferLen(yyl4841, z.DecBasicHandle().MaxInitLen, 304)
- if yyrt4841 {
- if yyrl4841 <= cap(yyv4841) {
- yyv4841 = yyv4841[:yyrl4841]
+ yyrg4846 := len(yyv4846) > 0
+ yyv24846 := yyv4846
+ yyrl4846, yyrt4846 = z.DecInferLen(yyl4846, z.DecBasicHandle().MaxInitLen, 304)
+ if yyrt4846 {
+ if yyrl4846 <= cap(yyv4846) {
+ yyv4846 = yyv4846[:yyrl4846]
} else {
- yyv4841 = make([]ResourceQuota, yyrl4841)
+ yyv4846 = make([]ResourceQuota, yyrl4846)
}
} else {
- yyv4841 = make([]ResourceQuota, yyrl4841)
+ yyv4846 = make([]ResourceQuota, yyrl4846)
}
- yyc4841 = true
- yyrr4841 = len(yyv4841)
- if yyrg4841 {
- copy(yyv4841, yyv24841)
+ yyc4846 = true
+ yyrr4846 = len(yyv4846)
+ if yyrg4846 {
+ copy(yyv4846, yyv24846)
}
- } else if yyl4841 != len(yyv4841) {
- yyv4841 = yyv4841[:yyl4841]
- yyc4841 = true
+ } else if yyl4846 != len(yyv4846) {
+ yyv4846 = yyv4846[:yyl4846]
+ yyc4846 = true
}
- yyj4841 := 0
- for ; yyj4841 < yyrr4841; yyj4841++ {
- yyh4841.ElemContainerState(yyj4841)
+ yyj4846 := 0
+ for ; yyj4846 < yyrr4846; yyj4846++ {
+ yyh4846.ElemContainerState(yyj4846)
if r.TryDecodeAsNil() {
- yyv4841[yyj4841] = ResourceQuota{}
+ yyv4846[yyj4846] = ResourceQuota{}
} else {
- yyv4842 := &yyv4841[yyj4841]
- yyv4842.CodecDecodeSelf(d)
+ yyv4847 := &yyv4846[yyj4846]
+ yyv4847.CodecDecodeSelf(d)
}
}
- if yyrt4841 {
- for ; yyj4841 < yyl4841; yyj4841++ {
- yyv4841 = append(yyv4841, ResourceQuota{})
- yyh4841.ElemContainerState(yyj4841)
+ if yyrt4846 {
+ for ; yyj4846 < yyl4846; yyj4846++ {
+ yyv4846 = append(yyv4846, ResourceQuota{})
+ yyh4846.ElemContainerState(yyj4846)
if r.TryDecodeAsNil() {
- yyv4841[yyj4841] = ResourceQuota{}
+ yyv4846[yyj4846] = ResourceQuota{}
} else {
- yyv4843 := &yyv4841[yyj4841]
- yyv4843.CodecDecodeSelf(d)
+ yyv4848 := &yyv4846[yyj4846]
+ yyv4848.CodecDecodeSelf(d)
}
}
}
} else {
- yyj4841 := 0
- for ; !r.CheckBreak(); yyj4841++ {
+ yyj4846 := 0
+ for ; !r.CheckBreak(); yyj4846++ {
- if yyj4841 >= len(yyv4841) {
- yyv4841 = append(yyv4841, ResourceQuota{}) // var yyz4841 ResourceQuota
- yyc4841 = true
+ if yyj4846 >= len(yyv4846) {
+ yyv4846 = append(yyv4846, ResourceQuota{}) // var yyz4846 ResourceQuota
+ yyc4846 = true
}
- yyh4841.ElemContainerState(yyj4841)
- if yyj4841 < len(yyv4841) {
+ yyh4846.ElemContainerState(yyj4846)
+ if yyj4846 < len(yyv4846) {
if r.TryDecodeAsNil() {
- yyv4841[yyj4841] = ResourceQuota{}
+ yyv4846[yyj4846] = ResourceQuota{}
} else {
- yyv4844 := &yyv4841[yyj4841]
- yyv4844.CodecDecodeSelf(d)
+ yyv4849 := &yyv4846[yyj4846]
+ yyv4849.CodecDecodeSelf(d)
}
} else {
@@ -62358,17 +62422,17 @@ func (x codecSelfer1234) decSliceResourceQuota(v *[]ResourceQuota, d *codec1978.
}
}
- if yyj4841 < len(yyv4841) {
- yyv4841 = yyv4841[:yyj4841]
- yyc4841 = true
- } else if yyj4841 == 0 && yyv4841 == nil {
- yyv4841 = []ResourceQuota{}
- yyc4841 = true
+ if yyj4846 < len(yyv4846) {
+ yyv4846 = yyv4846[:yyj4846]
+ yyc4846 = true
+ } else if yyj4846 == 0 && yyv4846 == nil {
+ yyv4846 = []ResourceQuota{}
+ yyc4846 = true
}
}
- yyh4841.End()
- if yyc4841 {
- *v = yyv4841
+ yyh4846.End()
+ if yyc4846 {
+ *v = yyv4846
}
}
@@ -62377,23 +62441,23 @@ func (x codecSelfer1234) encMapstringSliceuint8(v map[string][]uint8, e *codec19
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
r.EncodeMapStart(len(v))
- for yyk4845, yyv4845 := range v {
+ for yyk4850, yyv4850 := range v {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
- yym4846 := z.EncBinary()
- _ = yym4846
+ yym4851 := z.EncBinary()
+ _ = yym4851
if false {
} else {
- r.EncodeString(codecSelferC_UTF81234, string(yyk4845))
+ r.EncodeString(codecSelferC_UTF81234, string(yyk4850))
}
z.EncSendContainerState(codecSelfer_containerMapValue1234)
- if yyv4845 == nil {
+ if yyv4850 == nil {
r.EncodeNil()
} else {
- yym4847 := z.EncBinary()
- _ = yym4847
+ yym4852 := z.EncBinary()
+ _ = yym4852
if false {
} else {
- r.EncodeStringBytes(codecSelferC_RAW1234, []byte(yyv4845))
+ r.EncodeStringBytes(codecSelferC_RAW1234, []byte(yyv4850))
}
}
}
@@ -62405,80 +62469,80 @@ func (x codecSelfer1234) decMapstringSliceuint8(v *map[string][]uint8, d *codec1
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yyv4848 := *v
- yyl4848 := r.ReadMapStart()
- yybh4848 := z.DecBasicHandle()
- if yyv4848 == nil {
- yyrl4848, _ := z.DecInferLen(yyl4848, yybh4848.MaxInitLen, 40)
- yyv4848 = make(map[string][]uint8, yyrl4848)
- *v = yyv4848
+ yyv4853 := *v
+ yyl4853 := r.ReadMapStart()
+ yybh4853 := z.DecBasicHandle()
+ if yyv4853 == nil {
+ yyrl4853, _ := z.DecInferLen(yyl4853, yybh4853.MaxInitLen, 40)
+ yyv4853 = make(map[string][]uint8, yyrl4853)
+ *v = yyv4853
}
- var yymk4848 string
- var yymv4848 []uint8
- var yymg4848 bool
- if yybh4848.MapValueReset {
- yymg4848 = true
+ var yymk4853 string
+ var yymv4853 []uint8
+ var yymg4853 bool
+ if yybh4853.MapValueReset {
+ yymg4853 = true
}
- if yyl4848 > 0 {
- for yyj4848 := 0; yyj4848 < yyl4848; yyj4848++ {
+ if yyl4853 > 0 {
+ for yyj4853 := 0; yyj4853 < yyl4853; yyj4853++ {
z.DecSendContainerState(codecSelfer_containerMapKey1234)
if r.TryDecodeAsNil() {
- yymk4848 = ""
+ yymk4853 = ""
} else {
- yymk4848 = string(r.DecodeString())
+ yymk4853 = string(r.DecodeString())
}
- if yymg4848 {
- yymv4848 = yyv4848[yymk4848]
+ if yymg4853 {
+ yymv4853 = yyv4853[yymk4853]
} else {
- yymv4848 = nil
+ yymv4853 = nil
}
z.DecSendContainerState(codecSelfer_containerMapValue1234)
if r.TryDecodeAsNil() {
- yymv4848 = nil
+ yymv4853 = nil
} else {
- yyv4850 := &yymv4848
- yym4851 := z.DecBinary()
- _ = yym4851
+ yyv4855 := &yymv4853
+ yym4856 := z.DecBinary()
+ _ = yym4856
if false {
} else {
- *yyv4850 = r.DecodeBytes(*(*[]byte)(yyv4850), false, false)
+ *yyv4855 = r.DecodeBytes(*(*[]byte)(yyv4855), false, false)
}
}
- if yyv4848 != nil {
- yyv4848[yymk4848] = yymv4848
+ if yyv4853 != nil {
+ yyv4853[yymk4853] = yymv4853
}
}
- } else if yyl4848 < 0 {
- for yyj4848 := 0; !r.CheckBreak(); yyj4848++ {
+ } else if yyl4853 < 0 {
+ for yyj4853 := 0; !r.CheckBreak(); yyj4853++ {
z.DecSendContainerState(codecSelfer_containerMapKey1234)
if r.TryDecodeAsNil() {
- yymk4848 = ""
+ yymk4853 = ""
} else {
- yymk4848 = string(r.DecodeString())
+ yymk4853 = string(r.DecodeString())
}
- if yymg4848 {
- yymv4848 = yyv4848[yymk4848]
+ if yymg4853 {
+ yymv4853 = yyv4853[yymk4853]
} else {
- yymv4848 = nil
+ yymv4853 = nil
}
z.DecSendContainerState(codecSelfer_containerMapValue1234)
if r.TryDecodeAsNil() {
- yymv4848 = nil
+ yymv4853 = nil
} else {
- yyv4853 := &yymv4848
- yym4854 := z.DecBinary()
- _ = yym4854
+ yyv4858 := &yymv4853
+ yym4859 := z.DecBinary()
+ _ = yym4859
if false {
} else {
- *yyv4853 = r.DecodeBytes(*(*[]byte)(yyv4853), false, false)
+ *yyv4858 = r.DecodeBytes(*(*[]byte)(yyv4858), false, false)
}
}
- if yyv4848 != nil {
- yyv4848[yymk4848] = yymv4848
+ if yyv4853 != nil {
+ yyv4853[yymk4853] = yymv4853
}
}
} // else len==0: TODO: Should we clear map entries?
@@ -62490,10 +62554,10 @@ func (x codecSelfer1234) encSliceSecret(v []Secret, e *codec1978.Encoder) {
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
r.EncodeArrayStart(len(v))
- for _, yyv4855 := range v {
+ for _, yyv4860 := range v {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy4856 := &yyv4855
- yy4856.CodecEncodeSelf(e)
+ yy4861 := &yyv4860
+ yy4861.CodecEncodeSelf(e)
}
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -62503,83 +62567,83 @@ func (x codecSelfer1234) decSliceSecret(v *[]Secret, d *codec1978.Decoder) {
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yyv4857 := *v
- yyh4857, yyl4857 := z.DecSliceHelperStart()
- var yyc4857 bool
- if yyl4857 == 0 {
- if yyv4857 == nil {
- yyv4857 = []Secret{}
- yyc4857 = true
- } else if len(yyv4857) != 0 {
- yyv4857 = yyv4857[:0]
- yyc4857 = true
+ yyv4862 := *v
+ yyh4862, yyl4862 := z.DecSliceHelperStart()
+ var yyc4862 bool
+ if yyl4862 == 0 {
+ if yyv4862 == nil {
+ yyv4862 = []Secret{}
+ yyc4862 = true
+ } else if len(yyv4862) != 0 {
+ yyv4862 = yyv4862[:0]
+ yyc4862 = true
}
- } else if yyl4857 > 0 {
- var yyrr4857, yyrl4857 int
- var yyrt4857 bool
- if yyl4857 > cap(yyv4857) {
+ } else if yyl4862 > 0 {
+ var yyrr4862, yyrl4862 int
+ var yyrt4862 bool
+ if yyl4862 > cap(yyv4862) {
- yyrg4857 := len(yyv4857) > 0
- yyv24857 := yyv4857
- yyrl4857, yyrt4857 = z.DecInferLen(yyl4857, z.DecBasicHandle().MaxInitLen, 288)
- if yyrt4857 {
- if yyrl4857 <= cap(yyv4857) {
- yyv4857 = yyv4857[:yyrl4857]
+ yyrg4862 := len(yyv4862) > 0
+ yyv24862 := yyv4862
+ yyrl4862, yyrt4862 = z.DecInferLen(yyl4862, z.DecBasicHandle().MaxInitLen, 288)
+ if yyrt4862 {
+ if yyrl4862 <= cap(yyv4862) {
+ yyv4862 = yyv4862[:yyrl4862]
} else {
- yyv4857 = make([]Secret, yyrl4857)
+ yyv4862 = make([]Secret, yyrl4862)
}
} else {
- yyv4857 = make([]Secret, yyrl4857)
+ yyv4862 = make([]Secret, yyrl4862)
}
- yyc4857 = true
- yyrr4857 = len(yyv4857)
- if yyrg4857 {
- copy(yyv4857, yyv24857)
+ yyc4862 = true
+ yyrr4862 = len(yyv4862)
+ if yyrg4862 {
+ copy(yyv4862, yyv24862)
}
- } else if yyl4857 != len(yyv4857) {
- yyv4857 = yyv4857[:yyl4857]
- yyc4857 = true
+ } else if yyl4862 != len(yyv4862) {
+ yyv4862 = yyv4862[:yyl4862]
+ yyc4862 = true
}
- yyj4857 := 0
- for ; yyj4857 < yyrr4857; yyj4857++ {
- yyh4857.ElemContainerState(yyj4857)
+ yyj4862 := 0
+ for ; yyj4862 < yyrr4862; yyj4862++ {
+ yyh4862.ElemContainerState(yyj4862)
if r.TryDecodeAsNil() {
- yyv4857[yyj4857] = Secret{}
+ yyv4862[yyj4862] = Secret{}
} else {
- yyv4858 := &yyv4857[yyj4857]
- yyv4858.CodecDecodeSelf(d)
+ yyv4863 := &yyv4862[yyj4862]
+ yyv4863.CodecDecodeSelf(d)
}
}
- if yyrt4857 {
- for ; yyj4857 < yyl4857; yyj4857++ {
- yyv4857 = append(yyv4857, Secret{})
- yyh4857.ElemContainerState(yyj4857)
+ if yyrt4862 {
+ for ; yyj4862 < yyl4862; yyj4862++ {
+ yyv4862 = append(yyv4862, Secret{})
+ yyh4862.ElemContainerState(yyj4862)
if r.TryDecodeAsNil() {
- yyv4857[yyj4857] = Secret{}
+ yyv4862[yyj4862] = Secret{}
} else {
- yyv4859 := &yyv4857[yyj4857]
- yyv4859.CodecDecodeSelf(d)
+ yyv4864 := &yyv4862[yyj4862]
+ yyv4864.CodecDecodeSelf(d)
}
}
}
} else {
- yyj4857 := 0
- for ; !r.CheckBreak(); yyj4857++ {
+ yyj4862 := 0
+ for ; !r.CheckBreak(); yyj4862++ {
- if yyj4857 >= len(yyv4857) {
- yyv4857 = append(yyv4857, Secret{}) // var yyz4857 Secret
- yyc4857 = true
+ if yyj4862 >= len(yyv4862) {
+ yyv4862 = append(yyv4862, Secret{}) // var yyz4862 Secret
+ yyc4862 = true
}
- yyh4857.ElemContainerState(yyj4857)
- if yyj4857 < len(yyv4857) {
+ yyh4862.ElemContainerState(yyj4862)
+ if yyj4862 < len(yyv4862) {
if r.TryDecodeAsNil() {
- yyv4857[yyj4857] = Secret{}
+ yyv4862[yyj4862] = Secret{}
} else {
- yyv4860 := &yyv4857[yyj4857]
- yyv4860.CodecDecodeSelf(d)
+ yyv4865 := &yyv4862[yyj4862]
+ yyv4865.CodecDecodeSelf(d)
}
} else {
@@ -62587,17 +62651,17 @@ func (x codecSelfer1234) decSliceSecret(v *[]Secret, d *codec1978.Decoder) {
}
}
- if yyj4857 < len(yyv4857) {
- yyv4857 = yyv4857[:yyj4857]
- yyc4857 = true
- } else if yyj4857 == 0 && yyv4857 == nil {
- yyv4857 = []Secret{}
- yyc4857 = true
+ if yyj4862 < len(yyv4862) {
+ yyv4862 = yyv4862[:yyj4862]
+ yyc4862 = true
+ } else if yyj4862 == 0 && yyv4862 == nil {
+ yyv4862 = []Secret{}
+ yyc4862 = true
}
}
- yyh4857.End()
- if yyc4857 {
- *v = yyv4857
+ yyh4862.End()
+ if yyc4862 {
+ *v = yyv4862
}
}
@@ -62606,10 +62670,10 @@ func (x codecSelfer1234) encSliceConfigMap(v []ConfigMap, e *codec1978.Encoder)
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
r.EncodeArrayStart(len(v))
- for _, yyv4861 := range v {
+ for _, yyv4866 := range v {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy4862 := &yyv4861
- yy4862.CodecEncodeSelf(e)
+ yy4867 := &yyv4866
+ yy4867.CodecEncodeSelf(e)
}
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -62619,83 +62683,83 @@ func (x codecSelfer1234) decSliceConfigMap(v *[]ConfigMap, d *codec1978.Decoder)
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yyv4863 := *v
- yyh4863, yyl4863 := z.DecSliceHelperStart()
- var yyc4863 bool
- if yyl4863 == 0 {
- if yyv4863 == nil {
- yyv4863 = []ConfigMap{}
- yyc4863 = true
- } else if len(yyv4863) != 0 {
- yyv4863 = yyv4863[:0]
- yyc4863 = true
+ yyv4868 := *v
+ yyh4868, yyl4868 := z.DecSliceHelperStart()
+ var yyc4868 bool
+ if yyl4868 == 0 {
+ if yyv4868 == nil {
+ yyv4868 = []ConfigMap{}
+ yyc4868 = true
+ } else if len(yyv4868) != 0 {
+ yyv4868 = yyv4868[:0]
+ yyc4868 = true
}
- } else if yyl4863 > 0 {
- var yyrr4863, yyrl4863 int
- var yyrt4863 bool
- if yyl4863 > cap(yyv4863) {
+ } else if yyl4868 > 0 {
+ var yyrr4868, yyrl4868 int
+ var yyrt4868 bool
+ if yyl4868 > cap(yyv4868) {
- yyrg4863 := len(yyv4863) > 0
- yyv24863 := yyv4863
- yyrl4863, yyrt4863 = z.DecInferLen(yyl4863, z.DecBasicHandle().MaxInitLen, 264)
- if yyrt4863 {
- if yyrl4863 <= cap(yyv4863) {
- yyv4863 = yyv4863[:yyrl4863]
+ yyrg4868 := len(yyv4868) > 0
+ yyv24868 := yyv4868
+ yyrl4868, yyrt4868 = z.DecInferLen(yyl4868, z.DecBasicHandle().MaxInitLen, 264)
+ if yyrt4868 {
+ if yyrl4868 <= cap(yyv4868) {
+ yyv4868 = yyv4868[:yyrl4868]
} else {
- yyv4863 = make([]ConfigMap, yyrl4863)
+ yyv4868 = make([]ConfigMap, yyrl4868)
}
} else {
- yyv4863 = make([]ConfigMap, yyrl4863)
+ yyv4868 = make([]ConfigMap, yyrl4868)
}
- yyc4863 = true
- yyrr4863 = len(yyv4863)
- if yyrg4863 {
- copy(yyv4863, yyv24863)
+ yyc4868 = true
+ yyrr4868 = len(yyv4868)
+ if yyrg4868 {
+ copy(yyv4868, yyv24868)
}
- } else if yyl4863 != len(yyv4863) {
- yyv4863 = yyv4863[:yyl4863]
- yyc4863 = true
+ } else if yyl4868 != len(yyv4868) {
+ yyv4868 = yyv4868[:yyl4868]
+ yyc4868 = true
}
- yyj4863 := 0
- for ; yyj4863 < yyrr4863; yyj4863++ {
- yyh4863.ElemContainerState(yyj4863)
+ yyj4868 := 0
+ for ; yyj4868 < yyrr4868; yyj4868++ {
+ yyh4868.ElemContainerState(yyj4868)
if r.TryDecodeAsNil() {
- yyv4863[yyj4863] = ConfigMap{}
+ yyv4868[yyj4868] = ConfigMap{}
} else {
- yyv4864 := &yyv4863[yyj4863]
- yyv4864.CodecDecodeSelf(d)
+ yyv4869 := &yyv4868[yyj4868]
+ yyv4869.CodecDecodeSelf(d)
}
}
- if yyrt4863 {
- for ; yyj4863 < yyl4863; yyj4863++ {
- yyv4863 = append(yyv4863, ConfigMap{})
- yyh4863.ElemContainerState(yyj4863)
+ if yyrt4868 {
+ for ; yyj4868 < yyl4868; yyj4868++ {
+ yyv4868 = append(yyv4868, ConfigMap{})
+ yyh4868.ElemContainerState(yyj4868)
if r.TryDecodeAsNil() {
- yyv4863[yyj4863] = ConfigMap{}
+ yyv4868[yyj4868] = ConfigMap{}
} else {
- yyv4865 := &yyv4863[yyj4863]
- yyv4865.CodecDecodeSelf(d)
+ yyv4870 := &yyv4868[yyj4868]
+ yyv4870.CodecDecodeSelf(d)
}
}
}
} else {
- yyj4863 := 0
- for ; !r.CheckBreak(); yyj4863++ {
+ yyj4868 := 0
+ for ; !r.CheckBreak(); yyj4868++ {
- if yyj4863 >= len(yyv4863) {
- yyv4863 = append(yyv4863, ConfigMap{}) // var yyz4863 ConfigMap
- yyc4863 = true
+ if yyj4868 >= len(yyv4868) {
+ yyv4868 = append(yyv4868, ConfigMap{}) // var yyz4868 ConfigMap
+ yyc4868 = true
}
- yyh4863.ElemContainerState(yyj4863)
- if yyj4863 < len(yyv4863) {
+ yyh4868.ElemContainerState(yyj4868)
+ if yyj4868 < len(yyv4868) {
if r.TryDecodeAsNil() {
- yyv4863[yyj4863] = ConfigMap{}
+ yyv4868[yyj4868] = ConfigMap{}
} else {
- yyv4866 := &yyv4863[yyj4863]
- yyv4866.CodecDecodeSelf(d)
+ yyv4871 := &yyv4868[yyj4868]
+ yyv4871.CodecDecodeSelf(d)
}
} else {
@@ -62703,17 +62767,17 @@ func (x codecSelfer1234) decSliceConfigMap(v *[]ConfigMap, d *codec1978.Decoder)
}
}
- if yyj4863 < len(yyv4863) {
- yyv4863 = yyv4863[:yyj4863]
- yyc4863 = true
- } else if yyj4863 == 0 && yyv4863 == nil {
- yyv4863 = []ConfigMap{}
- yyc4863 = true
+ if yyj4868 < len(yyv4868) {
+ yyv4868 = yyv4868[:yyj4868]
+ yyc4868 = true
+ } else if yyj4868 == 0 && yyv4868 == nil {
+ yyv4868 = []ConfigMap{}
+ yyc4868 = true
}
}
- yyh4863.End()
- if yyc4863 {
- *v = yyv4863
+ yyh4868.End()
+ if yyc4868 {
+ *v = yyv4868
}
}
@@ -62722,10 +62786,10 @@ func (x codecSelfer1234) encSliceComponentCondition(v []ComponentCondition, e *c
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
r.EncodeArrayStart(len(v))
- for _, yyv4867 := range v {
+ for _, yyv4872 := range v {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy4868 := &yyv4867
- yy4868.CodecEncodeSelf(e)
+ yy4873 := &yyv4872
+ yy4873.CodecEncodeSelf(e)
}
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -62735,83 +62799,83 @@ func (x codecSelfer1234) decSliceComponentCondition(v *[]ComponentCondition, d *
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yyv4869 := *v
- yyh4869, yyl4869 := z.DecSliceHelperStart()
- var yyc4869 bool
- if yyl4869 == 0 {
- if yyv4869 == nil {
- yyv4869 = []ComponentCondition{}
- yyc4869 = true
- } else if len(yyv4869) != 0 {
- yyv4869 = yyv4869[:0]
- yyc4869 = true
+ yyv4874 := *v
+ yyh4874, yyl4874 := z.DecSliceHelperStart()
+ var yyc4874 bool
+ if yyl4874 == 0 {
+ if yyv4874 == nil {
+ yyv4874 = []ComponentCondition{}
+ yyc4874 = true
+ } else if len(yyv4874) != 0 {
+ yyv4874 = yyv4874[:0]
+ yyc4874 = true
}
- } else if yyl4869 > 0 {
- var yyrr4869, yyrl4869 int
- var yyrt4869 bool
- if yyl4869 > cap(yyv4869) {
+ } else if yyl4874 > 0 {
+ var yyrr4874, yyrl4874 int
+ var yyrt4874 bool
+ if yyl4874 > cap(yyv4874) {
- yyrg4869 := len(yyv4869) > 0
- yyv24869 := yyv4869
- yyrl4869, yyrt4869 = z.DecInferLen(yyl4869, z.DecBasicHandle().MaxInitLen, 64)
- if yyrt4869 {
- if yyrl4869 <= cap(yyv4869) {
- yyv4869 = yyv4869[:yyrl4869]
+ yyrg4874 := len(yyv4874) > 0
+ yyv24874 := yyv4874
+ yyrl4874, yyrt4874 = z.DecInferLen(yyl4874, z.DecBasicHandle().MaxInitLen, 64)
+ if yyrt4874 {
+ if yyrl4874 <= cap(yyv4874) {
+ yyv4874 = yyv4874[:yyrl4874]
} else {
- yyv4869 = make([]ComponentCondition, yyrl4869)
+ yyv4874 = make([]ComponentCondition, yyrl4874)
}
} else {
- yyv4869 = make([]ComponentCondition, yyrl4869)
+ yyv4874 = make([]ComponentCondition, yyrl4874)
}
- yyc4869 = true
- yyrr4869 = len(yyv4869)
- if yyrg4869 {
- copy(yyv4869, yyv24869)
+ yyc4874 = true
+ yyrr4874 = len(yyv4874)
+ if yyrg4874 {
+ copy(yyv4874, yyv24874)
}
- } else if yyl4869 != len(yyv4869) {
- yyv4869 = yyv4869[:yyl4869]
- yyc4869 = true
+ } else if yyl4874 != len(yyv4874) {
+ yyv4874 = yyv4874[:yyl4874]
+ yyc4874 = true
}
- yyj4869 := 0
- for ; yyj4869 < yyrr4869; yyj4869++ {
- yyh4869.ElemContainerState(yyj4869)
+ yyj4874 := 0
+ for ; yyj4874 < yyrr4874; yyj4874++ {
+ yyh4874.ElemContainerState(yyj4874)
if r.TryDecodeAsNil() {
- yyv4869[yyj4869] = ComponentCondition{}
+ yyv4874[yyj4874] = ComponentCondition{}
} else {
- yyv4870 := &yyv4869[yyj4869]
- yyv4870.CodecDecodeSelf(d)
+ yyv4875 := &yyv4874[yyj4874]
+ yyv4875.CodecDecodeSelf(d)
}
}
- if yyrt4869 {
- for ; yyj4869 < yyl4869; yyj4869++ {
- yyv4869 = append(yyv4869, ComponentCondition{})
- yyh4869.ElemContainerState(yyj4869)
+ if yyrt4874 {
+ for ; yyj4874 < yyl4874; yyj4874++ {
+ yyv4874 = append(yyv4874, ComponentCondition{})
+ yyh4874.ElemContainerState(yyj4874)
if r.TryDecodeAsNil() {
- yyv4869[yyj4869] = ComponentCondition{}
+ yyv4874[yyj4874] = ComponentCondition{}
} else {
- yyv4871 := &yyv4869[yyj4869]
- yyv4871.CodecDecodeSelf(d)
+ yyv4876 := &yyv4874[yyj4874]
+ yyv4876.CodecDecodeSelf(d)
}
}
}
} else {
- yyj4869 := 0
- for ; !r.CheckBreak(); yyj4869++ {
+ yyj4874 := 0
+ for ; !r.CheckBreak(); yyj4874++ {
- if yyj4869 >= len(yyv4869) {
- yyv4869 = append(yyv4869, ComponentCondition{}) // var yyz4869 ComponentCondition
- yyc4869 = true
+ if yyj4874 >= len(yyv4874) {
+ yyv4874 = append(yyv4874, ComponentCondition{}) // var yyz4874 ComponentCondition
+ yyc4874 = true
}
- yyh4869.ElemContainerState(yyj4869)
- if yyj4869 < len(yyv4869) {
+ yyh4874.ElemContainerState(yyj4874)
+ if yyj4874 < len(yyv4874) {
if r.TryDecodeAsNil() {
- yyv4869[yyj4869] = ComponentCondition{}
+ yyv4874[yyj4874] = ComponentCondition{}
} else {
- yyv4872 := &yyv4869[yyj4869]
- yyv4872.CodecDecodeSelf(d)
+ yyv4877 := &yyv4874[yyj4874]
+ yyv4877.CodecDecodeSelf(d)
}
} else {
@@ -62819,17 +62883,17 @@ func (x codecSelfer1234) decSliceComponentCondition(v *[]ComponentCondition, d *
}
}
- if yyj4869 < len(yyv4869) {
- yyv4869 = yyv4869[:yyj4869]
- yyc4869 = true
- } else if yyj4869 == 0 && yyv4869 == nil {
- yyv4869 = []ComponentCondition{}
- yyc4869 = true
+ if yyj4874 < len(yyv4874) {
+ yyv4874 = yyv4874[:yyj4874]
+ yyc4874 = true
+ } else if yyj4874 == 0 && yyv4874 == nil {
+ yyv4874 = []ComponentCondition{}
+ yyc4874 = true
}
}
- yyh4869.End()
- if yyc4869 {
- *v = yyv4869
+ yyh4874.End()
+ if yyc4874 {
+ *v = yyv4874
}
}
@@ -62838,10 +62902,10 @@ func (x codecSelfer1234) encSliceComponentStatus(v []ComponentStatus, e *codec19
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
r.EncodeArrayStart(len(v))
- for _, yyv4873 := range v {
+ for _, yyv4878 := range v {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy4874 := &yyv4873
- yy4874.CodecEncodeSelf(e)
+ yy4879 := &yyv4878
+ yy4879.CodecEncodeSelf(e)
}
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -62851,83 +62915,83 @@ func (x codecSelfer1234) decSliceComponentStatus(v *[]ComponentStatus, d *codec1
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yyv4875 := *v
- yyh4875, yyl4875 := z.DecSliceHelperStart()
- var yyc4875 bool
- if yyl4875 == 0 {
- if yyv4875 == nil {
- yyv4875 = []ComponentStatus{}
- yyc4875 = true
- } else if len(yyv4875) != 0 {
- yyv4875 = yyv4875[:0]
- yyc4875 = true
+ yyv4880 := *v
+ yyh4880, yyl4880 := z.DecSliceHelperStart()
+ var yyc4880 bool
+ if yyl4880 == 0 {
+ if yyv4880 == nil {
+ yyv4880 = []ComponentStatus{}
+ yyc4880 = true
+ } else if len(yyv4880) != 0 {
+ yyv4880 = yyv4880[:0]
+ yyc4880 = true
}
- } else if yyl4875 > 0 {
- var yyrr4875, yyrl4875 int
- var yyrt4875 bool
- if yyl4875 > cap(yyv4875) {
+ } else if yyl4880 > 0 {
+ var yyrr4880, yyrl4880 int
+ var yyrt4880 bool
+ if yyl4880 > cap(yyv4880) {
- yyrg4875 := len(yyv4875) > 0
- yyv24875 := yyv4875
- yyrl4875, yyrt4875 = z.DecInferLen(yyl4875, z.DecBasicHandle().MaxInitLen, 280)
- if yyrt4875 {
- if yyrl4875 <= cap(yyv4875) {
- yyv4875 = yyv4875[:yyrl4875]
+ yyrg4880 := len(yyv4880) > 0
+ yyv24880 := yyv4880
+ yyrl4880, yyrt4880 = z.DecInferLen(yyl4880, z.DecBasicHandle().MaxInitLen, 280)
+ if yyrt4880 {
+ if yyrl4880 <= cap(yyv4880) {
+ yyv4880 = yyv4880[:yyrl4880]
} else {
- yyv4875 = make([]ComponentStatus, yyrl4875)
+ yyv4880 = make([]ComponentStatus, yyrl4880)
}
} else {
- yyv4875 = make([]ComponentStatus, yyrl4875)
+ yyv4880 = make([]ComponentStatus, yyrl4880)
}
- yyc4875 = true
- yyrr4875 = len(yyv4875)
- if yyrg4875 {
- copy(yyv4875, yyv24875)
+ yyc4880 = true
+ yyrr4880 = len(yyv4880)
+ if yyrg4880 {
+ copy(yyv4880, yyv24880)
}
- } else if yyl4875 != len(yyv4875) {
- yyv4875 = yyv4875[:yyl4875]
- yyc4875 = true
+ } else if yyl4880 != len(yyv4880) {
+ yyv4880 = yyv4880[:yyl4880]
+ yyc4880 = true
}
- yyj4875 := 0
- for ; yyj4875 < yyrr4875; yyj4875++ {
- yyh4875.ElemContainerState(yyj4875)
+ yyj4880 := 0
+ for ; yyj4880 < yyrr4880; yyj4880++ {
+ yyh4880.ElemContainerState(yyj4880)
if r.TryDecodeAsNil() {
- yyv4875[yyj4875] = ComponentStatus{}
+ yyv4880[yyj4880] = ComponentStatus{}
} else {
- yyv4876 := &yyv4875[yyj4875]
- yyv4876.CodecDecodeSelf(d)
+ yyv4881 := &yyv4880[yyj4880]
+ yyv4881.CodecDecodeSelf(d)
}
}
- if yyrt4875 {
- for ; yyj4875 < yyl4875; yyj4875++ {
- yyv4875 = append(yyv4875, ComponentStatus{})
- yyh4875.ElemContainerState(yyj4875)
+ if yyrt4880 {
+ for ; yyj4880 < yyl4880; yyj4880++ {
+ yyv4880 = append(yyv4880, ComponentStatus{})
+ yyh4880.ElemContainerState(yyj4880)
if r.TryDecodeAsNil() {
- yyv4875[yyj4875] = ComponentStatus{}
+ yyv4880[yyj4880] = ComponentStatus{}
} else {
- yyv4877 := &yyv4875[yyj4875]
- yyv4877.CodecDecodeSelf(d)
+ yyv4882 := &yyv4880[yyj4880]
+ yyv4882.CodecDecodeSelf(d)
}
}
}
} else {
- yyj4875 := 0
- for ; !r.CheckBreak(); yyj4875++ {
+ yyj4880 := 0
+ for ; !r.CheckBreak(); yyj4880++ {
- if yyj4875 >= len(yyv4875) {
- yyv4875 = append(yyv4875, ComponentStatus{}) // var yyz4875 ComponentStatus
- yyc4875 = true
+ if yyj4880 >= len(yyv4880) {
+ yyv4880 = append(yyv4880, ComponentStatus{}) // var yyz4880 ComponentStatus
+ yyc4880 = true
}
- yyh4875.ElemContainerState(yyj4875)
- if yyj4875 < len(yyv4875) {
+ yyh4880.ElemContainerState(yyj4880)
+ if yyj4880 < len(yyv4880) {
if r.TryDecodeAsNil() {
- yyv4875[yyj4875] = ComponentStatus{}
+ yyv4880[yyj4880] = ComponentStatus{}
} else {
- yyv4878 := &yyv4875[yyj4875]
- yyv4878.CodecDecodeSelf(d)
+ yyv4883 := &yyv4880[yyj4880]
+ yyv4883.CodecDecodeSelf(d)
}
} else {
@@ -62935,17 +62999,17 @@ func (x codecSelfer1234) decSliceComponentStatus(v *[]ComponentStatus, d *codec1
}
}
- if yyj4875 < len(yyv4875) {
- yyv4875 = yyv4875[:yyj4875]
- yyc4875 = true
- } else if yyj4875 == 0 && yyv4875 == nil {
- yyv4875 = []ComponentStatus{}
- yyc4875 = true
+ if yyj4880 < len(yyv4880) {
+ yyv4880 = yyv4880[:yyj4880]
+ yyc4880 = true
+ } else if yyj4880 == 0 && yyv4880 == nil {
+ yyv4880 = []ComponentStatus{}
+ yyc4880 = true
}
}
- yyh4875.End()
- if yyc4875 {
- *v = yyv4875
+ yyh4880.End()
+ if yyc4880 {
+ *v = yyv4880
}
}
@@ -62954,10 +63018,10 @@ func (x codecSelfer1234) encSliceDownwardAPIVolumeFile(v []DownwardAPIVolumeFile
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
r.EncodeArrayStart(len(v))
- for _, yyv4879 := range v {
+ for _, yyv4884 := range v {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
- yy4880 := &yyv4879
- yy4880.CodecEncodeSelf(e)
+ yy4885 := &yyv4884
+ yy4885.CodecEncodeSelf(e)
}
z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
}
@@ -62967,83 +63031,83 @@ func (x codecSelfer1234) decSliceDownwardAPIVolumeFile(v *[]DownwardAPIVolumeFil
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
- yyv4881 := *v
- yyh4881, yyl4881 := z.DecSliceHelperStart()
- var yyc4881 bool
- if yyl4881 == 0 {
- if yyv4881 == nil {
- yyv4881 = []DownwardAPIVolumeFile{}
- yyc4881 = true
- } else if len(yyv4881) != 0 {
- yyv4881 = yyv4881[:0]
- yyc4881 = true
+ yyv4886 := *v
+ yyh4886, yyl4886 := z.DecSliceHelperStart()
+ var yyc4886 bool
+ if yyl4886 == 0 {
+ if yyv4886 == nil {
+ yyv4886 = []DownwardAPIVolumeFile{}
+ yyc4886 = true
+ } else if len(yyv4886) != 0 {
+ yyv4886 = yyv4886[:0]
+ yyc4886 = true
}
- } else if yyl4881 > 0 {
- var yyrr4881, yyrl4881 int
- var yyrt4881 bool
- if yyl4881 > cap(yyv4881) {
+ } else if yyl4886 > 0 {
+ var yyrr4886, yyrl4886 int
+ var yyrt4886 bool
+ if yyl4886 > cap(yyv4886) {
- yyrg4881 := len(yyv4881) > 0
- yyv24881 := yyv4881
- yyrl4881, yyrt4881 = z.DecInferLen(yyl4881, z.DecBasicHandle().MaxInitLen, 40)
- if yyrt4881 {
- if yyrl4881 <= cap(yyv4881) {
- yyv4881 = yyv4881[:yyrl4881]
+ yyrg4886 := len(yyv4886) > 0
+ yyv24886 := yyv4886
+ yyrl4886, yyrt4886 = z.DecInferLen(yyl4886, z.DecBasicHandle().MaxInitLen, 40)
+ if yyrt4886 {
+ if yyrl4886 <= cap(yyv4886) {
+ yyv4886 = yyv4886[:yyrl4886]
} else {
- yyv4881 = make([]DownwardAPIVolumeFile, yyrl4881)
+ yyv4886 = make([]DownwardAPIVolumeFile, yyrl4886)
}
} else {
- yyv4881 = make([]DownwardAPIVolumeFile, yyrl4881)
+ yyv4886 = make([]DownwardAPIVolumeFile, yyrl4886)
}
- yyc4881 = true
- yyrr4881 = len(yyv4881)
- if yyrg4881 {
- copy(yyv4881, yyv24881)
+ yyc4886 = true
+ yyrr4886 = len(yyv4886)
+ if yyrg4886 {
+ copy(yyv4886, yyv24886)
}
- } else if yyl4881 != len(yyv4881) {
- yyv4881 = yyv4881[:yyl4881]
- yyc4881 = true
+ } else if yyl4886 != len(yyv4886) {
+ yyv4886 = yyv4886[:yyl4886]
+ yyc4886 = true
}
- yyj4881 := 0
- for ; yyj4881 < yyrr4881; yyj4881++ {
- yyh4881.ElemContainerState(yyj4881)
+ yyj4886 := 0
+ for ; yyj4886 < yyrr4886; yyj4886++ {
+ yyh4886.ElemContainerState(yyj4886)
if r.TryDecodeAsNil() {
- yyv4881[yyj4881] = DownwardAPIVolumeFile{}
+ yyv4886[yyj4886] = DownwardAPIVolumeFile{}
} else {
- yyv4882 := &yyv4881[yyj4881]
- yyv4882.CodecDecodeSelf(d)
+ yyv4887 := &yyv4886[yyj4886]
+ yyv4887.CodecDecodeSelf(d)
}
}
- if yyrt4881 {
- for ; yyj4881 < yyl4881; yyj4881++ {
- yyv4881 = append(yyv4881, DownwardAPIVolumeFile{})
- yyh4881.ElemContainerState(yyj4881)
+ if yyrt4886 {
+ for ; yyj4886 < yyl4886; yyj4886++ {
+ yyv4886 = append(yyv4886, DownwardAPIVolumeFile{})
+ yyh4886.ElemContainerState(yyj4886)
if r.TryDecodeAsNil() {
- yyv4881[yyj4881] = DownwardAPIVolumeFile{}
+ yyv4886[yyj4886] = DownwardAPIVolumeFile{}
} else {
- yyv4883 := &yyv4881[yyj4881]
- yyv4883.CodecDecodeSelf(d)
+ yyv4888 := &yyv4886[yyj4886]
+ yyv4888.CodecDecodeSelf(d)
}
}
}
} else {
- yyj4881 := 0
- for ; !r.CheckBreak(); yyj4881++ {
+ yyj4886 := 0
+ for ; !r.CheckBreak(); yyj4886++ {
- if yyj4881 >= len(yyv4881) {
- yyv4881 = append(yyv4881, DownwardAPIVolumeFile{}) // var yyz4881 DownwardAPIVolumeFile
- yyc4881 = true
+ if yyj4886 >= len(yyv4886) {
+ yyv4886 = append(yyv4886, DownwardAPIVolumeFile{}) // var yyz4886 DownwardAPIVolumeFile
+ yyc4886 = true
}
- yyh4881.ElemContainerState(yyj4881)
- if yyj4881 < len(yyv4881) {
+ yyh4886.ElemContainerState(yyj4886)
+ if yyj4886 < len(yyv4886) {
if r.TryDecodeAsNil() {
- yyv4881[yyj4881] = DownwardAPIVolumeFile{}
+ yyv4886[yyj4886] = DownwardAPIVolumeFile{}
} else {
- yyv4884 := &yyv4881[yyj4881]
- yyv4884.CodecDecodeSelf(d)
+ yyv4889 := &yyv4886[yyj4886]
+ yyv4889.CodecDecodeSelf(d)
}
} else {
@@ -63051,16 +63115,16 @@ func (x codecSelfer1234) decSliceDownwardAPIVolumeFile(v *[]DownwardAPIVolumeFil
}
}
- if yyj4881 < len(yyv4881) {
- yyv4881 = yyv4881[:yyj4881]
- yyc4881 = true
- } else if yyj4881 == 0 && yyv4881 == nil {
- yyv4881 = []DownwardAPIVolumeFile{}
- yyc4881 = true
+ if yyj4886 < len(yyv4886) {
+ yyv4886 = yyv4886[:yyj4886]
+ yyc4886 = true
+ } else if yyj4886 == 0 && yyv4886 == nil {
+ yyv4886 = []DownwardAPIVolumeFile{}
+ yyc4886 = true
}
}
- yyh4881.End()
- if yyc4881 {
- *v = yyv4881
+ yyh4886.End()
+ if yyc4886 {
+ *v = yyv4886
}
}
diff --git a/pkg/api/v1/types.go b/pkg/api/v1/types.go
index 4a2f85979c5..d84c4b100f7 100644
--- a/pkg/api/v1/types.go
+++ b/pkg/api/v1/types.go
@@ -2153,6 +2153,18 @@ type PodSecurityContext struct {
FSGroup *int64 `json:"fsGroup,omitempty" protobuf:"varint,5,opt,name=fsGroup"`
}
+// PodQOSClass defines the supported qos classes of Pods.
+type PodQOSClass string
+
+const (
+ // PodQOSGuaranteed is the Guaranteed qos class.
+ PodQOSGuaranteed PodQOSClass = "Guaranteed"
+ // PodQOSBurstable is the Burstable qos class.
+ PodQOSBurstable PodQOSClass = "Burstable"
+ // PodQOSBestEffort is the BestEffort qos class.
+ PodQOSBestEffort PodQOSClass = "BestEffort"
+)
+
// PodStatus represents information about the status of a pod. Status may trail the actual
// state of a system.
type PodStatus struct {
@@ -2196,6 +2208,11 @@ type PodStatus struct {
// More info: http://kubernetes.io/docs/user-guide/pod-states#container-statuses
// +optional
ContainerStatuses []ContainerStatus `json:"containerStatuses,omitempty" protobuf:"bytes,8,rep,name=containerStatuses"`
+ // The Quality of Service (QOS) classification assigned to the pod based on resource requirements
+ // See PodQOSClass type for available QOS classes
+ // More info: https://github.com/kubernetes/kubernetes/blob/master/docs/design/resource-qos.md
+ // +optional
+ QOSClass PodQOSClass `json:"qosClass,omitempty" protobuf:"bytes,9,rep,name=qosClass"`
}
// PodStatusResult is a wrapper for PodStatus returned by kubelet that can be encode/decoded
diff --git a/pkg/api/v1/types_swagger_doc_generated.go b/pkg/api/v1/types_swagger_doc_generated.go
index 58c374a4551..27f073743b8 100644
--- a/pkg/api/v1/types_swagger_doc_generated.go
+++ b/pkg/api/v1/types_swagger_doc_generated.go
@@ -1290,6 +1290,7 @@ var map_PodStatus = map[string]string{
"podIP": "IP address allocated to the pod. Routable at least within the cluster. Empty if not yet allocated.",
"startTime": "RFC 3339 date and time at which the object was acknowledged by the Kubelet. This is before the Kubelet pulled the container image(s) for the pod.",
"containerStatuses": "The list has one entry per container in the manifest. Each entry is currently the output of `docker inspect`. More info: http://kubernetes.io/docs/user-guide/pod-states#container-statuses",
+ "qosClass": "The Quality of Service (QOS) classification assigned to the pod based on resource requirements See PodQOSClass type for available QOS classes More info: https://github.com/kubernetes/kubernetes/blob/master/docs/design/resource-qos.md",
}
func (PodStatus) SwaggerDoc() map[string]string {
diff --git a/pkg/api/v1/zz_generated.conversion.go b/pkg/api/v1/zz_generated.conversion.go
index 4e0cccc5dcd..c4013b6da4f 100644
--- a/pkg/api/v1/zz_generated.conversion.go
+++ b/pkg/api/v1/zz_generated.conversion.go
@@ -3113,6 +3113,7 @@ func autoConvert_v1_PodStatus_To_api_PodStatus(in *PodStatus, out *api.PodStatus
out.StartTime = (*meta_v1.Time)(unsafe.Pointer(in.StartTime))
out.InitContainerStatuses = *(*[]api.ContainerStatus)(unsafe.Pointer(&in.InitContainerStatuses))
out.ContainerStatuses = *(*[]api.ContainerStatus)(unsafe.Pointer(&in.ContainerStatuses))
+ out.QOSClass = api.PodQOSClass(in.QOSClass)
return nil
}
@@ -3128,6 +3129,7 @@ func autoConvert_api_PodStatus_To_v1_PodStatus(in *api.PodStatus, out *PodStatus
out.HostIP = in.HostIP
out.PodIP = in.PodIP
out.StartTime = (*meta_v1.Time)(unsafe.Pointer(in.StartTime))
+ out.QOSClass = PodQOSClass(in.QOSClass)
out.InitContainerStatuses = *(*[]ContainerStatus)(unsafe.Pointer(&in.InitContainerStatuses))
out.ContainerStatuses = *(*[]ContainerStatus)(unsafe.Pointer(&in.ContainerStatuses))
return nil
diff --git a/pkg/api/v1/zz_generated.deepcopy.go b/pkg/api/v1/zz_generated.deepcopy.go
index 559f6058743..e370dff1562 100644
--- a/pkg/api/v1/zz_generated.deepcopy.go
+++ b/pkg/api/v1/zz_generated.deepcopy.go
@@ -2713,6 +2713,7 @@ func DeepCopy_v1_PodStatus(in interface{}, out interface{}, c *conversion.Cloner
} else {
out.ContainerStatuses = nil
}
+ out.QOSClass = in.QOSClass
return nil
}
}
diff --git a/pkg/api/zz_generated.deepcopy.go b/pkg/api/zz_generated.deepcopy.go
index dad1bb152f4..dfbbbf2bf51 100644
--- a/pkg/api/zz_generated.deepcopy.go
+++ b/pkg/api/zz_generated.deepcopy.go
@@ -2730,6 +2730,7 @@ func DeepCopy_api_PodStatus(in interface{}, out interface{}, c *conversion.Clone
} else {
out.StartTime = nil
}
+ out.QOSClass = in.QOSClass
if in.InitContainerStatuses != nil {
in, out := &in.InitContainerStatuses, &out.InitContainerStatuses
*out = make([]ContainerStatus, len(*in))
diff --git a/pkg/generated/openapi/zz_generated.openapi.go b/pkg/generated/openapi/zz_generated.openapi.go
index 82d1bf12b59..37f07781f6a 100644
--- a/pkg/generated/openapi/zz_generated.openapi.go
+++ b/pkg/generated/openapi/zz_generated.openapi.go
@@ -5452,6 +5452,13 @@ var OpenAPIDefinitions *common.OpenAPIDefinitions = &common.OpenAPIDefinitions{
},
},
},
+ "qosClass": {
+ SchemaProps: spec.SchemaProps{
+ Description: "The Quality of Service (QOS) classification assigned to the pod based on resource requirements See PodQOSClass type for available QOS classes More info: https://github.com/kubernetes/kubernetes/blob/master/docs/design/resource-qos.md",
+ Type: []string{"string"},
+ Format: "",
+ },
+ },
},
},
},