▽

Source file src/k8s.io/api/extensions/v1beta1/generated.pb.go

Documentation: k8s.io/api/extensions/v1beta1

     1  /*
     2  Copyright The Kubernetes Authors.
     3  
     4  Licensed under the Apache License, Version 2.0 (the "License");
     5  you may not use this file except in compliance with the License.
     6  You may obtain a copy of the License at
     7  
     8      http://www.apache.org/licenses/LICENSE-2.0
     9  
    10  Unless required by applicable law or agreed to in writing, software
    11  distributed under the License is distributed on an "AS IS" BASIS,
    12  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13  See the License for the specific language governing permissions and
    14  limitations under the License.
    15  */
    16  
    17  // Code generated by protoc-gen-gogo. DO NOT EDIT.
    18  // source: k8s.io/api/extensions/v1beta1/generated.proto
    19  
    20  package v1beta1
    21  
    22  import (
    23  	fmt "fmt"
    24  
    25  	io "io"
    26  
    27  	proto "github.com/gogo/protobuf/proto"
    28  	github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
    29  	k8s_io_api_core_v1 "k8s.io/api/core/v1"
    30  	v11 "k8s.io/api/core/v1"
    31  	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    32  
    33  	math "math"
    34  	math_bits "math/bits"
    35  	reflect "reflect"
    36  	strings "strings"
    37  
    38  	intstr "k8s.io/apimachinery/pkg/util/intstr"
    39  )
    40  
    41  // Reference imports to suppress errors if they are not otherwise used.
    42  var _ = proto.Marshal
    43  var _ = fmt.Errorf
    44  var _ = math.Inf
    45  
    46  // This is a compile-time assertion to ensure that this generated file
    47  // is compatible with the proto package it is being compiled against.
    48  // A compilation error at this line likely means your copy of the
    49  // proto package needs to be updated.
    50  const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
    51  
    52  func (m *DaemonSet) Reset()      { *m = DaemonSet{} }
    53  func (*DaemonSet) ProtoMessage() {}
    54  func (*DaemonSet) Descriptor() ([]byte, []int) {
    55  	return fileDescriptor_90a532284de28347, []int{0}
    56  }
    57  func (m *DaemonSet) XXX_Unmarshal(b []byte) error {
    58  	return m.Unmarshal(b)
    59  }
    60  func (m *DaemonSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    61  	b = b[:cap(b)]
    62  	n, err := m.MarshalToSizedBuffer(b)
    63  	if err != nil {
    64  		return nil, err
    65  	}
    66  	return b[:n], nil
    67  }
    68  func (m *DaemonSet) XXX_Merge(src proto.Message) {
    69  	xxx_messageInfo_DaemonSet.Merge(m, src)
    70  }
    71  func (m *DaemonSet) XXX_Size() int {
    72  	return m.Size()
    73  }
    74  func (m *DaemonSet) XXX_DiscardUnknown() {
    75  	xxx_messageInfo_DaemonSet.DiscardUnknown(m)
    76  }
    77  
    78  var xxx_messageInfo_DaemonSet proto.InternalMessageInfo
    79  
    80  func (m *DaemonSetCondition) Reset()      { *m = DaemonSetCondition{} }
    81  func (*DaemonSetCondition) ProtoMessage() {}
    82  func (*DaemonSetCondition) Descriptor() ([]byte, []int) {
    83  	return fileDescriptor_90a532284de28347, []int{1}
    84  }
    85  func (m *DaemonSetCondition) XXX_Unmarshal(b []byte) error {
    86  	return m.Unmarshal(b)
    87  }
    88  func (m *DaemonSetCondition) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    89  	b = b[:cap(b)]
    90  	n, err := m.MarshalToSizedBuffer(b)
    91  	if err != nil {
    92  		return nil, err
    93  	}
    94  	return b[:n], nil
    95  }
    96  func (m *DaemonSetCondition) XXX_Merge(src proto.Message) {
    97  	xxx_messageInfo_DaemonSetCondition.Merge(m, src)
    98  }
    99  func (m *DaemonSetCondition) XXX_Size() int {
   100  	return m.Size()
   101  }
   102  func (m *DaemonSetCondition) XXX_DiscardUnknown() {
   103  	xxx_messageInfo_DaemonSetCondition.DiscardUnknown(m)
   104  }
   105  
   106  var xxx_messageInfo_DaemonSetCondition proto.InternalMessageInfo
   107  
   108  func (m *DaemonSetList) Reset()      { *m = DaemonSetList{} }
   109  func (*DaemonSetList) ProtoMessage() {}
   110  func (*DaemonSetList) Descriptor() ([]byte, []int) {
   111  	return fileDescriptor_90a532284de28347, []int{2}
   112  }
   113  func (m *DaemonSetList) XXX_Unmarshal(b []byte) error {
   114  	return m.Unmarshal(b)
   115  }
   116  func (m *DaemonSetList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   117  	b = b[:cap(b)]
   118  	n, err := m.MarshalToSizedBuffer(b)
   119  	if err != nil {
   120  		return nil, err
   121  	}
   122  	return b[:n], nil
   123  }
   124  func (m *DaemonSetList) XXX_Merge(src proto.Message) {
   125  	xxx_messageInfo_DaemonSetList.Merge(m, src)
   126  }
   127  func (m *DaemonSetList) XXX_Size() int {
   128  	return m.Size()
   129  }
   130  func (m *DaemonSetList) XXX_DiscardUnknown() {
   131  	xxx_messageInfo_DaemonSetList.DiscardUnknown(m)
   132  }
   133  
   134  var xxx_messageInfo_DaemonSetList proto.InternalMessageInfo
   135  
   136  func (m *DaemonSetSpec) Reset()      { *m = DaemonSetSpec{} }
   137  func (*DaemonSetSpec) ProtoMessage() {}
   138  func (*DaemonSetSpec) Descriptor() ([]byte, []int) {
   139  	return fileDescriptor_90a532284de28347, []int{3}
   140  }
   141  func (m *DaemonSetSpec) XXX_Unmarshal(b []byte) error {
   142  	return m.Unmarshal(b)
   143  }
   144  func (m *DaemonSetSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   145  	b = b[:cap(b)]
   146  	n, err := m.MarshalToSizedBuffer(b)
   147  	if err != nil {
   148  		return nil, err
   149  	}
   150  	return b[:n], nil
   151  }
   152  func (m *DaemonSetSpec) XXX_Merge(src proto.Message) {
   153  	xxx_messageInfo_DaemonSetSpec.Merge(m, src)
   154  }
   155  func (m *DaemonSetSpec) XXX_Size() int {
   156  	return m.Size()
   157  }
   158  func (m *DaemonSetSpec) XXX_DiscardUnknown() {
   159  	xxx_messageInfo_DaemonSetSpec.DiscardUnknown(m)
   160  }
   161  
   162  var xxx_messageInfo_DaemonSetSpec proto.InternalMessageInfo
   163  
   164  func (m *DaemonSetStatus) Reset()      { *m = DaemonSetStatus{} }
   165  func (*DaemonSetStatus) ProtoMessage() {}
   166  func (*DaemonSetStatus) Descriptor() ([]byte, []int) {
   167  	return fileDescriptor_90a532284de28347, []int{4}
   168  }
   169  func (m *DaemonSetStatus) XXX_Unmarshal(b []byte) error {
   170  	return m.Unmarshal(b)
   171  }
   172  func (m *DaemonSetStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   173  	b = b[:cap(b)]
   174  	n, err := m.MarshalToSizedBuffer(b)
   175  	if err != nil {
   176  		return nil, err
   177  	}
   178  	return b[:n], nil
   179  }
   180  func (m *DaemonSetStatus) XXX_Merge(src proto.Message) {
   181  	xxx_messageInfo_DaemonSetStatus.Merge(m, src)
   182  }
   183  func (m *DaemonSetStatus) XXX_Size() int {
   184  	return m.Size()
   185  }
   186  func (m *DaemonSetStatus) XXX_DiscardUnknown() {
   187  	xxx_messageInfo_DaemonSetStatus.DiscardUnknown(m)
   188  }
   189  
   190  var xxx_messageInfo_DaemonSetStatus proto.InternalMessageInfo
   191  
   192  func (m *DaemonSetUpdateStrategy) Reset()      { *m = DaemonSetUpdateStrategy{} }
   193  func (*DaemonSetUpdateStrategy) ProtoMessage() {}
   194  func (*DaemonSetUpdateStrategy) Descriptor() ([]byte, []int) {
   195  	return fileDescriptor_90a532284de28347, []int{5}
   196  }
   197  func (m *DaemonSetUpdateStrategy) XXX_Unmarshal(b []byte) error {
   198  	return m.Unmarshal(b)
   199  }
   200  func (m *DaemonSetUpdateStrategy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   201  	b = b[:cap(b)]
   202  	n, err := m.MarshalToSizedBuffer(b)
   203  	if err != nil {
   204  		return nil, err
   205  	}
   206  	return b[:n], nil
   207  }
   208  func (m *DaemonSetUpdateStrategy) XXX_Merge(src proto.Message) {
   209  	xxx_messageInfo_DaemonSetUpdateStrategy.Merge(m, src)
   210  }
   211  func (m *DaemonSetUpdateStrategy) XXX_Size() int {
   212  	return m.Size()
   213  }
   214  func (m *DaemonSetUpdateStrategy) XXX_DiscardUnknown() {
   215  	xxx_messageInfo_DaemonSetUpdateStrategy.DiscardUnknown(m)
   216  }
   217  
   218  var xxx_messageInfo_DaemonSetUpdateStrategy proto.InternalMessageInfo
   219  
   220  func (m *Deployment) Reset()      { *m = Deployment{} }
   221  func (*Deployment) ProtoMessage() {}
   222  func (*Deployment) Descriptor() ([]byte, []int) {
   223  	return fileDescriptor_90a532284de28347, []int{6}
   224  }
   225  func (m *Deployment) XXX_Unmarshal(b []byte) error {
   226  	return m.Unmarshal(b)
   227  }
   228  func (m *Deployment) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   229  	b = b[:cap(b)]
   230  	n, err := m.MarshalToSizedBuffer(b)
   231  	if err != nil {
   232  		return nil, err
   233  	}
   234  	return b[:n], nil
   235  }
   236  func (m *Deployment) XXX_Merge(src proto.Message) {
   237  	xxx_messageInfo_Deployment.Merge(m, src)
   238  }
   239  func (m *Deployment) XXX_Size() int {
   240  	return m.Size()
   241  }
   242  func (m *Deployment) XXX_DiscardUnknown() {
   243  	xxx_messageInfo_Deployment.DiscardUnknown(m)
   244  }
   245  
   246  var xxx_messageInfo_Deployment proto.InternalMessageInfo
   247  
   248  func (m *DeploymentCondition) Reset()      { *m = DeploymentCondition{} }
   249  func (*DeploymentCondition) ProtoMessage() {}
   250  func (*DeploymentCondition) Descriptor() ([]byte, []int) {
   251  	return fileDescriptor_90a532284de28347, []int{7}
   252  }
   253  func (m *DeploymentCondition) XXX_Unmarshal(b []byte) error {
   254  	return m.Unmarshal(b)
   255  }
   256  func (m *DeploymentCondition) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   257  	b = b[:cap(b)]
   258  	n, err := m.MarshalToSizedBuffer(b)
   259  	if err != nil {
   260  		return nil, err
   261  	}
   262  	return b[:n], nil
   263  }
   264  func (m *DeploymentCondition) XXX_Merge(src proto.Message) {
   265  	xxx_messageInfo_DeploymentCondition.Merge(m, src)
   266  }
   267  func (m *DeploymentCondition) XXX_Size() int {
   268  	return m.Size()
   269  }
   270  func (m *DeploymentCondition) XXX_DiscardUnknown() {
   271  	xxx_messageInfo_DeploymentCondition.DiscardUnknown(m)
   272  }
   273  
   274  var xxx_messageInfo_DeploymentCondition proto.InternalMessageInfo
   275  
   276  func (m *DeploymentList) Reset()      { *m = DeploymentList{} }
   277  func (*DeploymentList) ProtoMessage() {}
   278  func (*DeploymentList) Descriptor() ([]byte, []int) {
   279  	return fileDescriptor_90a532284de28347, []int{8}
   280  }
   281  func (m *DeploymentList) XXX_Unmarshal(b []byte) error {
   282  	return m.Unmarshal(b)
   283  }
   284  func (m *DeploymentList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   285  	b = b[:cap(b)]
   286  	n, err := m.MarshalToSizedBuffer(b)
   287  	if err != nil {
   288  		return nil, err
   289  	}
   290  	return b[:n], nil
   291  }
   292  func (m *DeploymentList) XXX_Merge(src proto.Message) {
   293  	xxx_messageInfo_DeploymentList.Merge(m, src)
   294  }
   295  func (m *DeploymentList) XXX_Size() int {
   296  	return m.Size()
   297  }
   298  func (m *DeploymentList) XXX_DiscardUnknown() {
   299  	xxx_messageInfo_DeploymentList.DiscardUnknown(m)
   300  }
   301  
   302  var xxx_messageInfo_DeploymentList proto.InternalMessageInfo
   303  
   304  func (m *DeploymentRollback) Reset()      { *m = DeploymentRollback{} }
   305  func (*DeploymentRollback) ProtoMessage() {}
   306  func (*DeploymentRollback) Descriptor() ([]byte, []int) {
   307  	return fileDescriptor_90a532284de28347, []int{9}
   308  }
   309  func (m *DeploymentRollback) XXX_Unmarshal(b []byte) error {
   310  	return m.Unmarshal(b)
   311  }
   312  func (m *DeploymentRollback) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   313  	b = b[:cap(b)]
   314  	n, err := m.MarshalToSizedBuffer(b)
   315  	if err != nil {
   316  		return nil, err
   317  	}
   318  	return b[:n], nil
   319  }
   320  func (m *DeploymentRollback) XXX_Merge(src proto.Message) {
   321  	xxx_messageInfo_DeploymentRollback.Merge(m, src)
   322  }
   323  func (m *DeploymentRollback) XXX_Size() int {
   324  	return m.Size()
   325  }
   326  func (m *DeploymentRollback) XXX_DiscardUnknown() {
   327  	xxx_messageInfo_DeploymentRollback.DiscardUnknown(m)
   328  }
   329  
   330  var xxx_messageInfo_DeploymentRollback proto.InternalMessageInfo
   331  
   332  func (m *DeploymentSpec) Reset()      { *m = DeploymentSpec{} }
   333  func (*DeploymentSpec) ProtoMessage() {}
   334  func (*DeploymentSpec) Descriptor() ([]byte, []int) {
   335  	return fileDescriptor_90a532284de28347, []int{10}
   336  }
   337  func (m *DeploymentSpec) XXX_Unmarshal(b []byte) error {
   338  	return m.Unmarshal(b)
   339  }
   340  func (m *DeploymentSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   341  	b = b[:cap(b)]
   342  	n, err := m.MarshalToSizedBuffer(b)
   343  	if err != nil {
   344  		return nil, err
   345  	}
   346  	return b[:n], nil
   347  }
   348  func (m *DeploymentSpec) XXX_Merge(src proto.Message) {
   349  	xxx_messageInfo_DeploymentSpec.Merge(m, src)
   350  }
   351  func (m *DeploymentSpec) XXX_Size() int {
   352  	return m.Size()
   353  }
   354  func (m *DeploymentSpec) XXX_DiscardUnknown() {
   355  	xxx_messageInfo_DeploymentSpec.DiscardUnknown(m)
   356  }
   357  
   358  var xxx_messageInfo_DeploymentSpec proto.InternalMessageInfo
   359  
   360  func (m *DeploymentStatus) Reset()      { *m = DeploymentStatus{} }
   361  func (*DeploymentStatus) ProtoMessage() {}
   362  func (*DeploymentStatus) Descriptor() ([]byte, []int) {
   363  	return fileDescriptor_90a532284de28347, []int{11}
   364  }
   365  func (m *DeploymentStatus) XXX_Unmarshal(b []byte) error {
   366  	return m.Unmarshal(b)
   367  }
   368  func (m *DeploymentStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   369  	b = b[:cap(b)]
   370  	n, err := m.MarshalToSizedBuffer(b)
   371  	if err != nil {
   372  		return nil, err
   373  	}
   374  	return b[:n], nil
   375  }
   376  func (m *DeploymentStatus) XXX_Merge(src proto.Message) {
   377  	xxx_messageInfo_DeploymentStatus.Merge(m, src)
   378  }
   379  func (m *DeploymentStatus) XXX_Size() int {
   380  	return m.Size()
   381  }
   382  func (m *DeploymentStatus) XXX_DiscardUnknown() {
   383  	xxx_messageInfo_DeploymentStatus.DiscardUnknown(m)
   384  }
   385  
   386  var xxx_messageInfo_DeploymentStatus proto.InternalMessageInfo
   387  
   388  func (m *DeploymentStrategy) Reset()      { *m = DeploymentStrategy{} }
   389  func (*DeploymentStrategy) ProtoMessage() {}
   390  func (*DeploymentStrategy) Descriptor() ([]byte, []int) {
   391  	return fileDescriptor_90a532284de28347, []int{12}
   392  }
   393  func (m *DeploymentStrategy) XXX_Unmarshal(b []byte) error {
   394  	return m.Unmarshal(b)
   395  }
   396  func (m *DeploymentStrategy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   397  	b = b[:cap(b)]
   398  	n, err := m.MarshalToSizedBuffer(b)
   399  	if err != nil {
   400  		return nil, err
   401  	}
   402  	return b[:n], nil
   403  }
   404  func (m *DeploymentStrategy) XXX_Merge(src proto.Message) {
   405  	xxx_messageInfo_DeploymentStrategy.Merge(m, src)
   406  }
   407  func (m *DeploymentStrategy) XXX_Size() int {
   408  	return m.Size()
   409  }
   410  func (m *DeploymentStrategy) XXX_DiscardUnknown() {
   411  	xxx_messageInfo_DeploymentStrategy.DiscardUnknown(m)
   412  }
   413  
   414  var xxx_messageInfo_DeploymentStrategy proto.InternalMessageInfo
   415  
   416  func (m *HTTPIngressPath) Reset()      { *m = HTTPIngressPath{} }
   417  func (*HTTPIngressPath) ProtoMessage() {}
   418  func (*HTTPIngressPath) Descriptor() ([]byte, []int) {
   419  	return fileDescriptor_90a532284de28347, []int{13}
   420  }
   421  func (m *HTTPIngressPath) XXX_Unmarshal(b []byte) error {
   422  	return m.Unmarshal(b)
   423  }
   424  func (m *HTTPIngressPath) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   425  	b = b[:cap(b)]
   426  	n, err := m.MarshalToSizedBuffer(b)
   427  	if err != nil {
   428  		return nil, err
   429  	}
   430  	return b[:n], nil
   431  }
   432  func (m *HTTPIngressPath) XXX_Merge(src proto.Message) {
   433  	xxx_messageInfo_HTTPIngressPath.Merge(m, src)
   434  }
   435  func (m *HTTPIngressPath) XXX_Size() int {
   436  	return m.Size()
   437  }
   438  func (m *HTTPIngressPath) XXX_DiscardUnknown() {
   439  	xxx_messageInfo_HTTPIngressPath.DiscardUnknown(m)
   440  }
   441  
   442  var xxx_messageInfo_HTTPIngressPath proto.InternalMessageInfo
   443  
   444  func (m *HTTPIngressRuleValue) Reset()      { *m = HTTPIngressRuleValue{} }
   445  func (*HTTPIngressRuleValue) ProtoMessage() {}
   446  func (*HTTPIngressRuleValue) Descriptor() ([]byte, []int) {
   447  	return fileDescriptor_90a532284de28347, []int{14}
   448  }
   449  func (m *HTTPIngressRuleValue) XXX_Unmarshal(b []byte) error {
   450  	return m.Unmarshal(b)
   451  }
   452  func (m *HTTPIngressRuleValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   453  	b = b[:cap(b)]
   454  	n, err := m.MarshalToSizedBuffer(b)
   455  	if err != nil {
   456  		return nil, err
   457  	}
   458  	return b[:n], nil
   459  }
   460  func (m *HTTPIngressRuleValue) XXX_Merge(src proto.Message) {
   461  	xxx_messageInfo_HTTPIngressRuleValue.Merge(m, src)
   462  }
   463  func (m *HTTPIngressRuleValue) XXX_Size() int {
   464  	return m.Size()
   465  }
   466  func (m *HTTPIngressRuleValue) XXX_DiscardUnknown() {
   467  	xxx_messageInfo_HTTPIngressRuleValue.DiscardUnknown(m)
   468  }
   469  
   470  var xxx_messageInfo_HTTPIngressRuleValue proto.InternalMessageInfo
   471  
   472  func (m *IPBlock) Reset()      { *m = IPBlock{} }
   473  func (*IPBlock) ProtoMessage() {}
   474  func (*IPBlock) Descriptor() ([]byte, []int) {
   475  	return fileDescriptor_90a532284de28347, []int{15}
   476  }
   477  func (m *IPBlock) XXX_Unmarshal(b []byte) error {
   478  	return m.Unmarshal(b)
   479  }
   480  func (m *IPBlock) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   481  	b = b[:cap(b)]
   482  	n, err := m.MarshalToSizedBuffer(b)
   483  	if err != nil {
   484  		return nil, err
   485  	}
   486  	return b[:n], nil
   487  }
   488  func (m *IPBlock) XXX_Merge(src proto.Message) {
   489  	xxx_messageInfo_IPBlock.Merge(m, src)
   490  }
   491  func (m *IPBlock) XXX_Size() int {
   492  	return m.Size()
   493  }
   494  func (m *IPBlock) XXX_DiscardUnknown() {
   495  	xxx_messageInfo_IPBlock.DiscardUnknown(m)
   496  }
   497  
   498  var xxx_messageInfo_IPBlock proto.InternalMessageInfo
   499  
   500  func (m *Ingress) Reset()      { *m = Ingress{} }
   501  func (*Ingress) ProtoMessage() {}
   502  func (*Ingress) Descriptor() ([]byte, []int) {
   503  	return fileDescriptor_90a532284de28347, []int{16}
   504  }
   505  func (m *Ingress) XXX_Unmarshal(b []byte) error {
   506  	return m.Unmarshal(b)
   507  }
   508  func (m *Ingress) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   509  	b = b[:cap(b)]
   510  	n, err := m.MarshalToSizedBuffer(b)
   511  	if err != nil {
   512  		return nil, err
   513  	}
   514  	return b[:n], nil
   515  }
   516  func (m *Ingress) XXX_Merge(src proto.Message) {
   517  	xxx_messageInfo_Ingress.Merge(m, src)
   518  }
   519  func (m *Ingress) XXX_Size() int {
   520  	return m.Size()
   521  }
   522  func (m *Ingress) XXX_DiscardUnknown() {
   523  	xxx_messageInfo_Ingress.DiscardUnknown(m)
   524  }
   525  
   526  var xxx_messageInfo_Ingress proto.InternalMessageInfo
   527  
   528  func (m *IngressBackend) Reset()      { *m = IngressBackend{} }
   529  func (*IngressBackend) ProtoMessage() {}
   530  func (*IngressBackend) Descriptor() ([]byte, []int) {
   531  	return fileDescriptor_90a532284de28347, []int{17}
   532  }
   533  func (m *IngressBackend) XXX_Unmarshal(b []byte) error {
   534  	return m.Unmarshal(b)
   535  }
   536  func (m *IngressBackend) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   537  	b = b[:cap(b)]
   538  	n, err := m.MarshalToSizedBuffer(b)
   539  	if err != nil {
   540  		return nil, err
   541  	}
   542  	return b[:n], nil
   543  }
   544  func (m *IngressBackend) XXX_Merge(src proto.Message) {
   545  	xxx_messageInfo_IngressBackend.Merge(m, src)
   546  }
   547  func (m *IngressBackend) XXX_Size() int {
   548  	return m.Size()
   549  }
   550  func (m *IngressBackend) XXX_DiscardUnknown() {
   551  	xxx_messageInfo_IngressBackend.DiscardUnknown(m)
   552  }
   553  
   554  var xxx_messageInfo_IngressBackend proto.InternalMessageInfo
   555  
   556  func (m *IngressList) Reset()      { *m = IngressList{} }
   557  func (*IngressList) ProtoMessage() {}
   558  func (*IngressList) Descriptor() ([]byte, []int) {
   559  	return fileDescriptor_90a532284de28347, []int{18}
   560  }
   561  func (m *IngressList) XXX_Unmarshal(b []byte) error {
   562  	return m.Unmarshal(b)
   563  }
   564  func (m *IngressList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   565  	b = b[:cap(b)]
   566  	n, err := m.MarshalToSizedBuffer(b)
   567  	if err != nil {
   568  		return nil, err
   569  	}
   570  	return b[:n], nil
   571  }
   572  func (m *IngressList) XXX_Merge(src proto.Message) {
   573  	xxx_messageInfo_IngressList.Merge(m, src)
   574  }
   575  func (m *IngressList) XXX_Size() int {
   576  	return m.Size()
   577  }
   578  func (m *IngressList) XXX_DiscardUnknown() {
   579  	xxx_messageInfo_IngressList.DiscardUnknown(m)
   580  }
   581  
   582  var xxx_messageInfo_IngressList proto.InternalMessageInfo
   583  
   584  func (m *IngressLoadBalancerIngress) Reset()      { *m = IngressLoadBalancerIngress{} }
   585  func (*IngressLoadBalancerIngress) ProtoMessage() {}
   586  func (*IngressLoadBalancerIngress) Descriptor() ([]byte, []int) {
   587  	return fileDescriptor_90a532284de28347, []int{19}
   588  }
   589  func (m *IngressLoadBalancerIngress) XXX_Unmarshal(b []byte) error {
   590  	return m.Unmarshal(b)
   591  }
   592  func (m *IngressLoadBalancerIngress) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   593  	b = b[:cap(b)]
   594  	n, err := m.MarshalToSizedBuffer(b)
   595  	if err != nil {
   596  		return nil, err
   597  	}
   598  	return b[:n], nil
   599  }
   600  func (m *IngressLoadBalancerIngress) XXX_Merge(src proto.Message) {
   601  	xxx_messageInfo_IngressLoadBalancerIngress.Merge(m, src)
   602  }
   603  func (m *IngressLoadBalancerIngress) XXX_Size() int {
   604  	return m.Size()
   605  }
   606  func (m *IngressLoadBalancerIngress) XXX_DiscardUnknown() {
   607  	xxx_messageInfo_IngressLoadBalancerIngress.DiscardUnknown(m)
   608  }
   609  
   610  var xxx_messageInfo_IngressLoadBalancerIngress proto.InternalMessageInfo
   611  
   612  func (m *IngressLoadBalancerStatus) Reset()      { *m = IngressLoadBalancerStatus{} }
   613  func (*IngressLoadBalancerStatus) ProtoMessage() {}
   614  func (*IngressLoadBalancerStatus) Descriptor() ([]byte, []int) {
   615  	return fileDescriptor_90a532284de28347, []int{20}
   616  }
   617  func (m *IngressLoadBalancerStatus) XXX_Unmarshal(b []byte) error {
   618  	return m.Unmarshal(b)
   619  }
   620  func (m *IngressLoadBalancerStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   621  	b = b[:cap(b)]
   622  	n, err := m.MarshalToSizedBuffer(b)
   623  	if err != nil {
   624  		return nil, err
   625  	}
   626  	return b[:n], nil
   627  }
   628  func (m *IngressLoadBalancerStatus) XXX_Merge(src proto.Message) {
   629  	xxx_messageInfo_IngressLoadBalancerStatus.Merge(m, src)
   630  }
   631  func (m *IngressLoadBalancerStatus) XXX_Size() int {
   632  	return m.Size()
   633  }
   634  func (m *IngressLoadBalancerStatus) XXX_DiscardUnknown() {
   635  	xxx_messageInfo_IngressLoadBalancerStatus.DiscardUnknown(m)
   636  }
   637  
   638  var xxx_messageInfo_IngressLoadBalancerStatus proto.InternalMessageInfo
   639  
   640  func (m *IngressPortStatus) Reset()      { *m = IngressPortStatus{} }
   641  func (*IngressPortStatus) ProtoMessage() {}
   642  func (*IngressPortStatus) Descriptor() ([]byte, []int) {
   643  	return fileDescriptor_90a532284de28347, []int{21}
   644  }
   645  func (m *IngressPortStatus) XXX_Unmarshal(b []byte) error {
   646  	return m.Unmarshal(b)
   647  }
   648  func (m *IngressPortStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   649  	b = b[:cap(b)]
   650  	n, err := m.MarshalToSizedBuffer(b)
   651  	if err != nil {
   652  		return nil, err
   653  	}
   654  	return b[:n], nil
   655  }
   656  func (m *IngressPortStatus) XXX_Merge(src proto.Message) {
   657  	xxx_messageInfo_IngressPortStatus.Merge(m, src)
   658  }
   659  func (m *IngressPortStatus) XXX_Size() int {
   660  	return m.Size()
   661  }
   662  func (m *IngressPortStatus) XXX_DiscardUnknown() {
   663  	xxx_messageInfo_IngressPortStatus.DiscardUnknown(m)
   664  }
   665  
   666  var xxx_messageInfo_IngressPortStatus proto.InternalMessageInfo
   667  
   668  func (m *IngressRule) Reset()      { *m = IngressRule{} }
   669  func (*IngressRule) ProtoMessage() {}
   670  func (*IngressRule) Descriptor() ([]byte, []int) {
   671  	return fileDescriptor_90a532284de28347, []int{22}
   672  }
   673  func (m *IngressRule) XXX_Unmarshal(b []byte) error {
   674  	return m.Unmarshal(b)
   675  }
   676  func (m *IngressRule) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   677  	b = b[:cap(b)]
   678  	n, err := m.MarshalToSizedBuffer(b)
   679  	if err != nil {
   680  		return nil, err
   681  	}
   682  	return b[:n], nil
   683  }
   684  func (m *IngressRule) XXX_Merge(src proto.Message) {
   685  	xxx_messageInfo_IngressRule.Merge(m, src)
   686  }
   687  func (m *IngressRule) XXX_Size() int {
   688  	return m.Size()
   689  }
   690  func (m *IngressRule) XXX_DiscardUnknown() {
   691  	xxx_messageInfo_IngressRule.DiscardUnknown(m)
   692  }
   693  
   694  var xxx_messageInfo_IngressRule proto.InternalMessageInfo
   695  
   696  func (m *IngressRuleValue) Reset()      { *m = IngressRuleValue{} }
   697  func (*IngressRuleValue) ProtoMessage() {}
   698  func (*IngressRuleValue) Descriptor() ([]byte, []int) {
   699  	return fileDescriptor_90a532284de28347, []int{23}
   700  }
   701  func (m *IngressRuleValue) XXX_Unmarshal(b []byte) error {
   702  	return m.Unmarshal(b)
   703  }
   704  func (m *IngressRuleValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   705  	b = b[:cap(b)]
   706  	n, err := m.MarshalToSizedBuffer(b)
   707  	if err != nil {
   708  		return nil, err
   709  	}
   710  	return b[:n], nil
   711  }
   712  func (m *IngressRuleValue) XXX_Merge(src proto.Message) {
   713  	xxx_messageInfo_IngressRuleValue.Merge(m, src)
   714  }
   715  func (m *IngressRuleValue) XXX_Size() int {
   716  	return m.Size()
   717  }
   718  func (m *IngressRuleValue) XXX_DiscardUnknown() {
   719  	xxx_messageInfo_IngressRuleValue.DiscardUnknown(m)
   720  }
   721  
   722  var xxx_messageInfo_IngressRuleValue proto.InternalMessageInfo
   723  
   724  func (m *IngressSpec) Reset()      { *m = IngressSpec{} }
   725  func (*IngressSpec) ProtoMessage() {}
   726  func (*IngressSpec) Descriptor() ([]byte, []int) {
   727  	return fileDescriptor_90a532284de28347, []int{24}
   728  }
   729  func (m *IngressSpec) XXX_Unmarshal(b []byte) error {
   730  	return m.Unmarshal(b)
   731  }
   732  func (m *IngressSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   733  	b = b[:cap(b)]
   734  	n, err := m.MarshalToSizedBuffer(b)
   735  	if err != nil {
   736  		return nil, err
   737  	}
   738  	return b[:n], nil
   739  }
   740  func (m *IngressSpec) XXX_Merge(src proto.Message) {
   741  	xxx_messageInfo_IngressSpec.Merge(m, src)
   742  }
   743  func (m *IngressSpec) XXX_Size() int {
   744  	return m.Size()
   745  }
   746  func (m *IngressSpec) XXX_DiscardUnknown() {
   747  	xxx_messageInfo_IngressSpec.DiscardUnknown(m)
   748  }
   749  
   750  var xxx_messageInfo_IngressSpec proto.InternalMessageInfo
   751  
   752  func (m *IngressStatus) Reset()      { *m = IngressStatus{} }
   753  func (*IngressStatus) ProtoMessage() {}
   754  func (*IngressStatus) Descriptor() ([]byte, []int) {
   755  	return fileDescriptor_90a532284de28347, []int{25}
   756  }
   757  func (m *IngressStatus) XXX_Unmarshal(b []byte) error {
   758  	return m.Unmarshal(b)
   759  }
   760  func (m *IngressStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   761  	b = b[:cap(b)]
   762  	n, err := m.MarshalToSizedBuffer(b)
   763  	if err != nil {
   764  		return nil, err
   765  	}
   766  	return b[:n], nil
   767  }
   768  func (m *IngressStatus) XXX_Merge(src proto.Message) {
   769  	xxx_messageInfo_IngressStatus.Merge(m, src)
   770  }
   771  func (m *IngressStatus) XXX_Size() int {
   772  	return m.Size()
   773  }
   774  func (m *IngressStatus) XXX_DiscardUnknown() {
   775  	xxx_messageInfo_IngressStatus.DiscardUnknown(m)
   776  }
   777  
   778  var xxx_messageInfo_IngressStatus proto.InternalMessageInfo
   779  
   780  func (m *IngressTLS) Reset()      { *m = IngressTLS{} }
   781  func (*IngressTLS) ProtoMessage() {}
   782  func (*IngressTLS) Descriptor() ([]byte, []int) {
   783  	return fileDescriptor_90a532284de28347, []int{26}
   784  }
   785  func (m *IngressTLS) XXX_Unmarshal(b []byte) error {
   786  	return m.Unmarshal(b)
   787  }
   788  func (m *IngressTLS) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   789  	b = b[:cap(b)]
   790  	n, err := m.MarshalToSizedBuffer(b)
   791  	if err != nil {
   792  		return nil, err
   793  	}
   794  	return b[:n], nil
   795  }
   796  func (m *IngressTLS) XXX_Merge(src proto.Message) {
   797  	xxx_messageInfo_IngressTLS.Merge(m, src)
   798  }
   799  func (m *IngressTLS) XXX_Size() int {
   800  	return m.Size()
   801  }
   802  func (m *IngressTLS) XXX_DiscardUnknown() {
   803  	xxx_messageInfo_IngressTLS.DiscardUnknown(m)
   804  }
   805  
   806  var xxx_messageInfo_IngressTLS proto.InternalMessageInfo
   807  
   808  func (m *NetworkPolicy) Reset()      { *m = NetworkPolicy{} }
   809  func (*NetworkPolicy) ProtoMessage() {}
   810  func (*NetworkPolicy) Descriptor() ([]byte, []int) {
   811  	return fileDescriptor_90a532284de28347, []int{27}
   812  }
   813  func (m *NetworkPolicy) XXX_Unmarshal(b []byte) error {
   814  	return m.Unmarshal(b)
   815  }
   816  func (m *NetworkPolicy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   817  	b = b[:cap(b)]
   818  	n, err := m.MarshalToSizedBuffer(b)
   819  	if err != nil {
   820  		return nil, err
   821  	}
   822  	return b[:n], nil
   823  }
   824  func (m *NetworkPolicy) XXX_Merge(src proto.Message) {
   825  	xxx_messageInfo_NetworkPolicy.Merge(m, src)
   826  }
   827  func (m *NetworkPolicy) XXX_Size() int {
   828  	return m.Size()
   829  }
   830  func (m *NetworkPolicy) XXX_DiscardUnknown() {
   831  	xxx_messageInfo_NetworkPolicy.DiscardUnknown(m)
   832  }
   833  
   834  var xxx_messageInfo_NetworkPolicy proto.InternalMessageInfo
   835  
   836  func (m *NetworkPolicyEgressRule) Reset()      { *m = NetworkPolicyEgressRule{} }
   837  func (*NetworkPolicyEgressRule) ProtoMessage() {}
   838  func (*NetworkPolicyEgressRule) Descriptor() ([]byte, []int) {
   839  	return fileDescriptor_90a532284de28347, []int{28}
   840  }
   841  func (m *NetworkPolicyEgressRule) XXX_Unmarshal(b []byte) error {
   842  	return m.Unmarshal(b)
   843  }
   844  func (m *NetworkPolicyEgressRule) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   845  	b = b[:cap(b)]
   846  	n, err := m.MarshalToSizedBuffer(b)
   847  	if err != nil {
   848  		return nil, err
   849  	}
   850  	return b[:n], nil
   851  }
   852  func (m *NetworkPolicyEgressRule) XXX_Merge(src proto.Message) {
   853  	xxx_messageInfo_NetworkPolicyEgressRule.Merge(m, src)
   854  }
   855  func (m *NetworkPolicyEgressRule) XXX_Size() int {
   856  	return m.Size()
   857  }
   858  func (m *NetworkPolicyEgressRule) XXX_DiscardUnknown() {
   859  	xxx_messageInfo_NetworkPolicyEgressRule.DiscardUnknown(m)
   860  }
   861  
   862  var xxx_messageInfo_NetworkPolicyEgressRule proto.InternalMessageInfo
   863  
   864  func (m *NetworkPolicyIngressRule) Reset()      { *m = NetworkPolicyIngressRule{} }
   865  func (*NetworkPolicyIngressRule) ProtoMessage() {}
   866  func (*NetworkPolicyIngressRule) Descriptor() ([]byte, []int) {
   867  	return fileDescriptor_90a532284de28347, []int{29}
   868  }
   869  func (m *NetworkPolicyIngressRule) XXX_Unmarshal(b []byte) error {
   870  	return m.Unmarshal(b)
   871  }
   872  func (m *NetworkPolicyIngressRule) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   873  	b = b[:cap(b)]
   874  	n, err := m.MarshalToSizedBuffer(b)
   875  	if err != nil {
   876  		return nil, err
   877  	}
   878  	return b[:n], nil
   879  }
   880  func (m *NetworkPolicyIngressRule) XXX_Merge(src proto.Message) {
   881  	xxx_messageInfo_NetworkPolicyIngressRule.Merge(m, src)
   882  }
   883  func (m *NetworkPolicyIngressRule) XXX_Size() int {
   884  	return m.Size()
   885  }
   886  func (m *NetworkPolicyIngressRule) XXX_DiscardUnknown() {
   887  	xxx_messageInfo_NetworkPolicyIngressRule.DiscardUnknown(m)
   888  }
   889  
   890  var xxx_messageInfo_NetworkPolicyIngressRule proto.InternalMessageInfo
   891  
   892  func (m *NetworkPolicyList) Reset()      { *m = NetworkPolicyList{} }
   893  func (*NetworkPolicyList) ProtoMessage() {}
   894  func (*NetworkPolicyList) Descriptor() ([]byte, []int) {
   895  	return fileDescriptor_90a532284de28347, []int{30}
   896  }
   897  func (m *NetworkPolicyList) XXX_Unmarshal(b []byte) error {
   898  	return m.Unmarshal(b)
   899  }
   900  func (m *NetworkPolicyList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   901  	b = b[:cap(b)]
   902  	n, err := m.MarshalToSizedBuffer(b)
   903  	if err != nil {
   904  		return nil, err
   905  	}
   906  	return b[:n], nil
   907  }
   908  func (m *NetworkPolicyList) XXX_Merge(src proto.Message) {
   909  	xxx_messageInfo_NetworkPolicyList.Merge(m, src)
   910  }
   911  func (m *NetworkPolicyList) XXX_Size() int {
   912  	return m.Size()
   913  }
   914  func (m *NetworkPolicyList) XXX_DiscardUnknown() {
   915  	xxx_messageInfo_NetworkPolicyList.DiscardUnknown(m)
   916  }
   917  
   918  var xxx_messageInfo_NetworkPolicyList proto.InternalMessageInfo
   919  
   920  func (m *NetworkPolicyPeer) Reset()      { *m = NetworkPolicyPeer{} }
   921  func (*NetworkPolicyPeer) ProtoMessage() {}
   922  func (*NetworkPolicyPeer) Descriptor() ([]byte, []int) {
   923  	return fileDescriptor_90a532284de28347, []int{31}
   924  }
   925  func (m *NetworkPolicyPeer) XXX_Unmarshal(b []byte) error {
   926  	return m.Unmarshal(b)
   927  }
   928  func (m *NetworkPolicyPeer) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   929  	b = b[:cap(b)]
   930  	n, err := m.MarshalToSizedBuffer(b)
   931  	if err != nil {
   932  		return nil, err
   933  	}
   934  	return b[:n], nil
   935  }
   936  func (m *NetworkPolicyPeer) XXX_Merge(src proto.Message) {
   937  	xxx_messageInfo_NetworkPolicyPeer.Merge(m, src)
   938  }
   939  func (m *NetworkPolicyPeer) XXX_Size() int {
   940  	return m.Size()
   941  }
   942  func (m *NetworkPolicyPeer) XXX_DiscardUnknown() {
   943  	xxx_messageInfo_NetworkPolicyPeer.DiscardUnknown(m)
   944  }
   945  
   946  var xxx_messageInfo_NetworkPolicyPeer proto.InternalMessageInfo
   947  
   948  func (m *NetworkPolicyPort) Reset()      { *m = NetworkPolicyPort{} }
   949  func (*NetworkPolicyPort) ProtoMessage() {}
   950  func (*NetworkPolicyPort) Descriptor() ([]byte, []int) {
   951  	return fileDescriptor_90a532284de28347, []int{32}
   952  }
   953  func (m *NetworkPolicyPort) XXX_Unmarshal(b []byte) error {
   954  	return m.Unmarshal(b)
   955  }
   956  func (m *NetworkPolicyPort) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   957  	b = b[:cap(b)]
   958  	n, err := m.MarshalToSizedBuffer(b)
   959  	if err != nil {
   960  		return nil, err
   961  	}
   962  	return b[:n], nil
   963  }
   964  func (m *NetworkPolicyPort) XXX_Merge(src proto.Message) {
   965  	xxx_messageInfo_NetworkPolicyPort.Merge(m, src)
   966  }
   967  func (m *NetworkPolicyPort) XXX_Size() int {
   968  	return m.Size()
   969  }
   970  func (m *NetworkPolicyPort) XXX_DiscardUnknown() {
   971  	xxx_messageInfo_NetworkPolicyPort.DiscardUnknown(m)
   972  }
   973  
   974  var xxx_messageInfo_NetworkPolicyPort proto.InternalMessageInfo
   975  
   976  func (m *NetworkPolicySpec) Reset()      { *m = NetworkPolicySpec{} }
   977  func (*NetworkPolicySpec) ProtoMessage() {}
   978  func (*NetworkPolicySpec) Descriptor() ([]byte, []int) {
   979  	return fileDescriptor_90a532284de28347, []int{33}
   980  }
   981  func (m *NetworkPolicySpec) XXX_Unmarshal(b []byte) error {
   982  	return m.Unmarshal(b)
   983  }
   984  func (m *NetworkPolicySpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   985  	b = b[:cap(b)]
   986  	n, err := m.MarshalToSizedBuffer(b)
   987  	if err != nil {
   988  		return nil, err
   989  	}
   990  	return b[:n], nil
   991  }
   992  func (m *NetworkPolicySpec) XXX_Merge(src proto.Message) {
   993  	xxx_messageInfo_NetworkPolicySpec.Merge(m, src)
   994  }
   995  func (m *NetworkPolicySpec) XXX_Size() int {
   996  	return m.Size()
   997  }
   998  func (m *NetworkPolicySpec) XXX_DiscardUnknown() {
   999  	xxx_messageInfo_NetworkPolicySpec.DiscardUnknown(m)
  1000  }
  1001  
  1002  var xxx_messageInfo_NetworkPolicySpec proto.InternalMessageInfo
  1003  
  1004  func (m *ReplicaSet) Reset()      { *m = ReplicaSet{} }
  1005  func (*ReplicaSet) ProtoMessage() {}
  1006  func (*ReplicaSet) Descriptor() ([]byte, []int) {
  1007  	return fileDescriptor_90a532284de28347, []int{34}
  1008  }
  1009  func (m *ReplicaSet) XXX_Unmarshal(b []byte) error {
  1010  	return m.Unmarshal(b)
  1011  }
  1012  func (m *ReplicaSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  1013  	b = b[:cap(b)]
  1014  	n, err := m.MarshalToSizedBuffer(b)
  1015  	if err != nil {
  1016  		return nil, err
  1017  	}
  1018  	return b[:n], nil
  1019  }
  1020  func (m *ReplicaSet) XXX_Merge(src proto.Message) {
  1021  	xxx_messageInfo_ReplicaSet.Merge(m, src)
  1022  }
  1023  func (m *ReplicaSet) XXX_Size() int {
  1024  	return m.Size()
  1025  }
  1026  func (m *ReplicaSet) XXX_DiscardUnknown() {
  1027  	xxx_messageInfo_ReplicaSet.DiscardUnknown(m)
  1028  }
  1029  
  1030  var xxx_messageInfo_ReplicaSet proto.InternalMessageInfo
  1031  
  1032  func (m *ReplicaSetCondition) Reset()      { *m = ReplicaSetCondition{} }
  1033  func (*ReplicaSetCondition) ProtoMessage() {}
  1034  func (*ReplicaSetCondition) Descriptor() ([]byte, []int) {
  1035  	return fileDescriptor_90a532284de28347, []int{35}
  1036  }
  1037  func (m *ReplicaSetCondition) XXX_Unmarshal(b []byte) error {
  1038  	return m.Unmarshal(b)
  1039  }
  1040  func (m *ReplicaSetCondition) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  1041  	b = b[:cap(b)]
  1042  	n, err := m.MarshalToSizedBuffer(b)
  1043  	if err != nil {
  1044  		return nil, err
  1045  	}
  1046  	return b[:n], nil
  1047  }
  1048  func (m *ReplicaSetCondition) XXX_Merge(src proto.Message) {
  1049  	xxx_messageInfo_ReplicaSetCondition.Merge(m, src)
  1050  }
  1051  func (m *ReplicaSetCondition) XXX_Size() int {
  1052  	return m.Size()
  1053  }
  1054  func (m *ReplicaSetCondition) XXX_DiscardUnknown() {
  1055  	xxx_messageInfo_ReplicaSetCondition.DiscardUnknown(m)
  1056  }
  1057  
  1058  var xxx_messageInfo_ReplicaSetCondition proto.InternalMessageInfo
  1059  
  1060  func (m *ReplicaSetList) Reset()      { *m = ReplicaSetList{} }
  1061  func (*ReplicaSetList) ProtoMessage() {}
  1062  func (*ReplicaSetList) Descriptor() ([]byte, []int) {
  1063  	return fileDescriptor_90a532284de28347, []int{36}
  1064  }
  1065  func (m *ReplicaSetList) XXX_Unmarshal(b []byte) error {
  1066  	return m.Unmarshal(b)
  1067  }
  1068  func (m *ReplicaSetList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  1069  	b = b[:cap(b)]
  1070  	n, err := m.MarshalToSizedBuffer(b)
  1071  	if err != nil {
  1072  		return nil, err
  1073  	}
  1074  	return b[:n], nil
  1075  }
  1076  func (m *ReplicaSetList) XXX_Merge(src proto.Message) {
  1077  	xxx_messageInfo_ReplicaSetList.Merge(m, src)
  1078  }
  1079  func (m *ReplicaSetList) XXX_Size() int {
  1080  	return m.Size()
  1081  }
  1082  func (m *ReplicaSetList) XXX_DiscardUnknown() {
  1083  	xxx_messageInfo_ReplicaSetList.DiscardUnknown(m)
  1084  }
  1085  
  1086  var xxx_messageInfo_ReplicaSetList proto.InternalMessageInfo
  1087  
  1088  func (m *ReplicaSetSpec) Reset()      { *m = ReplicaSetSpec{} }
  1089  func (*ReplicaSetSpec) ProtoMessage() {}
  1090  func (*ReplicaSetSpec) Descriptor() ([]byte, []int) {
  1091  	return fileDescriptor_90a532284de28347, []int{37}
  1092  }
  1093  func (m *ReplicaSetSpec) XXX_Unmarshal(b []byte) error {
  1094  	return m.Unmarshal(b)
  1095  }
  1096  func (m *ReplicaSetSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  1097  	b = b[:cap(b)]
  1098  	n, err := m.MarshalToSizedBuffer(b)
  1099  	if err != nil {
  1100  		return nil, err
  1101  	}
  1102  	return b[:n], nil
  1103  }
  1104  func (m *ReplicaSetSpec) XXX_Merge(src proto.Message) {
  1105  	xxx_messageInfo_ReplicaSetSpec.Merge(m, src)
  1106  }
  1107  func (m *ReplicaSetSpec) XXX_Size() int {
  1108  	return m.Size()
  1109  }
  1110  func (m *ReplicaSetSpec) XXX_DiscardUnknown() {
  1111  	xxx_messageInfo_ReplicaSetSpec.DiscardUnknown(m)
  1112  }
  1113  
  1114  var xxx_messageInfo_ReplicaSetSpec proto.InternalMessageInfo
  1115  
  1116  func (m *ReplicaSetStatus) Reset()      { *m = ReplicaSetStatus{} }
  1117  func (*ReplicaSetStatus) ProtoMessage() {}
  1118  func (*ReplicaSetStatus) Descriptor() ([]byte, []int) {
  1119  	return fileDescriptor_90a532284de28347, []int{38}
  1120  }
  1121  func (m *ReplicaSetStatus) XXX_Unmarshal(b []byte) error {
  1122  	return m.Unmarshal(b)
  1123  }
  1124  func (m *ReplicaSetStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  1125  	b = b[:cap(b)]
  1126  	n, err := m.MarshalToSizedBuffer(b)
  1127  	if err != nil {
  1128  		return nil, err
  1129  	}
  1130  	return b[:n], nil
  1131  }
  1132  func (m *ReplicaSetStatus) XXX_Merge(src proto.Message) {
  1133  	xxx_messageInfo_ReplicaSetStatus.Merge(m, src)
  1134  }
  1135  func (m *ReplicaSetStatus) XXX_Size() int {
  1136  	return m.Size()
  1137  }
  1138  func (m *ReplicaSetStatus) XXX_DiscardUnknown() {
  1139  	xxx_messageInfo_ReplicaSetStatus.DiscardUnknown(m)
  1140  }
  1141  
  1142  var xxx_messageInfo_ReplicaSetStatus proto.InternalMessageInfo
  1143  
  1144  func (m *RollbackConfig) Reset()      { *m = RollbackConfig{} }
  1145  func (*RollbackConfig) ProtoMessage() {}
  1146  func (*RollbackConfig) Descriptor() ([]byte, []int) {
  1147  	return fileDescriptor_90a532284de28347, []int{39}
  1148  }
  1149  func (m *RollbackConfig) XXX_Unmarshal(b []byte) error {
  1150  	return m.Unmarshal(b)
  1151  }
  1152  func (m *RollbackConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  1153  	b = b[:cap(b)]
  1154  	n, err := m.MarshalToSizedBuffer(b)
  1155  	if err != nil {
  1156  		return nil, err
  1157  	}
  1158  	return b[:n], nil
  1159  }
  1160  func (m *RollbackConfig) XXX_Merge(src proto.Message) {
  1161  	xxx_messageInfo_RollbackConfig.Merge(m, src)
  1162  }
  1163  func (m *RollbackConfig) XXX_Size() int {
  1164  	return m.Size()
  1165  }
  1166  func (m *RollbackConfig) XXX_DiscardUnknown() {
  1167  	xxx_messageInfo_RollbackConfig.DiscardUnknown(m)
  1168  }
  1169  
  1170  var xxx_messageInfo_RollbackConfig proto.InternalMessageInfo
  1171  
  1172  func (m *RollingUpdateDaemonSet) Reset()      { *m = RollingUpdateDaemonSet{} }
  1173  func (*RollingUpdateDaemonSet) ProtoMessage() {}
  1174  func (*RollingUpdateDaemonSet) Descriptor() ([]byte, []int) {
  1175  	return fileDescriptor_90a532284de28347, []int{40}
  1176  }
  1177  func (m *RollingUpdateDaemonSet) XXX_Unmarshal(b []byte) error {
  1178  	return m.Unmarshal(b)
  1179  }
  1180  func (m *RollingUpdateDaemonSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  1181  	b = b[:cap(b)]
  1182  	n, err := m.MarshalToSizedBuffer(b)
  1183  	if err != nil {
  1184  		return nil, err
  1185  	}
  1186  	return b[:n], nil
  1187  }
  1188  func (m *RollingUpdateDaemonSet) XXX_Merge(src proto.Message) {
  1189  	xxx_messageInfo_RollingUpdateDaemonSet.Merge(m, src)
  1190  }
  1191  func (m *RollingUpdateDaemonSet) XXX_Size() int {
  1192  	return m.Size()
  1193  }
  1194  func (m *RollingUpdateDaemonSet) XXX_DiscardUnknown() {
  1195  	xxx_messageInfo_RollingUpdateDaemonSet.DiscardUnknown(m)
  1196  }
  1197  
  1198  var xxx_messageInfo_RollingUpdateDaemonSet proto.InternalMessageInfo
  1199  
  1200  func (m *RollingUpdateDeployment) Reset()      { *m = RollingUpdateDeployment{} }
  1201  func (*RollingUpdateDeployment) ProtoMessage() {}
  1202  func (*RollingUpdateDeployment) Descriptor() ([]byte, []int) {
  1203  	return fileDescriptor_90a532284de28347, []int{41}
  1204  }
  1205  func (m *RollingUpdateDeployment) XXX_Unmarshal(b []byte) error {
  1206  	return m.Unmarshal(b)
  1207  }
  1208  func (m *RollingUpdateDeployment) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  1209  	b = b[:cap(b)]
  1210  	n, err := m.MarshalToSizedBuffer(b)
  1211  	if err != nil {
  1212  		return nil, err
  1213  	}
  1214  	return b[:n], nil
  1215  }
  1216  func (m *RollingUpdateDeployment) XXX_Merge(src proto.Message) {
  1217  	xxx_messageInfo_RollingUpdateDeployment.Merge(m, src)
  1218  }
  1219  func (m *RollingUpdateDeployment) XXX_Size() int {
  1220  	return m.Size()
  1221  }
  1222  func (m *RollingUpdateDeployment) XXX_DiscardUnknown() {
  1223  	xxx_messageInfo_RollingUpdateDeployment.DiscardUnknown(m)
  1224  }
  1225  
  1226  var xxx_messageInfo_RollingUpdateDeployment proto.InternalMessageInfo
  1227  
  1228  func (m *Scale) Reset()      { *m = Scale{} }
  1229  func (*Scale) ProtoMessage() {}
  1230  func (*Scale) Descriptor() ([]byte, []int) {
  1231  	return fileDescriptor_90a532284de28347, []int{42}
  1232  }
  1233  func (m *Scale) XXX_Unmarshal(b []byte) error {
  1234  	return m.Unmarshal(b)
  1235  }
  1236  func (m *Scale) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  1237  	b = b[:cap(b)]
  1238  	n, err := m.MarshalToSizedBuffer(b)
  1239  	if err != nil {
  1240  		return nil, err
  1241  	}
  1242  	return b[:n], nil
  1243  }
  1244  func (m *Scale) XXX_Merge(src proto.Message) {
  1245  	xxx_messageInfo_Scale.Merge(m, src)
  1246  }
  1247  func (m *Scale) XXX_Size() int {
  1248  	return m.Size()
  1249  }
  1250  func (m *Scale) XXX_DiscardUnknown() {
  1251  	xxx_messageInfo_Scale.DiscardUnknown(m)
  1252  }
  1253  
  1254  var xxx_messageInfo_Scale proto.InternalMessageInfo
  1255  
  1256  func (m *ScaleSpec) Reset()      { *m = ScaleSpec{} }
  1257  func (*ScaleSpec) ProtoMessage() {}
  1258  func (*ScaleSpec) Descriptor() ([]byte, []int) {
  1259  	return fileDescriptor_90a532284de28347, []int{43}
  1260  }
  1261  func (m *ScaleSpec) XXX_Unmarshal(b []byte) error {
  1262  	return m.Unmarshal(b)
  1263  }
  1264  func (m *ScaleSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  1265  	b = b[:cap(b)]
  1266  	n, err := m.MarshalToSizedBuffer(b)
  1267  	if err != nil {
  1268  		return nil, err
  1269  	}
  1270  	return b[:n], nil
  1271  }
  1272  func (m *ScaleSpec) XXX_Merge(src proto.Message) {
  1273  	xxx_messageInfo_ScaleSpec.Merge(m, src)
  1274  }
  1275  func (m *ScaleSpec) XXX_Size() int {
  1276  	return m.Size()
  1277  }
  1278  func (m *ScaleSpec) XXX_DiscardUnknown() {
  1279  	xxx_messageInfo_ScaleSpec.DiscardUnknown(m)
  1280  }
  1281  
  1282  var xxx_messageInfo_ScaleSpec proto.InternalMessageInfo
  1283  
  1284  func (m *ScaleStatus) Reset()      { *m = ScaleStatus{} }
  1285  func (*ScaleStatus) ProtoMessage() {}
  1286  func (*ScaleStatus) Descriptor() ([]byte, []int) {
  1287  	return fileDescriptor_90a532284de28347, []int{44}
  1288  }
  1289  func (m *ScaleStatus) XXX_Unmarshal(b []byte) error {
  1290  	return m.Unmarshal(b)
  1291  }
  1292  func (m *ScaleStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  1293  	b = b[:cap(b)]
  1294  	n, err := m.MarshalToSizedBuffer(b)
  1295  	if err != nil {
  1296  		return nil, err
  1297  	}
  1298  	return b[:n], nil
  1299  }
  1300  func (m *ScaleStatus) XXX_Merge(src proto.Message) {
  1301  	xxx_messageInfo_ScaleStatus.Merge(m, src)
  1302  }
  1303  func (m *ScaleStatus) XXX_Size() int {
  1304  	return m.Size()
  1305  }
  1306  func (m *ScaleStatus) XXX_DiscardUnknown() {
  1307  	xxx_messageInfo_ScaleStatus.DiscardUnknown(m)
  1308  }
  1309  
  1310  var xxx_messageInfo_ScaleStatus proto.InternalMessageInfo
  1311  
  1312  func init() {
  1313  	proto.RegisterType((*DaemonSet)(nil), "k8s.io.api.extensions.v1beta1.DaemonSet")
  1314  	proto.RegisterType((*DaemonSetCondition)(nil), "k8s.io.api.extensions.v1beta1.DaemonSetCondition")
  1315  	proto.RegisterType((*DaemonSetList)(nil), "k8s.io.api.extensions.v1beta1.DaemonSetList")
  1316  	proto.RegisterType((*DaemonSetSpec)(nil), "k8s.io.api.extensions.v1beta1.DaemonSetSpec")
  1317  	proto.RegisterType((*DaemonSetStatus)(nil), "k8s.io.api.extensions.v1beta1.DaemonSetStatus")
  1318  	proto.RegisterType((*DaemonSetUpdateStrategy)(nil), "k8s.io.api.extensions.v1beta1.DaemonSetUpdateStrategy")
  1319  	proto.RegisterType((*Deployment)(nil), "k8s.io.api.extensions.v1beta1.Deployment")
  1320  	proto.RegisterType((*DeploymentCondition)(nil), "k8s.io.api.extensions.v1beta1.DeploymentCondition")
  1321  	proto.RegisterType((*DeploymentList)(nil), "k8s.io.api.extensions.v1beta1.DeploymentList")
  1322  	proto.RegisterType((*DeploymentRollback)(nil), "k8s.io.api.extensions.v1beta1.DeploymentRollback")
  1323  	proto.RegisterMapType((map[string]string)(nil), "k8s.io.api.extensions.v1beta1.DeploymentRollback.UpdatedAnnotationsEntry")
  1324  	proto.RegisterType((*DeploymentSpec)(nil), "k8s.io.api.extensions.v1beta1.DeploymentSpec")
  1325  	proto.RegisterType((*DeploymentStatus)(nil), "k8s.io.api.extensions.v1beta1.DeploymentStatus")
  1326  	proto.RegisterType((*DeploymentStrategy)(nil), "k8s.io.api.extensions.v1beta1.DeploymentStrategy")
  1327  	proto.RegisterType((*HTTPIngressPath)(nil), "k8s.io.api.extensions.v1beta1.HTTPIngressPath")
  1328  	proto.RegisterType((*HTTPIngressRuleValue)(nil), "k8s.io.api.extensions.v1beta1.HTTPIngressRuleValue")
  1329  	proto.RegisterType((*IPBlock)(nil), "k8s.io.api.extensions.v1beta1.IPBlock")
  1330  	proto.RegisterType((*Ingress)(nil), "k8s.io.api.extensions.v1beta1.Ingress")
  1331  	proto.RegisterType((*IngressBackend)(nil), "k8s.io.api.extensions.v1beta1.IngressBackend")
  1332  	proto.RegisterType((*IngressList)(nil), "k8s.io.api.extensions.v1beta1.IngressList")
  1333  	proto.RegisterType((*IngressLoadBalancerIngress)(nil), "k8s.io.api.extensions.v1beta1.IngressLoadBalancerIngress")
  1334  	proto.RegisterType((*IngressLoadBalancerStatus)(nil), "k8s.io.api.extensions.v1beta1.IngressLoadBalancerStatus")
  1335  	proto.RegisterType((*IngressPortStatus)(nil), "k8s.io.api.extensions.v1beta1.IngressPortStatus")
  1336  	proto.RegisterType((*IngressRule)(nil), "k8s.io.api.extensions.v1beta1.IngressRule")
  1337  	proto.RegisterType((*IngressRuleValue)(nil), "k8s.io.api.extensions.v1beta1.IngressRuleValue")
  1338  	proto.RegisterType((*IngressSpec)(nil), "k8s.io.api.extensions.v1beta1.IngressSpec")
  1339  	proto.RegisterType((*IngressStatus)(nil), "k8s.io.api.extensions.v1beta1.IngressStatus")
  1340  	proto.RegisterType((*IngressTLS)(nil), "k8s.io.api.extensions.v1beta1.IngressTLS")
  1341  	proto.RegisterType((*NetworkPolicy)(nil), "k8s.io.api.extensions.v1beta1.NetworkPolicy")
  1342  	proto.RegisterType((*NetworkPolicyEgressRule)(nil), "k8s.io.api.extensions.v1beta1.NetworkPolicyEgressRule")
  1343  	proto.RegisterType((*NetworkPolicyIngressRule)(nil), "k8s.io.api.extensions.v1beta1.NetworkPolicyIngressRule")
  1344  	proto.RegisterType((*NetworkPolicyList)(nil), "k8s.io.api.extensions.v1beta1.NetworkPolicyList")
  1345  	proto.RegisterType((*NetworkPolicyPeer)(nil), "k8s.io.api.extensions.v1beta1.NetworkPolicyPeer")
  1346  	proto.RegisterType((*NetworkPolicyPort)(nil), "k8s.io.api.extensions.v1beta1.NetworkPolicyPort")
  1347  	proto.RegisterType((*NetworkPolicySpec)(nil), "k8s.io.api.extensions.v1beta1.NetworkPolicySpec")
  1348  	proto.RegisterType((*ReplicaSet)(nil), "k8s.io.api.extensions.v1beta1.ReplicaSet")
  1349  	proto.RegisterType((*ReplicaSetCondition)(nil), "k8s.io.api.extensions.v1beta1.ReplicaSetCondition")
  1350  	proto.RegisterType((*ReplicaSetList)(nil), "k8s.io.api.extensions.v1beta1.ReplicaSetList")
  1351  	proto.RegisterType((*ReplicaSetSpec)(nil), "k8s.io.api.extensions.v1beta1.ReplicaSetSpec")
  1352  	proto.RegisterType((*ReplicaSetStatus)(nil), "k8s.io.api.extensions.v1beta1.ReplicaSetStatus")
  1353  	proto.RegisterType((*RollbackConfig)(nil), "k8s.io.api.extensions.v1beta1.RollbackConfig")
  1354  	proto.RegisterType((*RollingUpdateDaemonSet)(nil), "k8s.io.api.extensions.v1beta1.RollingUpdateDaemonSet")
  1355  	proto.RegisterType((*RollingUpdateDeployment)(nil), "k8s.io.api.extensions.v1beta1.RollingUpdateDeployment")
  1356  	proto.RegisterType((*Scale)(nil), "k8s.io.api.extensions.v1beta1.Scale")
  1357  	proto.RegisterType((*ScaleSpec)(nil), "k8s.io.api.extensions.v1beta1.ScaleSpec")
  1358  	proto.RegisterType((*ScaleStatus)(nil), "k8s.io.api.extensions.v1beta1.ScaleStatus")
  1359  	proto.RegisterMapType((map[string]string)(nil), "k8s.io.api.extensions.v1beta1.ScaleStatus.SelectorEntry")
  1360  }
  1361  
  1362  func init() {
  1363  	proto.RegisterFile("k8s.io/api/extensions/v1beta1/generated.proto", fileDescriptor_90a532284de28347)
  1364  }
  1365  
  1366  var fileDescriptor_90a532284de28347 = []byte{
  1367  	// 2842 bytes of a gzipped FileDescriptorProto
  1368  	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x5b, 0xcd, 0x6f, 0x24, 0x47,
  1369  	0x15, 0xdf, 0x9e, 0xf1, 0xd8, 0xe3, 0xe7, 0xb5, 0xbd, 0x5b, 0xeb, 0xac, 0x1d, 0x2f, 0xb1, 0xa3,
  1370  	0x46, 0x84, 0x4d, 0xd8, 0x9d, 0x61, 0x37, 0xc9, 0x92, 0x0f, 0x29, 0x61, 0xc7, 0xbb, 0xc9, 0x3a,
  1371  	0xb1, 0xc7, 0x93, 0x9a, 0x71, 0x82, 0x22, 0x02, 0xb4, 0x7b, 0xca, 0xe3, 0x8e, 0x7b, 0xba, 0x47,
  1372  	0xdd, 0x35, 0x66, 0x7d, 0x03, 0xc1, 0x25, 0x27, 0xb8, 0x04, 0x38, 0x22, 0x21, 0x71, 0xe5, 0xca,
  1373  	0x21, 0x44, 0x20, 0x82, 0xb4, 0x42, 0x1c, 0x22, 0x71, 0x20, 0x27, 0x8b, 0x38, 0x27, 0xc4, 0x3f,
  1374  	0x80, 0xf6, 0x84, 0xea, 0xa3, 0xab, 0xbf, 0xed, 0x1e, 0xe3, 0x58, 0x04, 0x71, 0x5a, 0x4f, 0xbd,
  1375  	0xf7, 0x7e, 0xf5, 0xaa, 0xea, 0xd5, 0x7b, 0xbf, 0xaa, 0xea, 0x85, 0xeb, 0xbb, 0xcf, 0xf9, 0x35,
  1376  	0xcb, 0xad, 0x1b, 0x03, 0xab, 0x4e, 0xee, 0x53, 0xe2, 0xf8, 0x96, 0xeb, 0xf8, 0xf5, 0xbd, 0x1b,
  1377  	0x5b, 0x84, 0x1a, 0x37, 0xea, 0x3d, 0xe2, 0x10, 0xcf, 0xa0, 0xa4, 0x5b, 0x1b, 0x78, 0x2e, 0x75,
  1378  	0xd1, 0x63, 0x42, 0xbd, 0x66, 0x0c, 0xac, 0x5a, 0xa8, 0x5e, 0x93, 0xea, 0x8b, 0xd7, 0x7b, 0x16,
  1379  	0xdd, 0x19, 0x6e, 0xd5, 0x4c, 0xb7, 0x5f, 0xef, 0xb9, 0x3d, 0xb7, 0xce, 0xad, 0xb6, 0x86, 0xdb,
  1380  	0xfc, 0x17, 0xff, 0xc1, 0xff, 0x12, 0x68, 0x8b, 0x7a, 0xa4, 0x73, 0xd3, 0xf5, 0x48, 0x7d, 0x2f,
  1381  	0xd5, 0xe3, 0xe2, 0x33, 0xa1, 0x4e, 0xdf, 0x30, 0x77, 0x2c, 0x87, 0x78, 0xfb, 0xf5, 0xc1, 0x6e,
  1382  	0x8f, 0x35, 0xf8, 0xf5, 0x3e, 0xa1, 0x46, 0x96, 0x55, 0x3d, 0xcf, 0xca, 0x1b, 0x3a, 0xd4, 0xea,
  1383  	0x93, 0x94, 0xc1, 0xad, 0xe3, 0x0c, 0x7c, 0x73, 0x87, 0xf4, 0x8d, 0x94, 0xdd, 0xd3, 0x79, 0x76,
  1384  	0x43, 0x6a, 0xd9, 0x75, 0xcb, 0xa1, 0x3e, 0xf5, 0x92, 0x46, 0xfa, 0xfb, 0x25, 0x98, 0xbc, 0x63,
  1385  	0x90, 0xbe, 0xeb, 0xb4, 0x09, 0x45, 0xdf, 0x83, 0x2a, 0x1b, 0x46, 0xd7, 0xa0, 0xc6, 0x82, 0xf6,
  1386  	0xb8, 0x76, 0x75, 0xea, 0xe6, 0xd7, 0x6b, 0xe1, 0x34, 0x2b, 0xd4, 0xda, 0x60, 0xb7, 0xc7, 0x1a,
  1387  	0xfc, 0x1a, 0xd3, 0xae, 0xed, 0xdd, 0xa8, 0x6d, 0x6c, 0xbd, 0x4b, 0x4c, 0xba, 0x4e, 0xa8, 0xd1,
  1388  	0x40, 0x0f, 0x0e, 0x96, 0xcf, 0x1d, 0x1e, 0x2c, 0x43, 0xd8, 0x86, 0x15, 0x2a, 0x6a, 0xc2, 0x98,
  1389  	0x3f, 0x20, 0xe6, 0x42, 0x89, 0xa3, 0x5f, 0xab, 0x1d, 0xb9, 0x88, 0x35, 0xe5, 0x59, 0x7b, 0x40,
  1390  	0xcc, 0xc6, 0x79, 0x89, 0x3c, 0xc6, 0x7e, 0x61, 0x8e, 0x83, 0xde, 0x84, 0x71, 0x9f, 0x1a, 0x74,
  1391  	0xe8, 0x2f, 0x94, 0x39, 0x62, 0xad, 0x30, 0x22, 0xb7, 0x6a, 0xcc, 0x48, 0xcc, 0x71, 0xf1, 0x1b,
  1392  	0x4b, 0x34, 0xfd, 0x1f, 0x25, 0x40, 0x4a, 0x77, 0xc5, 0x75, 0xba, 0x16, 0xb5, 0x5c, 0x07, 0xbd,
  1393  	0x00, 0x63, 0x74, 0x7f, 0x40, 0xf8, 0xe4, 0x4c, 0x36, 0x9e, 0x08, 0x1c, 0xea, 0xec, 0x0f, 0xc8,
  1394  	0xc3, 0x83, 0xe5, 0xcb, 0x69, 0x0b, 0x26, 0xc1, 0xdc, 0x06, 0xad, 0x29, 0x57, 0x4b, 0xdc, 0xfa,
  1395  	0x99, 0x78, 0xd7, 0x0f, 0x0f, 0x96, 0x33, 0x82, 0xb0, 0xa6, 0x90, 0xe2, 0x0e, 0xa2, 0x3d, 0x40,
  1396  	0xb6, 0xe1, 0xd3, 0x8e, 0x67, 0x38, 0xbe, 0xe8, 0xc9, 0xea, 0x13, 0x39, 0x09, 0x4f, 0x15, 0x5b,
  1397  	0x34, 0x66, 0xd1, 0x58, 0x94, 0x5e, 0xa0, 0xb5, 0x14, 0x1a, 0xce, 0xe8, 0x01, 0x3d, 0x01, 0xe3,
  1398  	0x1e, 0x31, 0x7c, 0xd7, 0x59, 0x18, 0xe3, 0xa3, 0x50, 0x13, 0x88, 0x79, 0x2b, 0x96, 0x52, 0xf4,
  1399  	0x24, 0x4c, 0xf4, 0x89, 0xef, 0x1b, 0x3d, 0xb2, 0x50, 0xe1, 0x8a, 0xb3, 0x52, 0x71, 0x62, 0x5d,
  1400  	0x34, 0xe3, 0x40, 0xae, 0x7f, 0xa0, 0xc1, 0xb4, 0x9a, 0xb9, 0x35, 0xcb, 0xa7, 0xe8, 0xdb, 0xa9,
  1401  	0x38, 0xac, 0x15, 0x1b, 0x12, 0xb3, 0xe6, 0x51, 0x78, 0x41, 0xf6, 0x56, 0x0d, 0x5a, 0x22, 0x31,
  1402  	0xb8, 0x0e, 0x15, 0x8b, 0x92, 0x3e, 0x5b, 0x87, 0xf2, 0xd5, 0xa9, 0x9b, 0x57, 0x8b, 0x86, 0x4c,
  1403  	0x63, 0x5a, 0x82, 0x56, 0x56, 0x99, 0x39, 0x16, 0x28, 0xfa, 0xcf, 0xc6, 0x22, 0xee, 0xb3, 0xd0,
  1404  	0x44, 0xef, 0x40, 0xd5, 0x27, 0x36, 0x31, 0xa9, 0xeb, 0x49, 0xf7, 0x9f, 0x2e, 0xe8, 0xbe, 0xb1,
  1405  	0x45, 0xec, 0xb6, 0x34, 0x6d, 0x9c, 0x67, 0xfe, 0x07, 0xbf, 0xb0, 0x82, 0x44, 0x6f, 0x40, 0x95,
  1406  	0x92, 0xfe, 0xc0, 0x36, 0x28, 0x91, 0xfb, 0xe8, 0xcb, 0xd1, 0x21, 0xb0, 0xc8, 0x61, 0x60, 0x2d,
  1407  	0xb7, 0xdb, 0x91, 0x6a, 0x7c, 0xfb, 0xa8, 0x29, 0x09, 0x5a, 0xb1, 0x82, 0x41, 0x7b, 0x30, 0x33,
  1408  	0x1c, 0x74, 0x99, 0x26, 0x65, 0xd9, 0xa1, 0xb7, 0x2f, 0x23, 0xe9, 0x56, 0xd1, 0xb9, 0xd9, 0x8c,
  1409  	0x59, 0x37, 0x2e, 0xcb, 0xbe, 0x66, 0xe2, 0xed, 0x38, 0xd1, 0x0b, 0xba, 0x0d, 0xb3, 0x7d, 0xcb,
  1410  	0xc1, 0xc4, 0xe8, 0xee, 0xb7, 0x89, 0xe9, 0x3a, 0x5d, 0x9f, 0x87, 0x55, 0xa5, 0x31, 0x2f, 0x01,
  1411  	0x66, 0xd7, 0xe3, 0x62, 0x9c, 0xd4, 0x47, 0xaf, 0x01, 0x0a, 0x86, 0xf1, 0xaa, 0x48, 0x6e, 0x96,
  1412  	0xeb, 0xf0, 0x98, 0x2b, 0x87, 0xc1, 0xdd, 0x49, 0x69, 0xe0, 0x0c, 0x2b, 0xb4, 0x06, 0x73, 0x1e,
  1413  	0xd9, 0xb3, 0xd8, 0x18, 0xef, 0x59, 0x3e, 0x75, 0xbd, 0xfd, 0x35, 0xab, 0x6f, 0xd1, 0x85, 0x71,
  1414  	0xee, 0xd3, 0xc2, 0xe1, 0xc1, 0xf2, 0x1c, 0xce, 0x90, 0xe3, 0x4c, 0x2b, 0xfd, 0xe7, 0xe3, 0x30,
  1415  	0x9b, 0xc8, 0x37, 0xe8, 0x4d, 0xb8, 0x6c, 0x0e, 0x3d, 0x8f, 0x38, 0xb4, 0x39, 0xec, 0x6f, 0x11,
  1416  	0xaf, 0x6d, 0xee, 0x90, 0xee, 0xd0, 0x26, 0x5d, 0x1e, 0x28, 0x95, 0xc6, 0x92, 0xf4, 0xf8, 0xf2,
  1417  	0x4a, 0xa6, 0x16, 0xce, 0xb1, 0x66, 0xb3, 0xe0, 0xf0, 0xa6, 0x75, 0xcb, 0xf7, 0x15, 0x66, 0x89,
  1418  	0x63, 0xaa, 0x59, 0x68, 0xa6, 0x34, 0x70, 0x86, 0x15, 0xf3, 0xb1, 0x4b, 0x7c, 0xcb, 0x23, 0xdd,
  1419  	0xa4, 0x8f, 0xe5, 0xb8, 0x8f, 0x77, 0x32, 0xb5, 0x70, 0x8e, 0x35, 0x7a, 0x16, 0xa6, 0x44, 0x6f,
  1420  	0x7c, 0xfd, 0xe4, 0x42, 0x5f, 0x92, 0x60, 0x53, 0xcd, 0x50, 0x84, 0xa3, 0x7a, 0x6c, 0x68, 0xee,
  1421  	0x96, 0x4f, 0xbc, 0x3d, 0xd2, 0xcd, 0x5f, 0xe0, 0x8d, 0x94, 0x06, 0xce, 0xb0, 0x62, 0x43, 0x13,
  1422  	0x11, 0x98, 0x1a, 0xda, 0x78, 0x7c, 0x68, 0x9b, 0x99, 0x5a, 0x38, 0xc7, 0x9a, 0xc5, 0xb1, 0x70,
  1423  	0xf9, 0xf6, 0x9e, 0x61, 0xd9, 0xc6, 0x96, 0x4d, 0x16, 0x26, 0xe2, 0x71, 0xdc, 0x8c, 0x8b, 0x71,
  1424  	0x52, 0x1f, 0xbd, 0x0a, 0x17, 0x45, 0xd3, 0xa6, 0x63, 0x28, 0x90, 0x2a, 0x07, 0x79, 0x54, 0x82,
  1425  	0x5c, 0x6c, 0x26, 0x15, 0x70, 0xda, 0x06, 0xbd, 0x00, 0x33, 0xa6, 0x6b, 0xdb, 0x3c, 0x1e, 0x57,
  1426  	0xdc, 0xa1, 0x43, 0x17, 0x26, 0x39, 0x0a, 0x62, 0xfb, 0x71, 0x25, 0x26, 0xc1, 0x09, 0x4d, 0x44,
  1427  	0x00, 0xcc, 0xa0, 0xe0, 0xf8, 0x0b, 0xc0, 0xf3, 0xe3, 0x8d, 0xa2, 0x39, 0x40, 0x95, 0xaa, 0x90,
  1428  	0x03, 0xa8, 0x26, 0x1f, 0x47, 0x80, 0xf5, 0x3f, 0x6b, 0x30, 0x9f, 0x93, 0x3a, 0xd0, 0xcb, 0xb1,
  1429  	0x12, 0xfb, 0xb5, 0x44, 0x89, 0xbd, 0x92, 0x63, 0x16, 0xa9, 0xb3, 0x0e, 0x4c, 0x7b, 0x6c, 0x54,
  1430  	0x4e, 0x4f, 0xa8, 0xc8, 0x1c, 0xf9, 0xec, 0x31, 0xc3, 0xc0, 0x51, 0x9b, 0x30, 0xe7, 0x5f, 0x3c,
  1431  	0x3c, 0x58, 0x9e, 0x8e, 0xc9, 0x70, 0x1c, 0x5e, 0xff, 0x45, 0x09, 0xe0, 0x0e, 0x19, 0xd8, 0xee,
  1432  	0x7e, 0x9f, 0x38, 0x67, 0xc1, 0xa1, 0x36, 0x62, 0x1c, 0xea, 0xfa, 0x71, 0xcb, 0xa3, 0x5c, 0xcb,
  1433  	0x25, 0x51, 0x6f, 0x25, 0x48, 0x54, 0xbd, 0x38, 0xe4, 0xd1, 0x2c, 0xea, 0x6f, 0x65, 0xb8, 0x14,
  1434  	0x2a, 0x87, 0x34, 0xea, 0xc5, 0xd8, 0x1a, 0x7f, 0x35, 0xb1, 0xc6, 0xf3, 0x19, 0x26, 0x9f, 0x1b,
  1435  	0x8f, 0x7a, 0x17, 0x66, 0x18, 0xcb, 0x11, 0x6b, 0xc9, 0x39, 0xd4, 0xf8, 0xc8, 0x1c, 0x4a, 0x55,
  1436  	0xbb, 0xb5, 0x18, 0x12, 0x4e, 0x20, 0xe7, 0x70, 0xb6, 0x89, 0x2f, 0x22, 0x67, 0xfb, 0x50, 0x83,
  1437  	0x99, 0x70, 0x99, 0xce, 0x80, 0xb4, 0x35, 0xe3, 0xa4, 0xed, 0xc9, 0xc2, 0x21, 0x9a, 0xc3, 0xda,
  1438  	0xfe, 0xc5, 0x08, 0xbe, 0x52, 0x62, 0x1b, 0x7c, 0xcb, 0x30, 0x77, 0xd1, 0xe3, 0x30, 0xe6, 0x18,
  1439  	0xfd, 0x20, 0x32, 0xd5, 0x66, 0x69, 0x1a, 0x7d, 0x82, 0xb9, 0x04, 0xbd, 0xaf, 0x01, 0x92, 0x55,
  1440  	0xe0, 0xb6, 0xe3, 0xb8, 0xd4, 0x10, 0xb9, 0x52, 0xb8, 0xb5, 0x5a, 0xd8, 0xad, 0xa0, 0xc7, 0xda,
  1441  	0x66, 0x0a, 0xeb, 0xae, 0x43, 0xbd, 0xfd, 0x70, 0x91, 0xd3, 0x0a, 0x38, 0xc3, 0x01, 0x64, 0x00,
  1442  	0x78, 0x12, 0xb3, 0xe3, 0xca, 0x8d, 0x7c, 0xbd, 0x40, 0xce, 0x63, 0x06, 0x2b, 0xae, 0xb3, 0x6d,
  1443  	0xf5, 0xc2, 0xb4, 0x83, 0x15, 0x10, 0x8e, 0x80, 0x2e, 0xde, 0x85, 0xf9, 0x1c, 0x6f, 0xd1, 0x05,
  1444  	0x28, 0xef, 0x92, 0x7d, 0x31, 0x6d, 0x98, 0xfd, 0x89, 0xe6, 0xa0, 0xb2, 0x67, 0xd8, 0x43, 0x91,
  1445  	0x7e, 0x27, 0xb1, 0xf8, 0xf1, 0x42, 0xe9, 0x39, 0x4d, 0xff, 0xa0, 0x12, 0x8d, 0x1d, 0xce, 0x98,
  1446  	0xaf, 0x42, 0xd5, 0x23, 0x03, 0xdb, 0x32, 0x0d, 0x5f, 0x12, 0x21, 0x4e, 0x7e, 0xb1, 0x6c, 0xc3,
  1447  	0x4a, 0x1a, 0xe3, 0xd6, 0xa5, 0xcf, 0x97, 0x5b, 0x97, 0x4f, 0x87, 0x5b, 0x7f, 0x17, 0xaa, 0x7e,
  1448  	0xc0, 0xaa, 0xc7, 0x38, 0xe4, 0x8d, 0x11, 0xf2, 0xab, 0x24, 0xd4, 0xaa, 0x03, 0x45, 0xa5, 0x15,
  1449  	0x68, 0x16, 0x89, 0xae, 0x8c, 0x48, 0xa2, 0x4f, 0x95, 0xf8, 0xb2, 0x7c, 0x33, 0x30, 0x86, 0x3e,
  1450  	0xe9, 0xf2, 0xdc, 0x56, 0x0d, 0xf3, 0x4d, 0x8b, 0xb7, 0x62, 0x29, 0x45, 0xef, 0xc4, 0x42, 0xb6,
  1451  	0x7a, 0x92, 0x90, 0x9d, 0xc9, 0x0f, 0x57, 0xb4, 0x09, 0xf3, 0x03, 0xcf, 0xed, 0x79, 0xc4, 0xf7,
  1452  	0xef, 0x10, 0xa3, 0x6b, 0x5b, 0x0e, 0x09, 0xe6, 0x47, 0x30, 0xa2, 0x2b, 0x87, 0x07, 0xcb, 0xf3,
  1453  	0xad, 0x6c, 0x15, 0x9c, 0x67, 0xab, 0x3f, 0x18, 0x83, 0x0b, 0xc9, 0x0a, 0x98, 0x43, 0x52, 0xb5,
  1454  	0x13, 0x91, 0xd4, 0x6b, 0x91, 0xcd, 0x20, 0x18, 0xbc, 0x5a, 0xfd, 0x8c, 0x0d, 0x71, 0x1b, 0x66,
  1455  	0x65, 0x36, 0x08, 0x84, 0x92, 0xa6, 0xab, 0xd5, 0xdf, 0x8c, 0x8b, 0x71, 0x52, 0x1f, 0xbd, 0x08,
  1456  	0xd3, 0x1e, 0xe7, 0xdd, 0x01, 0x80, 0xe0, 0xae, 0x8f, 0x48, 0x80, 0x69, 0x1c, 0x15, 0xe2, 0xb8,
  1457  	0x2e, 0xe3, 0xad, 0x21, 0x1d, 0x0d, 0x00, 0xc6, 0xe2, 0xbc, 0xf5, 0x76, 0x52, 0x01, 0xa7, 0x6d,
  1458  	0xd0, 0x3a, 0x5c, 0x1a, 0x3a, 0x69, 0x28, 0x11, 0xca, 0x57, 0x24, 0xd4, 0xa5, 0xcd, 0xb4, 0x0a,
  1459  	0xce, 0xb2, 0x43, 0xdb, 0x31, 0x2a, 0x3b, 0xce, 0xd3, 0xf3, 0xcd, 0xc2, 0x1b, 0xaf, 0x30, 0x97,
  1460  	0xcd, 0xa0, 0xdb, 0xd5, 0xa2, 0x74, 0x5b, 0xff, 0x83, 0x16, 0x2d, 0x42, 0x8a, 0x02, 0x1f, 0x77,
  1461  	0xcb, 0x94, 0xb2, 0x88, 0xb0, 0x23, 0x37, 0x9b, 0xfd, 0xde, 0x1a, 0x89, 0xfd, 0x86, 0xc5, 0xf3,
  1462  	0x78, 0xfa, 0xfb, 0x47, 0x0d, 0x66, 0xef, 0x75, 0x3a, 0xad, 0x55, 0x87, 0xef, 0x96, 0x96, 0x41,
  1463  	0x77, 0x58, 0x15, 0x1d, 0x18, 0x74, 0x27, 0x59, 0x45, 0x99, 0x0c, 0x73, 0x09, 0x7a, 0x06, 0xaa,
  1464  	0xec, 0x5f, 0xe6, 0x38, 0x0f, 0xd7, 0x49, 0x9e, 0x64, 0xaa, 0x2d, 0xd9, 0xf6, 0x30, 0xf2, 0x37,
  1465  	0x56, 0x9a, 0xe8, 0x5b, 0x30, 0xc1, 0xf6, 0x36, 0x71, 0xba, 0x05, 0xc9, 0xaf, 0x74, 0xaa, 0x21,
  1466  	0x8c, 0x42, 0x3e, 0x23, 0x1b, 0x70, 0x00, 0xa7, 0xef, 0xc2, 0x5c, 0x64, 0x10, 0x78, 0x68, 0x93,
  1467  	0x37, 0x59, 0xbd, 0x42, 0x6d, 0xa8, 0xb0, 0xde, 0x59, 0x55, 0x2a, 0x17, 0xb8, 0x5e, 0x4c, 0x4c,
  1468  	0x44, 0xc8, 0x3d, 0xd8, 0x2f, 0x1f, 0x0b, 0x2c, 0x7d, 0x03, 0x26, 0x56, 0x5b, 0x0d, 0xdb, 0x15,
  1469  	0x7c, 0xc3, 0xb4, 0xba, 0x5e, 0x72, 0xa6, 0x56, 0x56, 0xef, 0x60, 0xcc, 0x25, 0x48, 0x87, 0x71,
  1470  	0x72, 0xdf, 0x24, 0x03, 0xca, 0x29, 0xc6, 0x64, 0x03, 0x58, 0x22, 0xbd, 0xcb, 0x5b, 0xb0, 0x94,
  1471  	0xe8, 0x3f, 0x29, 0xc1, 0x84, 0xec, 0xf6, 0x0c, 0xce, 0x1f, 0x6b, 0xb1, 0xf3, 0xc7, 0x53, 0xc5,
  1472  	0x96, 0x20, 0xf7, 0xf0, 0xd1, 0x49, 0x1c, 0x3e, 0xae, 0x15, 0xc4, 0x3b, 0xfa, 0xe4, 0xf1, 0x5e,
  1473  	0x09, 0x66, 0xe2, 0x8b, 0x8f, 0x9e, 0x85, 0x29, 0x96, 0x6a, 0x2d, 0x93, 0x34, 0x43, 0x86, 0xa7,
  1474  	0xae, 0x1f, 0xda, 0xa1, 0x08, 0x47, 0xf5, 0x50, 0x4f, 0x99, 0xb5, 0x5c, 0x8f, 0xca, 0x41, 0xe7,
  1475  	0x4f, 0xe9, 0x90, 0x5a, 0x76, 0x4d, 0x5c, 0xb6, 0xd7, 0x56, 0x1d, 0xba, 0xe1, 0xb5, 0xa9, 0x67,
  1476  	0x39, 0xbd, 0x54, 0x47, 0x0c, 0x0c, 0x47, 0x91, 0xd1, 0x5b, 0x2c, 0xed, 0xfb, 0xee, 0xd0, 0x33,
  1477  	0x49, 0x16, 0x7d, 0x0b, 0xa8, 0x07, 0xdb, 0x08, 0xdd, 0x35, 0xd7, 0x34, 0x6c, 0xb1, 0x38, 0x98,
  1478  	0x6c, 0x13, 0x8f, 0x38, 0x26, 0x09, 0x28, 0x93, 0x80, 0xc0, 0x0a, 0x4c, 0xff, 0xad, 0x06, 0x53,
  1479  	0x72, 0x2e, 0xce, 0x80, 0xa8, 0xbf, 0x1e, 0x27, 0xea, 0x4f, 0x14, 0xdc, 0xa1, 0xd9, 0x2c, 0xfd,
  1480  	0x77, 0x1a, 0x2c, 0x06, 0xae, 0xbb, 0x46, 0xb7, 0x61, 0xd8, 0x86, 0x63, 0x12, 0x2f, 0x88, 0xf5,
  1481  	0x45, 0x28, 0x59, 0x03, 0xb9, 0x92, 0x20, 0x01, 0x4a, 0xab, 0x2d, 0x5c, 0xb2, 0x06, 0xac, 0x8a,
  1482  	0xee, 0xb8, 0x3e, 0xe5, 0x6c, 0x5e, 0x1c, 0x14, 0x95, 0xd7, 0xf7, 0x64, 0x3b, 0x56, 0x1a, 0x68,
  1483  	0x13, 0x2a, 0x03, 0xd7, 0xa3, 0xac, 0x72, 0x95, 0x13, 0xeb, 0x7b, 0x84, 0xd7, 0x6c, 0xdd, 0x64,
  1484  	0x20, 0x86, 0x3b, 0x9d, 0xc1, 0x60, 0x81, 0xa6, 0xff, 0x50, 0x83, 0x47, 0x33, 0xfc, 0x97, 0xa4,
  1485  	0xa1, 0x0b, 0x13, 0x96, 0x10, 0xca, 0xf4, 0xf2, 0x7c, 0xb1, 0x6e, 0x33, 0xa6, 0x22, 0x4c, 0x6d,
  1486  	0x41, 0x0a, 0x0b, 0xa0, 0xf5, 0x5f, 0x69, 0x70, 0x31, 0xe5, 0x2f, 0x4f, 0xd1, 0x2c, 0x9e, 0x25,
  1487  	0xdb, 0x56, 0x29, 0x9a, 0x85, 0x25, 0x97, 0xa0, 0xd7, 0xa1, 0xca, 0xdf, 0x88, 0x4c, 0xd7, 0x96,
  1488  	0x13, 0x58, 0x0f, 0x26, 0xb0, 0x25, 0xdb, 0x1f, 0x1e, 0x2c, 0x5f, 0xc9, 0x38, 0x6b, 0x07, 0x62,
  1489  	0xac, 0x00, 0xd0, 0x32, 0x54, 0x88, 0xe7, 0xb9, 0x9e, 0x4c, 0xf6, 0x93, 0x6c, 0xa6, 0xee, 0xb2,
  1490  	0x06, 0x2c, 0xda, 0xf5, 0x5f, 0x87, 0x41, 0xca, 0xb2, 0x2f, 0xf3, 0x8f, 0x2d, 0x4e, 0x32, 0x31,
  1491  	0xb2, 0xa5, 0xc3, 0x5c, 0x82, 0x86, 0x70, 0xc1, 0x4a, 0xa4, 0x6b, 0xb9, 0x3b, 0xeb, 0xc5, 0xa6,
  1492  	0x51, 0x99, 0x35, 0x16, 0x24, 0xfc, 0x85, 0xa4, 0x04, 0xa7, 0xba, 0xd0, 0x09, 0xa4, 0xb4, 0xd0,
  1493  	0x1b, 0x30, 0xb6, 0x43, 0xe9, 0x20, 0xe3, 0xb2, 0xff, 0x98, 0x22, 0x11, 0xba, 0x50, 0xe5, 0xa3,
  1494  	0xeb, 0x74, 0x5a, 0x98, 0x43, 0xe9, 0xbf, 0x2f, 0xa9, 0xf9, 0xe0, 0x27, 0xa4, 0x6f, 0xaa, 0xd1,
  1495  	0xae, 0xd8, 0x86, 0xef, 0xf3, 0x14, 0x26, 0x4e, 0xf3, 0x73, 0x11, 0xc7, 0x95, 0x0c, 0xa7, 0xb4,
  1496  	0x51, 0x27, 0x2c, 0x9e, 0xda, 0x49, 0x8a, 0xe7, 0x54, 0x56, 0xe1, 0x44, 0xf7, 0xa0, 0x4c, 0xed,
  1497  	0xa2, 0xa7, 0x72, 0x89, 0xd8, 0x59, 0x6b, 0x37, 0xa6, 0xe4, 0x94, 0x97, 0x3b, 0x6b, 0x6d, 0xcc,
  1498  	0x20, 0xd0, 0x06, 0x54, 0xbc, 0xa1, 0x4d, 0x58, 0x1d, 0x28, 0x17, 0xaf, 0x2b, 0x6c, 0x06, 0xc3,
  1499  	0xcd, 0xc7, 0x7e, 0xf9, 0x58, 0xe0, 0xe8, 0x3f, 0xd2, 0x60, 0x3a, 0x56, 0x2d, 0x90, 0x07, 0xe7,
  1500  	0xed, 0xc8, 0xde, 0x91, 0xf3, 0xf0, 0xdc, 0xe8, 0xbb, 0x4e, 0x6e, 0xfa, 0x39, 0xd9, 0xef, 0xf9,
  1501  	0xa8, 0x0c, 0xc7, 0xfa, 0xd0, 0x0d, 0x80, 0x70, 0xd8, 0x6c, 0x1f, 0xb0, 0xe0, 0x15, 0x1b, 0x5e,
  1502  	0xee, 0x03, 0x16, 0xd3, 0x3e, 0x16, 0xed, 0xe8, 0x26, 0x80, 0x4f, 0x4c, 0x8f, 0xd0, 0x66, 0x98,
  1503  	0xb8, 0x54, 0x39, 0x6e, 0x2b, 0x09, 0x8e, 0x68, 0xe9, 0x7f, 0xd2, 0x60, 0xba, 0x49, 0xe8, 0xf7,
  1504  	0x5d, 0x6f, 0xb7, 0xe5, 0xda, 0x96, 0xb9, 0x7f, 0x06, 0x24, 0x00, 0xc7, 0x48, 0xc0, 0x71, 0xf9,
  1505  	0x32, 0xe6, 0x5d, 0x1e, 0x15, 0xd0, 0x3f, 0xd4, 0x60, 0x3e, 0xa6, 0x79, 0x37, 0xcc, 0x07, 0x2a,
  1506  	0x41, 0x6b, 0x85, 0x12, 0x74, 0x0c, 0x86, 0x25, 0xb5, 0xec, 0x04, 0x8d, 0xd6, 0xa0, 0x44, 0x5d,
  1507  	0x19, 0xbd, 0xa3, 0x61, 0x12, 0xe2, 0x85, 0x35, 0xa7, 0xe3, 0xe2, 0x12, 0x75, 0xd9, 0x42, 0x2c,
  1508  	0xc4, 0xb4, 0xa2, 0x19, 0xed, 0x73, 0x1a, 0x01, 0x86, 0xb1, 0x6d, 0xcf, 0xed, 0x9f, 0x78, 0x0c,
  1509  	0x6a, 0x21, 0x5e, 0xf1, 0xdc, 0x3e, 0xe6, 0x58, 0xfa, 0x47, 0x1a, 0x5c, 0x8c, 0x69, 0x9e, 0x01,
  1510  	0x6f, 0x78, 0x23, 0xce, 0x1b, 0xae, 0x8d, 0x32, 0x90, 0x1c, 0xf6, 0xf0, 0x51, 0x29, 0x31, 0x0c,
  1511  	0x36, 0x60, 0xb4, 0x0d, 0x53, 0x03, 0xb7, 0xdb, 0x3e, 0x85, 0x07, 0xda, 0x59, 0xc6, 0xe7, 0x5a,
  1512  	0x21, 0x16, 0x8e, 0x02, 0xa3, 0xfb, 0x70, 0x91, 0x51, 0x0b, 0x7f, 0x60, 0x98, 0xa4, 0x7d, 0x0a,
  1513  	0x57, 0x56, 0x8f, 0xf0, 0x17, 0xa0, 0x24, 0x22, 0x4e, 0x77, 0x82, 0xd6, 0x61, 0xc2, 0x1a, 0xf0,
  1514  	0xf3, 0x85, 0x24, 0x92, 0xc7, 0x92, 0x30, 0x71, 0x1a, 0x11, 0x29, 0x5e, 0xfe, 0xc0, 0x01, 0x86,
  1515  	0xfe, 0xd7, 0x64, 0x34, 0x70, 0xba, 0xfa, 0x6a, 0x84, 0x1e, 0xc8, 0xb7, 0x9a, 0x93, 0x51, 0x83,
  1516  	0xa6, 0x64, 0x22, 0x27, 0x65, 0xd6, 0xd5, 0x04, 0x6f, 0xf9, 0x0a, 0x4c, 0x10, 0xa7, 0xcb, 0xc9,
  1517  	0xba, 0xb8, 0x08, 0xe1, 0xa3, 0xba, 0x2b, 0x9a, 0x70, 0x20, 0xd3, 0x7f, 0x5c, 0x4e, 0x8c, 0x8a,
  1518  	0x97, 0xd9, 0x77, 0x4f, 0x2d, 0x38, 0x14, 0xe1, 0xcf, 0x0d, 0x90, 0xad, 0x90, 0xfe, 0x89, 0x98,
  1519  	0xff, 0xc6, 0x28, 0x31, 0x1f, 0xad, 0x7f, 0xb9, 0xe4, 0x0f, 0x7d, 0x07, 0xc6, 0x89, 0xe8, 0x42,
  1520  	0x54, 0xd5, 0x5b, 0xa3, 0x74, 0x11, 0xa6, 0xdf, 0xf0, 0x9c, 0x25, 0xdb, 0x24, 0x2a, 0x7a, 0x99,
  1521  	0xcd, 0x17, 0xd3, 0x65, 0xc7, 0x12, 0xc1, 0x9e, 0x27, 0x1b, 0x8f, 0x89, 0x61, 0xab, 0xe6, 0x87,
  1522  	0x07, 0xcb, 0x10, 0xfe, 0xc4, 0x51, 0x0b, 0xfe, 0x7a, 0x26, 0xef, 0x6c, 0xce, 0xe6, 0x0b, 0xa4,
  1523  	0xd1, 0x5e, 0xcf, 0x42, 0xd7, 0x4e, 0xed, 0xf5, 0x2c, 0x02, 0x79, 0xf4, 0x19, 0xf6, 0x9f, 0x25,
  1524  	0xb8, 0x14, 0x2a, 0x17, 0x7e, 0x3d, 0xcb, 0x30, 0xf9, 0xff, 0x57, 0x48, 0xc5, 0x5e, 0xb4, 0xc2,
  1525  	0xa9, 0xfb, 0xef, 0x7b, 0xd1, 0x0a, 0x7d, 0xcb, 0xa9, 0x76, 0xbf, 0x29, 0x45, 0x07, 0x30, 0xe2,
  1526  	0xb3, 0xca, 0x29, 0x7c, 0x88, 0xf3, 0x85, 0x7b, 0x99, 0xd1, 0xff, 0x52, 0x86, 0x0b, 0xc9, 0xdd,
  1527  	0x18, 0xbb, 0x7d, 0xd7, 0x8e, 0xbd, 0x7d, 0x6f, 0xc1, 0xdc, 0xf6, 0xd0, 0xb6, 0xf7, 0xf9, 0x18,
  1528  	0x22, 0x57, 0xf0, 0xe2, 0xde, 0xfe, 0x4b, 0xd2, 0x72, 0xee, 0x95, 0x0c, 0x1d, 0x9c, 0x69, 0x99,
  1529  	0xbe, 0x8c, 0x1f, 0xfb, 0x4f, 0x2f, 0xe3, 0x2b, 0x27, 0xb8, 0x8c, 0xcf, 0x7e, 0xcf, 0x28, 0x9f,
  1530  	0xe8, 0x3d, 0xe3, 0x24, 0x37, 0xf1, 0x19, 0x49, 0xec, 0xd8, 0xaf, 0x4a, 0x5e, 0x82, 0x99, 0xf8,
  1531  	0xeb, 0x90, 0x58, 0x4b, 0xf1, 0x40, 0x25, 0xdf, 0x62, 0x22, 0x6b, 0x29, 0xda, 0xb1, 0xd2, 0xd0,
  1532  	0x0f, 0x35, 0xb8, 0x9c, 0xfd, 0x15, 0x08, 0xb2, 0x61, 0xa6, 0x6f, 0xdc, 0x8f, 0x7e, 0x99, 0xa3,
  1533  	0x9d, 0x90, 0xad, 0xf0, 0x67, 0x81, 0xf5, 0x18, 0x16, 0x4e, 0x60, 0xa3, 0xb7, 0xa1, 0xda, 0x37,
  1534  	0xee, 0xb7, 0x87, 0x5e, 0x8f, 0x9c, 0x98, 0x15, 0xf1, 0x6d, 0xb4, 0x2e, 0x51, 0xb0, 0xc2, 0xd3,
  1535  	0x3f, 0xd3, 0x60, 0x3e, 0xe7, 0xb2, 0xff, 0x7f, 0x68, 0x94, 0xef, 0x95, 0xa0, 0xd2, 0x36, 0x0d,
  1536  	0x9b, 0x9c, 0x01, 0xa1, 0x78, 0x2d, 0x46, 0x28, 0x8e, 0xfb, 0x9a, 0x94, 0x7b, 0x95, 0xcb, 0x25,
  1537  	0x70, 0x82, 0x4b, 0x3c, 0x55, 0x08, 0xed, 0x68, 0x1a, 0xf1, 0x3c, 0x4c, 0xaa, 0x4e, 0x47, 0xcb,
  1538  	0x6e, 0xfa, 0x2f, 0x4b, 0x30, 0x15, 0xe9, 0x62, 0xc4, 0xdc, 0xb8, 0x1d, 0x2b, 0x08, 0xe5, 0x02,
  1539  	0x37, 0x2d, 0x91, 0xbe, 0x6a, 0x41, 0x09, 0x10, 0x5f, 0x43, 0x84, 0xef, 0xdf, 0xe9, 0xca, 0xf0,
  1540  	0x12, 0xcc, 0x50, 0xc3, 0xeb, 0x11, 0xaa, 0x68, 0xbb, 0xb8, 0x64, 0x54, 0x9f, 0xe5, 0x74, 0x62,
  1541  	0x52, 0x9c, 0xd0, 0x5e, 0x7c, 0x11, 0xa6, 0x63, 0x9d, 0x8d, 0xf2, 0x31, 0x43, 0x63, 0xe5, 0xc1,
  1542  	0xa7, 0x4b, 0xe7, 0x3e, 0xfe, 0x74, 0xe9, 0xdc, 0x27, 0x9f, 0x2e, 0x9d, 0xfb, 0xc1, 0xe1, 0x92,
  1543  	0xf6, 0xe0, 0x70, 0x49, 0xfb, 0xf8, 0x70, 0x49, 0xfb, 0xe4, 0x70, 0x49, 0xfb, 0xfb, 0xe1, 0x92,
  1544  	0xf6, 0xd3, 0xcf, 0x96, 0xce, 0xbd, 0xfd, 0xd8, 0x91, 0xff, 0xb7, 0xe1, 0xdf, 0x01, 0x00, 0x00,
  1545  	0xff, 0xff, 0x5f, 0xd8, 0x14, 0x50, 0xfb, 0x30, 0x00, 0x00,
  1546  }
  1547  
  1548  func (m *DaemonSet) Marshal() (dAtA []byte, err error) {
  1549  	size := m.Size()
  1550  	dAtA = make([]byte, size)
  1551  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  1552  	if err != nil {
  1553  		return nil, err
  1554  	}
  1555  	return dAtA[:n], nil
  1556  }
  1557  
  1558  func (m *DaemonSet) MarshalTo(dAtA []byte) (int, error) {
  1559  	size := m.Size()
  1560  	return m.MarshalToSizedBuffer(dAtA[:size])
  1561  }
  1562  
  1563  func (m *DaemonSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  1564  	i := len(dAtA)
  1565  	_ = i
  1566  	var l int
  1567  	_ = l
  1568  	{
  1569  		size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
  1570  		if err != nil {
  1571  			return 0, err
  1572  		}
  1573  		i -= size
  1574  		i = encodeVarintGenerated(dAtA, i, uint64(size))
  1575  	}
  1576  	i--
  1577  	dAtA[i] = 0x1a
  1578  	{
  1579  		size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i])
  1580  		if err != nil {
  1581  			return 0, err
  1582  		}
  1583  		i -= size
  1584  		i = encodeVarintGenerated(dAtA, i, uint64(size))
  1585  	}
  1586  	i--
  1587  	dAtA[i] = 0x12
  1588  	{
  1589  		size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
  1590  		if err != nil {
  1591  			return 0, err
  1592  		}
  1593  		i -= size
  1594  		i = encodeVarintGenerated(dAtA, i, uint64(size))
  1595  	}
  1596  	i--
  1597  	dAtA[i] = 0xa
  1598  	return len(dAtA) - i, nil
  1599  }
  1600  
  1601  func (m *DaemonSetCondition) Marshal() (dAtA []byte, err error) {
  1602  	size := m.Size()
  1603  	dAtA = make([]byte, size)
  1604  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  1605  	if err != nil {
  1606  		return nil, err
  1607  	}
  1608  	return dAtA[:n], nil
  1609  }
  1610  
  1611  func (m *DaemonSetCondition) MarshalTo(dAtA []byte) (int, error) {
  1612  	size := m.Size()
  1613  	return m.MarshalToSizedBuffer(dAtA[:size])
  1614  }
  1615  
  1616  func (m *DaemonSetCondition) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  1617  	i := len(dAtA)
  1618  	_ = i
  1619  	var l int
  1620  	_ = l
  1621  	i -= len(m.Message)
  1622  	copy(dAtA[i:], m.Message)
  1623  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message)))
  1624  	i--
  1625  	dAtA[i] = 0x2a
  1626  	i -= len(m.Reason)
  1627  	copy(dAtA[i:], m.Reason)
  1628  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Reason)))
  1629  	i--
  1630  	dAtA[i] = 0x22
  1631  	{
  1632  		size, err := m.LastTransitionTime.MarshalToSizedBuffer(dAtA[:i])
  1633  		if err != nil {
  1634  			return 0, err
  1635  		}
  1636  		i -= size
  1637  		i = encodeVarintGenerated(dAtA, i, uint64(size))
  1638  	}
  1639  	i--
  1640  	dAtA[i] = 0x1a
  1641  	i -= len(m.Status)
  1642  	copy(dAtA[i:], m.Status)
  1643  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Status)))
  1644  	i--
  1645  	dAtA[i] = 0x12
  1646  	i -= len(m.Type)
  1647  	copy(dAtA[i:], m.Type)
  1648  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
  1649  	i--
  1650  	dAtA[i] = 0xa
  1651  	return len(dAtA) - i, nil
  1652  }
  1653  
  1654  func (m *DaemonSetList) Marshal() (dAtA []byte, err error) {
  1655  	size := m.Size()
  1656  	dAtA = make([]byte, size)
  1657  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  1658  	if err != nil {
  1659  		return nil, err
  1660  	}
  1661  	return dAtA[:n], nil
  1662  }
  1663  
  1664  func (m *DaemonSetList) MarshalTo(dAtA []byte) (int, error) {
  1665  	size := m.Size()
  1666  	return m.MarshalToSizedBuffer(dAtA[:size])
  1667  }
  1668  
  1669  func (m *DaemonSetList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  1670  	i := len(dAtA)
  1671  	_ = i
  1672  	var l int
  1673  	_ = l
  1674  	if len(m.Items) > 0 {
  1675  		for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
  1676  			{
  1677  				size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  1678  				if err != nil {
  1679  					return 0, err
  1680  				}
  1681  				i -= size
  1682  				i = encodeVarintGenerated(dAtA, i, uint64(size))
  1683  			}
  1684  			i--
  1685  			dAtA[i] = 0x12
  1686  		}
  1687  	}
  1688  	{
  1689  		size, err := m.ListMeta.MarshalToSizedBuffer(dAtA[:i])
  1690  		if err != nil {
  1691  			return 0, err
  1692  		}
  1693  		i -= size
  1694  		i = encodeVarintGenerated(dAtA, i, uint64(size))
  1695  	}
  1696  	i--
  1697  	dAtA[i] = 0xa
  1698  	return len(dAtA) - i, nil
  1699  }
  1700  
  1701  func (m *DaemonSetSpec) Marshal() (dAtA []byte, err error) {
  1702  	size := m.Size()
  1703  	dAtA = make([]byte, size)
  1704  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  1705  	if err != nil {
  1706  		return nil, err
  1707  	}
  1708  	return dAtA[:n], nil
  1709  }
  1710  
  1711  func (m *DaemonSetSpec) MarshalTo(dAtA []byte) (int, error) {
  1712  	size := m.Size()
  1713  	return m.MarshalToSizedBuffer(dAtA[:size])
  1714  }
  1715  
  1716  func (m *DaemonSetSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  1717  	i := len(dAtA)
  1718  	_ = i
  1719  	var l int
  1720  	_ = l
  1721  	if m.RevisionHistoryLimit != nil {
  1722  		i = encodeVarintGenerated(dAtA, i, uint64(*m.RevisionHistoryLimit))
  1723  		i--
  1724  		dAtA[i] = 0x30
  1725  	}
  1726  	i = encodeVarintGenerated(dAtA, i, uint64(m.TemplateGeneration))
  1727  	i--
  1728  	dAtA[i] = 0x28
  1729  	i = encodeVarintGenerated(dAtA, i, uint64(m.MinReadySeconds))
  1730  	i--
  1731  	dAtA[i] = 0x20
  1732  	{
  1733  		size, err := m.UpdateStrategy.MarshalToSizedBuffer(dAtA[:i])
  1734  		if err != nil {
  1735  			return 0, err
  1736  		}
  1737  		i -= size
  1738  		i = encodeVarintGenerated(dAtA, i, uint64(size))
  1739  	}
  1740  	i--
  1741  	dAtA[i] = 0x1a
  1742  	{
  1743  		size, err := m.Template.MarshalToSizedBuffer(dAtA[:i])
  1744  		if err != nil {
  1745  			return 0, err
  1746  		}
  1747  		i -= size
  1748  		i = encodeVarintGenerated(dAtA, i, uint64(size))
  1749  	}
  1750  	i--
  1751  	dAtA[i] = 0x12
  1752  	if m.Selector != nil {
  1753  		{
  1754  			size, err := m.Selector.MarshalToSizedBuffer(dAtA[:i])
  1755  			if err != nil {
  1756  				return 0, err
  1757  			}
  1758  			i -= size
  1759  			i = encodeVarintGenerated(dAtA, i, uint64(size))
  1760  		}
  1761  		i--
  1762  		dAtA[i] = 0xa
  1763  	}
  1764  	return len(dAtA) - i, nil
  1765  }
  1766  
  1767  func (m *DaemonSetStatus) Marshal() (dAtA []byte, err error) {
  1768  	size := m.Size()
  1769  	dAtA = make([]byte, size)
  1770  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  1771  	if err != nil {
  1772  		return nil, err
  1773  	}
  1774  	return dAtA[:n], nil
  1775  }
  1776  
  1777  func (m *DaemonSetStatus) MarshalTo(dAtA []byte) (int, error) {
  1778  	size := m.Size()
  1779  	return m.MarshalToSizedBuffer(dAtA[:size])
  1780  }
  1781  
  1782  func (m *DaemonSetStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  1783  	i := len(dAtA)
  1784  	_ = i
  1785  	var l int
  1786  	_ = l
  1787  	if len(m.Conditions) > 0 {
  1788  		for iNdEx := len(m.Conditions) - 1; iNdEx >= 0; iNdEx-- {
  1789  			{
  1790  				size, err := m.Conditions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  1791  				if err != nil {
  1792  					return 0, err
  1793  				}
  1794  				i -= size
  1795  				i = encodeVarintGenerated(dAtA, i, uint64(size))
  1796  			}
  1797  			i--
  1798  			dAtA[i] = 0x52
  1799  		}
  1800  	}
  1801  	if m.CollisionCount != nil {
  1802  		i = encodeVarintGenerated(dAtA, i, uint64(*m.CollisionCount))
  1803  		i--
  1804  		dAtA[i] = 0x48
  1805  	}
  1806  	i = encodeVarintGenerated(dAtA, i, uint64(m.NumberUnavailable))
  1807  	i--
  1808  	dAtA[i] = 0x40
  1809  	i = encodeVarintGenerated(dAtA, i, uint64(m.NumberAvailable))
  1810  	i--
  1811  	dAtA[i] = 0x38
  1812  	i = encodeVarintGenerated(dAtA, i, uint64(m.UpdatedNumberScheduled))
  1813  	i--
  1814  	dAtA[i] = 0x30
  1815  	i = encodeVarintGenerated(dAtA, i, uint64(m.ObservedGeneration))
  1816  	i--
  1817  	dAtA[i] = 0x28
  1818  	i = encodeVarintGenerated(dAtA, i, uint64(m.NumberReady))
  1819  	i--
  1820  	dAtA[i] = 0x20
  1821  	i = encodeVarintGenerated(dAtA, i, uint64(m.DesiredNumberScheduled))
  1822  	i--
  1823  	dAtA[i] = 0x18
  1824  	i = encodeVarintGenerated(dAtA, i, uint64(m.NumberMisscheduled))
  1825  	i--
  1826  	dAtA[i] = 0x10
  1827  	i = encodeVarintGenerated(dAtA, i, uint64(m.CurrentNumberScheduled))
  1828  	i--
  1829  	dAtA[i] = 0x8
  1830  	return len(dAtA) - i, nil
  1831  }
  1832  
  1833  func (m *DaemonSetUpdateStrategy) Marshal() (dAtA []byte, err error) {
  1834  	size := m.Size()
  1835  	dAtA = make([]byte, size)
  1836  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  1837  	if err != nil {
  1838  		return nil, err
  1839  	}
  1840  	return dAtA[:n], nil
  1841  }
  1842  
  1843  func (m *DaemonSetUpdateStrategy) MarshalTo(dAtA []byte) (int, error) {
  1844  	size := m.Size()
  1845  	return m.MarshalToSizedBuffer(dAtA[:size])
  1846  }
  1847  
  1848  func (m *DaemonSetUpdateStrategy) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  1849  	i := len(dAtA)
  1850  	_ = i
  1851  	var l int
  1852  	_ = l
  1853  	if m.RollingUpdate != nil {
  1854  		{
  1855  			size, err := m.RollingUpdate.MarshalToSizedBuffer(dAtA[:i])
  1856  			if err != nil {
  1857  				return 0, err
  1858  			}
  1859  			i -= size
  1860  			i = encodeVarintGenerated(dAtA, i, uint64(size))
  1861  		}
  1862  		i--
  1863  		dAtA[i] = 0x12
  1864  	}
  1865  	i -= len(m.Type)
  1866  	copy(dAtA[i:], m.Type)
  1867  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
  1868  	i--
  1869  	dAtA[i] = 0xa
  1870  	return len(dAtA) - i, nil
  1871  }
  1872  
  1873  func (m *Deployment) Marshal() (dAtA []byte, err error) {
  1874  	size := m.Size()
  1875  	dAtA = make([]byte, size)
  1876  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  1877  	if err != nil {
  1878  		return nil, err
  1879  	}
  1880  	return dAtA[:n], nil
  1881  }
  1882  
  1883  func (m *Deployment) MarshalTo(dAtA []byte) (int, error) {
  1884  	size := m.Size()
  1885  	return m.MarshalToSizedBuffer(dAtA[:size])
  1886  }
  1887  
  1888  func (m *Deployment) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  1889  	i := len(dAtA)
  1890  	_ = i
  1891  	var l int
  1892  	_ = l
  1893  	{
  1894  		size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
  1895  		if err != nil {
  1896  			return 0, err
  1897  		}
  1898  		i -= size
  1899  		i = encodeVarintGenerated(dAtA, i, uint64(size))
  1900  	}
  1901  	i--
  1902  	dAtA[i] = 0x1a
  1903  	{
  1904  		size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i])
  1905  		if err != nil {
  1906  			return 0, err
  1907  		}
  1908  		i -= size
  1909  		i = encodeVarintGenerated(dAtA, i, uint64(size))
  1910  	}
  1911  	i--
  1912  	dAtA[i] = 0x12
  1913  	{
  1914  		size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
  1915  		if err != nil {
  1916  			return 0, err
  1917  		}
  1918  		i -= size
  1919  		i = encodeVarintGenerated(dAtA, i, uint64(size))
  1920  	}
  1921  	i--
  1922  	dAtA[i] = 0xa
  1923  	return len(dAtA) - i, nil
  1924  }
  1925  
  1926  func (m *DeploymentCondition) Marshal() (dAtA []byte, err error) {
  1927  	size := m.Size()
  1928  	dAtA = make([]byte, size)
  1929  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  1930  	if err != nil {
  1931  		return nil, err
  1932  	}
  1933  	return dAtA[:n], nil
  1934  }
  1935  
  1936  func (m *DeploymentCondition) MarshalTo(dAtA []byte) (int, error) {
  1937  	size := m.Size()
  1938  	return m.MarshalToSizedBuffer(dAtA[:size])
  1939  }
  1940  
  1941  func (m *DeploymentCondition) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  1942  	i := len(dAtA)
  1943  	_ = i
  1944  	var l int
  1945  	_ = l
  1946  	{
  1947  		size, err := m.LastTransitionTime.MarshalToSizedBuffer(dAtA[:i])
  1948  		if err != nil {
  1949  			return 0, err
  1950  		}
  1951  		i -= size
  1952  		i = encodeVarintGenerated(dAtA, i, uint64(size))
  1953  	}
  1954  	i--
  1955  	dAtA[i] = 0x3a
  1956  	{
  1957  		size, err := m.LastUpdateTime.MarshalToSizedBuffer(dAtA[:i])
  1958  		if err != nil {
  1959  			return 0, err
  1960  		}
  1961  		i -= size
  1962  		i = encodeVarintGenerated(dAtA, i, uint64(size))
  1963  	}
  1964  	i--
  1965  	dAtA[i] = 0x32
  1966  	i -= len(m.Message)
  1967  	copy(dAtA[i:], m.Message)
  1968  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message)))
  1969  	i--
  1970  	dAtA[i] = 0x2a
  1971  	i -= len(m.Reason)
  1972  	copy(dAtA[i:], m.Reason)
  1973  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Reason)))
  1974  	i--
  1975  	dAtA[i] = 0x22
  1976  	i -= len(m.Status)
  1977  	copy(dAtA[i:], m.Status)
  1978  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Status)))
  1979  	i--
  1980  	dAtA[i] = 0x12
  1981  	i -= len(m.Type)
  1982  	copy(dAtA[i:], m.Type)
  1983  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
  1984  	i--
  1985  	dAtA[i] = 0xa
  1986  	return len(dAtA) - i, nil
  1987  }
  1988  
  1989  func (m *DeploymentList) Marshal() (dAtA []byte, err error) {
  1990  	size := m.Size()
  1991  	dAtA = make([]byte, size)
  1992  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  1993  	if err != nil {
  1994  		return nil, err
  1995  	}
  1996  	return dAtA[:n], nil
  1997  }
  1998  
  1999  func (m *DeploymentList) MarshalTo(dAtA []byte) (int, error) {
  2000  	size := m.Size()
  2001  	return m.MarshalToSizedBuffer(dAtA[:size])
  2002  }
  2003  
  2004  func (m *DeploymentList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  2005  	i := len(dAtA)
  2006  	_ = i
  2007  	var l int
  2008  	_ = l
  2009  	if len(m.Items) > 0 {
  2010  		for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
  2011  			{
  2012  				size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  2013  				if err != nil {
  2014  					return 0, err
  2015  				}
  2016  				i -= size
  2017  				i = encodeVarintGenerated(dAtA, i, uint64(size))
  2018  			}
  2019  			i--
  2020  			dAtA[i] = 0x12
  2021  		}
  2022  	}
  2023  	{
  2024  		size, err := m.ListMeta.MarshalToSizedBuffer(dAtA[:i])
  2025  		if err != nil {
  2026  			return 0, err
  2027  		}
  2028  		i -= size
  2029  		i = encodeVarintGenerated(dAtA, i, uint64(size))
  2030  	}
  2031  	i--
  2032  	dAtA[i] = 0xa
  2033  	return len(dAtA) - i, nil
  2034  }
  2035  
  2036  func (m *DeploymentRollback) Marshal() (dAtA []byte, err error) {
  2037  	size := m.Size()
  2038  	dAtA = make([]byte, size)
  2039  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  2040  	if err != nil {
  2041  		return nil, err
  2042  	}
  2043  	return dAtA[:n], nil
  2044  }
  2045  
  2046  func (m *DeploymentRollback) MarshalTo(dAtA []byte) (int, error) {
  2047  	size := m.Size()
  2048  	return m.MarshalToSizedBuffer(dAtA[:size])
  2049  }
  2050  
  2051  func (m *DeploymentRollback) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  2052  	i := len(dAtA)
  2053  	_ = i
  2054  	var l int
  2055  	_ = l
  2056  	{
  2057  		size, err := m.RollbackTo.MarshalToSizedBuffer(dAtA[:i])
  2058  		if err != nil {
  2059  			return 0, err
  2060  		}
  2061  		i -= size
  2062  		i = encodeVarintGenerated(dAtA, i, uint64(size))
  2063  	}
  2064  	i--
  2065  	dAtA[i] = 0x1a
  2066  	if len(m.UpdatedAnnotations) > 0 {
  2067  		keysForUpdatedAnnotations := make([]string, 0, len(m.UpdatedAnnotations))
  2068  		for k := range m.UpdatedAnnotations {
  2069  			keysForUpdatedAnnotations = append(keysForUpdatedAnnotations, string(k))
  2070  		}
  2071  		github_com_gogo_protobuf_sortkeys.Strings(keysForUpdatedAnnotations)
  2072  		for iNdEx := len(keysForUpdatedAnnotations) - 1; iNdEx >= 0; iNdEx-- {
  2073  			v := m.UpdatedAnnotations[string(keysForUpdatedAnnotations[iNdEx])]
  2074  			baseI := i
  2075  			i -= len(v)
  2076  			copy(dAtA[i:], v)
  2077  			i = encodeVarintGenerated(dAtA, i, uint64(len(v)))
  2078  			i--
  2079  			dAtA[i] = 0x12
  2080  			i -= len(keysForUpdatedAnnotations[iNdEx])
  2081  			copy(dAtA[i:], keysForUpdatedAnnotations[iNdEx])
  2082  			i = encodeVarintGenerated(dAtA, i, uint64(len(keysForUpdatedAnnotations[iNdEx])))
  2083  			i--
  2084  			dAtA[i] = 0xa
  2085  			i = encodeVarintGenerated(dAtA, i, uint64(baseI-i))
  2086  			i--
  2087  			dAtA[i] = 0x12
  2088  		}
  2089  	}
  2090  	i -= len(m.Name)
  2091  	copy(dAtA[i:], m.Name)
  2092  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
  2093  	i--
  2094  	dAtA[i] = 0xa
  2095  	return len(dAtA) - i, nil
  2096  }
  2097  
  2098  func (m *DeploymentSpec) Marshal() (dAtA []byte, err error) {
  2099  	size := m.Size()
  2100  	dAtA = make([]byte, size)
  2101  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  2102  	if err != nil {
  2103  		return nil, err
  2104  	}
  2105  	return dAtA[:n], nil
  2106  }
  2107  
  2108  func (m *DeploymentSpec) MarshalTo(dAtA []byte) (int, error) {
  2109  	size := m.Size()
  2110  	return m.MarshalToSizedBuffer(dAtA[:size])
  2111  }
  2112  
  2113  func (m *DeploymentSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  2114  	i := len(dAtA)
  2115  	_ = i
  2116  	var l int
  2117  	_ = l
  2118  	if m.ProgressDeadlineSeconds != nil {
  2119  		i = encodeVarintGenerated(dAtA, i, uint64(*m.ProgressDeadlineSeconds))
  2120  		i--
  2121  		dAtA[i] = 0x48
  2122  	}
  2123  	if m.RollbackTo != nil {
  2124  		{
  2125  			size, err := m.RollbackTo.MarshalToSizedBuffer(dAtA[:i])
  2126  			if err != nil {
  2127  				return 0, err
  2128  			}
  2129  			i -= size
  2130  			i = encodeVarintGenerated(dAtA, i, uint64(size))
  2131  		}
  2132  		i--
  2133  		dAtA[i] = 0x42
  2134  	}
  2135  	i--
  2136  	if m.Paused {
  2137  		dAtA[i] = 1
  2138  	} else {
  2139  		dAtA[i] = 0
  2140  	}
  2141  	i--
  2142  	dAtA[i] = 0x38
  2143  	if m.RevisionHistoryLimit != nil {
  2144  		i = encodeVarintGenerated(dAtA, i, uint64(*m.RevisionHistoryLimit))
  2145  		i--
  2146  		dAtA[i] = 0x30
  2147  	}
  2148  	i = encodeVarintGenerated(dAtA, i, uint64(m.MinReadySeconds))
  2149  	i--
  2150  	dAtA[i] = 0x28
  2151  	{
  2152  		size, err := m.Strategy.MarshalToSizedBuffer(dAtA[:i])
  2153  		if err != nil {
  2154  			return 0, err
  2155  		}
  2156  		i -= size
  2157  		i = encodeVarintGenerated(dAtA, i, uint64(size))
  2158  	}
  2159  	i--
  2160  	dAtA[i] = 0x22
  2161  	{
  2162  		size, err := m.Template.MarshalToSizedBuffer(dAtA[:i])
  2163  		if err != nil {
  2164  			return 0, err
  2165  		}
  2166  		i -= size
  2167  		i = encodeVarintGenerated(dAtA, i, uint64(size))
  2168  	}
  2169  	i--
  2170  	dAtA[i] = 0x1a
  2171  	if m.Selector != nil {
  2172  		{
  2173  			size, err := m.Selector.MarshalToSizedBuffer(dAtA[:i])
  2174  			if err != nil {
  2175  				return 0, err
  2176  			}
  2177  			i -= size
  2178  			i = encodeVarintGenerated(dAtA, i, uint64(size))
  2179  		}
  2180  		i--
  2181  		dAtA[i] = 0x12
  2182  	}
  2183  	if m.Replicas != nil {
  2184  		i = encodeVarintGenerated(dAtA, i, uint64(*m.Replicas))
  2185  		i--
  2186  		dAtA[i] = 0x8
  2187  	}
  2188  	return len(dAtA) - i, nil
  2189  }
  2190  
  2191  func (m *DeploymentStatus) Marshal() (dAtA []byte, err error) {
  2192  	size := m.Size()
  2193  	dAtA = make([]byte, size)
  2194  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  2195  	if err != nil {
  2196  		return nil, err
  2197  	}
  2198  	return dAtA[:n], nil
  2199  }
  2200  
  2201  func (m *DeploymentStatus) MarshalTo(dAtA []byte) (int, error) {
  2202  	size := m.Size()
  2203  	return m.MarshalToSizedBuffer(dAtA[:size])
  2204  }
  2205  
  2206  func (m *DeploymentStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  2207  	i := len(dAtA)
  2208  	_ = i
  2209  	var l int
  2210  	_ = l
  2211  	if m.CollisionCount != nil {
  2212  		i = encodeVarintGenerated(dAtA, i, uint64(*m.CollisionCount))
  2213  		i--
  2214  		dAtA[i] = 0x40
  2215  	}
  2216  	i = encodeVarintGenerated(dAtA, i, uint64(m.ReadyReplicas))
  2217  	i--
  2218  	dAtA[i] = 0x38
  2219  	if len(m.Conditions) > 0 {
  2220  		for iNdEx := len(m.Conditions) - 1; iNdEx >= 0; iNdEx-- {
  2221  			{
  2222  				size, err := m.Conditions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  2223  				if err != nil {
  2224  					return 0, err
  2225  				}
  2226  				i -= size
  2227  				i = encodeVarintGenerated(dAtA, i, uint64(size))
  2228  			}
  2229  			i--
  2230  			dAtA[i] = 0x32
  2231  		}
  2232  	}
  2233  	i = encodeVarintGenerated(dAtA, i, uint64(m.UnavailableReplicas))
  2234  	i--
  2235  	dAtA[i] = 0x28
  2236  	i = encodeVarintGenerated(dAtA, i, uint64(m.AvailableReplicas))
  2237  	i--
  2238  	dAtA[i] = 0x20
  2239  	i = encodeVarintGenerated(dAtA, i, uint64(m.UpdatedReplicas))
  2240  	i--
  2241  	dAtA[i] = 0x18
  2242  	i = encodeVarintGenerated(dAtA, i, uint64(m.Replicas))
  2243  	i--
  2244  	dAtA[i] = 0x10
  2245  	i = encodeVarintGenerated(dAtA, i, uint64(m.ObservedGeneration))
  2246  	i--
  2247  	dAtA[i] = 0x8
  2248  	return len(dAtA) - i, nil
  2249  }
  2250  
  2251  func (m *DeploymentStrategy) Marshal() (dAtA []byte, err error) {
  2252  	size := m.Size()
  2253  	dAtA = make([]byte, size)
  2254  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  2255  	if err != nil {
  2256  		return nil, err
  2257  	}
  2258  	return dAtA[:n], nil
  2259  }
  2260  
  2261  func (m *DeploymentStrategy) MarshalTo(dAtA []byte) (int, error) {
  2262  	size := m.Size()
  2263  	return m.MarshalToSizedBuffer(dAtA[:size])
  2264  }
  2265  
  2266  func (m *DeploymentStrategy) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  2267  	i := len(dAtA)
  2268  	_ = i
  2269  	var l int
  2270  	_ = l
  2271  	if m.RollingUpdate != nil {
  2272  		{
  2273  			size, err := m.RollingUpdate.MarshalToSizedBuffer(dAtA[:i])
  2274  			if err != nil {
  2275  				return 0, err
  2276  			}
  2277  			i -= size
  2278  			i = encodeVarintGenerated(dAtA, i, uint64(size))
  2279  		}
  2280  		i--
  2281  		dAtA[i] = 0x12
  2282  	}
  2283  	i -= len(m.Type)
  2284  	copy(dAtA[i:], m.Type)
  2285  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
  2286  	i--
  2287  	dAtA[i] = 0xa
  2288  	return len(dAtA) - i, nil
  2289  }
  2290  
  2291  func (m *HTTPIngressPath) Marshal() (dAtA []byte, err error) {
  2292  	size := m.Size()
  2293  	dAtA = make([]byte, size)
  2294  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  2295  	if err != nil {
  2296  		return nil, err
  2297  	}
  2298  	return dAtA[:n], nil
  2299  }
  2300  
  2301  func (m *HTTPIngressPath) MarshalTo(dAtA []byte) (int, error) {
  2302  	size := m.Size()
  2303  	return m.MarshalToSizedBuffer(dAtA[:size])
  2304  }
  2305  
  2306  func (m *HTTPIngressPath) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  2307  	i := len(dAtA)
  2308  	_ = i
  2309  	var l int
  2310  	_ = l
  2311  	if m.PathType != nil {
  2312  		i -= len(*m.PathType)
  2313  		copy(dAtA[i:], *m.PathType)
  2314  		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.PathType)))
  2315  		i--
  2316  		dAtA[i] = 0x1a
  2317  	}
  2318  	{
  2319  		size, err := m.Backend.MarshalToSizedBuffer(dAtA[:i])
  2320  		if err != nil {
  2321  			return 0, err
  2322  		}
  2323  		i -= size
  2324  		i = encodeVarintGenerated(dAtA, i, uint64(size))
  2325  	}
  2326  	i--
  2327  	dAtA[i] = 0x12
  2328  	i -= len(m.Path)
  2329  	copy(dAtA[i:], m.Path)
  2330  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Path)))
  2331  	i--
  2332  	dAtA[i] = 0xa
  2333  	return len(dAtA) - i, nil
  2334  }
  2335  
  2336  func (m *HTTPIngressRuleValue) Marshal() (dAtA []byte, err error) {
  2337  	size := m.Size()
  2338  	dAtA = make([]byte, size)
  2339  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  2340  	if err != nil {
  2341  		return nil, err
  2342  	}
  2343  	return dAtA[:n], nil
  2344  }
  2345  
  2346  func (m *HTTPIngressRuleValue) MarshalTo(dAtA []byte) (int, error) {
  2347  	size := m.Size()
  2348  	return m.MarshalToSizedBuffer(dAtA[:size])
  2349  }
  2350  
  2351  func (m *HTTPIngressRuleValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  2352  	i := len(dAtA)
  2353  	_ = i
  2354  	var l int
  2355  	_ = l
  2356  	if len(m.Paths) > 0 {
  2357  		for iNdEx := len(m.Paths) - 1; iNdEx >= 0; iNdEx-- {
  2358  			{
  2359  				size, err := m.Paths[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  2360  				if err != nil {
  2361  					return 0, err
  2362  				}
  2363  				i -= size
  2364  				i = encodeVarintGenerated(dAtA, i, uint64(size))
  2365  			}
  2366  			i--
  2367  			dAtA[i] = 0xa
  2368  		}
  2369  	}
  2370  	return len(dAtA) - i, nil
  2371  }
  2372  
  2373  func (m *IPBlock) Marshal() (dAtA []byte, err error) {
  2374  	size := m.Size()
  2375  	dAtA = make([]byte, size)
  2376  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  2377  	if err != nil {
  2378  		return nil, err
  2379  	}
  2380  	return dAtA[:n], nil
  2381  }
  2382  
  2383  func (m *IPBlock) MarshalTo(dAtA []byte) (int, error) {
  2384  	size := m.Size()
  2385  	return m.MarshalToSizedBuffer(dAtA[:size])
  2386  }
  2387  
  2388  func (m *IPBlock) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  2389  	i := len(dAtA)
  2390  	_ = i
  2391  	var l int
  2392  	_ = l
  2393  	if len(m.Except) > 0 {
  2394  		for iNdEx := len(m.Except) - 1; iNdEx >= 0; iNdEx-- {
  2395  			i -= len(m.Except[iNdEx])
  2396  			copy(dAtA[i:], m.Except[iNdEx])
  2397  			i = encodeVarintGenerated(dAtA, i, uint64(len(m.Except[iNdEx])))
  2398  			i--
  2399  			dAtA[i] = 0x12
  2400  		}
  2401  	}
  2402  	i -= len(m.CIDR)
  2403  	copy(dAtA[i:], m.CIDR)
  2404  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.CIDR)))
  2405  	i--
  2406  	dAtA[i] = 0xa
  2407  	return len(dAtA) - i, nil
  2408  }
  2409  
  2410  func (m *Ingress) Marshal() (dAtA []byte, err error) {
  2411  	size := m.Size()
  2412  	dAtA = make([]byte, size)
  2413  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  2414  	if err != nil {
  2415  		return nil, err
  2416  	}
  2417  	return dAtA[:n], nil
  2418  }
  2419  
  2420  func (m *Ingress) MarshalTo(dAtA []byte) (int, error) {
  2421  	size := m.Size()
  2422  	return m.MarshalToSizedBuffer(dAtA[:size])
  2423  }
  2424  
  2425  func (m *Ingress) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  2426  	i := len(dAtA)
  2427  	_ = i
  2428  	var l int
  2429  	_ = l
  2430  	{
  2431  		size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
  2432  		if err != nil {
  2433  			return 0, err
  2434  		}
  2435  		i -= size
  2436  		i = encodeVarintGenerated(dAtA, i, uint64(size))
  2437  	}
  2438  	i--
  2439  	dAtA[i] = 0x1a
  2440  	{
  2441  		size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i])
  2442  		if err != nil {
  2443  			return 0, err
  2444  		}
  2445  		i -= size
  2446  		i = encodeVarintGenerated(dAtA, i, uint64(size))
  2447  	}
  2448  	i--
  2449  	dAtA[i] = 0x12
  2450  	{
  2451  		size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
  2452  		if err != nil {
  2453  			return 0, err
  2454  		}
  2455  		i -= size
  2456  		i = encodeVarintGenerated(dAtA, i, uint64(size))
  2457  	}
  2458  	i--
  2459  	dAtA[i] = 0xa
  2460  	return len(dAtA) - i, nil
  2461  }
  2462  
  2463  func (m *IngressBackend) Marshal() (dAtA []byte, err error) {
  2464  	size := m.Size()
  2465  	dAtA = make([]byte, size)
  2466  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  2467  	if err != nil {
  2468  		return nil, err
  2469  	}
  2470  	return dAtA[:n], nil
  2471  }
  2472  
  2473  func (m *IngressBackend) MarshalTo(dAtA []byte) (int, error) {
  2474  	size := m.Size()
  2475  	return m.MarshalToSizedBuffer(dAtA[:size])
  2476  }
  2477  
  2478  func (m *IngressBackend) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  2479  	i := len(dAtA)
  2480  	_ = i
  2481  	var l int
  2482  	_ = l
  2483  	if m.Resource != nil {
  2484  		{
  2485  			size, err := m.Resource.MarshalToSizedBuffer(dAtA[:i])
  2486  			if err != nil {
  2487  				return 0, err
  2488  			}
  2489  			i -= size
  2490  			i = encodeVarintGenerated(dAtA, i, uint64(size))
  2491  		}
  2492  		i--
  2493  		dAtA[i] = 0x1a
  2494  	}
  2495  	{
  2496  		size, err := m.ServicePort.MarshalToSizedBuffer(dAtA[:i])
  2497  		if err != nil {
  2498  			return 0, err
  2499  		}
  2500  		i -= size
  2501  		i = encodeVarintGenerated(dAtA, i, uint64(size))
  2502  	}
  2503  	i--
  2504  	dAtA[i] = 0x12
  2505  	i -= len(m.ServiceName)
  2506  	copy(dAtA[i:], m.ServiceName)
  2507  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.ServiceName)))
  2508  	i--
  2509  	dAtA[i] = 0xa
  2510  	return len(dAtA) - i, nil
  2511  }
  2512  
  2513  func (m *IngressList) Marshal() (dAtA []byte, err error) {
  2514  	size := m.Size()
  2515  	dAtA = make([]byte, size)
  2516  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  2517  	if err != nil {
  2518  		return nil, err
  2519  	}
  2520  	return dAtA[:n], nil
  2521  }
  2522  
  2523  func (m *IngressList) MarshalTo(dAtA []byte) (int, error) {
  2524  	size := m.Size()
  2525  	return m.MarshalToSizedBuffer(dAtA[:size])
  2526  }
  2527  
  2528  func (m *IngressList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  2529  	i := len(dAtA)
  2530  	_ = i
  2531  	var l int
  2532  	_ = l
  2533  	if len(m.Items) > 0 {
  2534  		for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
  2535  			{
  2536  				size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  2537  				if err != nil {
  2538  					return 0, err
  2539  				}
  2540  				i -= size
  2541  				i = encodeVarintGenerated(dAtA, i, uint64(size))
  2542  			}
  2543  			i--
  2544  			dAtA[i] = 0x12
  2545  		}
  2546  	}
  2547  	{
  2548  		size, err := m.ListMeta.MarshalToSizedBuffer(dAtA[:i])
  2549  		if err != nil {
  2550  			return 0, err
  2551  		}
  2552  		i -= size
  2553  		i = encodeVarintGenerated(dAtA, i, uint64(size))
  2554  	}
  2555  	i--
  2556  	dAtA[i] = 0xa
  2557  	return len(dAtA) - i, nil
  2558  }
  2559  
  2560  func (m *IngressLoadBalancerIngress) Marshal() (dAtA []byte, err error) {
  2561  	size := m.Size()
  2562  	dAtA = make([]byte, size)
  2563  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  2564  	if err != nil {
  2565  		return nil, err
  2566  	}
  2567  	return dAtA[:n], nil
  2568  }
  2569  
  2570  func (m *IngressLoadBalancerIngress) MarshalTo(dAtA []byte) (int, error) {
  2571  	size := m.Size()
  2572  	return m.MarshalToSizedBuffer(dAtA[:size])
  2573  }
  2574  
  2575  func (m *IngressLoadBalancerIngress) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  2576  	i := len(dAtA)
  2577  	_ = i
  2578  	var l int
  2579  	_ = l
  2580  	if len(m.Ports) > 0 {
  2581  		for iNdEx := len(m.Ports) - 1; iNdEx >= 0; iNdEx-- {
  2582  			{
  2583  				size, err := m.Ports[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  2584  				if err != nil {
  2585  					return 0, err
  2586  				}
  2587  				i -= size
  2588  				i = encodeVarintGenerated(dAtA, i, uint64(size))
  2589  			}
  2590  			i--
  2591  			dAtA[i] = 0x22
  2592  		}
  2593  	}
  2594  	i -= len(m.Hostname)
  2595  	copy(dAtA[i:], m.Hostname)
  2596  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Hostname)))
  2597  	i--
  2598  	dAtA[i] = 0x12
  2599  	i -= len(m.IP)
  2600  	copy(dAtA[i:], m.IP)
  2601  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.IP)))
  2602  	i--
  2603  	dAtA[i] = 0xa
  2604  	return len(dAtA) - i, nil
  2605  }
  2606  
  2607  func (m *IngressLoadBalancerStatus) Marshal() (dAtA []byte, err error) {
  2608  	size := m.Size()
  2609  	dAtA = make([]byte, size)
  2610  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  2611  	if err != nil {
  2612  		return nil, err
  2613  	}
  2614  	return dAtA[:n], nil
  2615  }
  2616  
  2617  func (m *IngressLoadBalancerStatus) MarshalTo(dAtA []byte) (int, error) {
  2618  	size := m.Size()
  2619  	return m.MarshalToSizedBuffer(dAtA[:size])
  2620  }
  2621  
  2622  func (m *IngressLoadBalancerStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  2623  	i := len(dAtA)
  2624  	_ = i
  2625  	var l int
  2626  	_ = l
  2627  	if len(m.Ingress) > 0 {
  2628  		for iNdEx := len(m.Ingress) - 1; iNdEx >= 0; iNdEx-- {
  2629  			{
  2630  				size, err := m.Ingress[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  2631  				if err != nil {
  2632  					return 0, err
  2633  				}
  2634  				i -= size
  2635  				i = encodeVarintGenerated(dAtA, i, uint64(size))
  2636  			}
  2637  			i--
  2638  			dAtA[i] = 0xa
  2639  		}
  2640  	}
  2641  	return len(dAtA) - i, nil
  2642  }
  2643  
  2644  func (m *IngressPortStatus) Marshal() (dAtA []byte, err error) {
  2645  	size := m.Size()
  2646  	dAtA = make([]byte, size)
  2647  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  2648  	if err != nil {
  2649  		return nil, err
  2650  	}
  2651  	return dAtA[:n], nil
  2652  }
  2653  
  2654  func (m *IngressPortStatus) MarshalTo(dAtA []byte) (int, error) {
  2655  	size := m.Size()
  2656  	return m.MarshalToSizedBuffer(dAtA[:size])
  2657  }
  2658  
  2659  func (m *IngressPortStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  2660  	i := len(dAtA)
  2661  	_ = i
  2662  	var l int
  2663  	_ = l
  2664  	if m.Error != nil {
  2665  		i -= len(*m.Error)
  2666  		copy(dAtA[i:], *m.Error)
  2667  		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.Error)))
  2668  		i--
  2669  		dAtA[i] = 0x1a
  2670  	}
  2671  	i -= len(m.Protocol)
  2672  	copy(dAtA[i:], m.Protocol)
  2673  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Protocol)))
  2674  	i--
  2675  	dAtA[i] = 0x12
  2676  	i = encodeVarintGenerated(dAtA, i, uint64(m.Port))
  2677  	i--
  2678  	dAtA[i] = 0x8
  2679  	return len(dAtA) - i, nil
  2680  }
  2681  
  2682  func (m *IngressRule) Marshal() (dAtA []byte, err error) {
  2683  	size := m.Size()
  2684  	dAtA = make([]byte, size)
  2685  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  2686  	if err != nil {
  2687  		return nil, err
  2688  	}
  2689  	return dAtA[:n], nil
  2690  }
  2691  
  2692  func (m *IngressRule) MarshalTo(dAtA []byte) (int, error) {
  2693  	size := m.Size()
  2694  	return m.MarshalToSizedBuffer(dAtA[:size])
  2695  }
  2696  
  2697  func (m *IngressRule) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  2698  	i := len(dAtA)
  2699  	_ = i
  2700  	var l int
  2701  	_ = l
  2702  	{
  2703  		size, err := m.IngressRuleValue.MarshalToSizedBuffer(dAtA[:i])
  2704  		if err != nil {
  2705  			return 0, err
  2706  		}
  2707  		i -= size
  2708  		i = encodeVarintGenerated(dAtA, i, uint64(size))
  2709  	}
  2710  	i--
  2711  	dAtA[i] = 0x12
  2712  	i -= len(m.Host)
  2713  	copy(dAtA[i:], m.Host)
  2714  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Host)))
  2715  	i--
  2716  	dAtA[i] = 0xa
  2717  	return len(dAtA) - i, nil
  2718  }
  2719  
  2720  func (m *IngressRuleValue) Marshal() (dAtA []byte, err error) {
  2721  	size := m.Size()
  2722  	dAtA = make([]byte, size)
  2723  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  2724  	if err != nil {
  2725  		return nil, err
  2726  	}
  2727  	return dAtA[:n], nil
  2728  }
  2729  
  2730  func (m *IngressRuleValue) MarshalTo(dAtA []byte) (int, error) {
  2731  	size := m.Size()
  2732  	return m.MarshalToSizedBuffer(dAtA[:size])
  2733  }
  2734  
  2735  func (m *IngressRuleValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  2736  	i := len(dAtA)
  2737  	_ = i
  2738  	var l int
  2739  	_ = l
  2740  	if m.HTTP != nil {
  2741  		{
  2742  			size, err := m.HTTP.MarshalToSizedBuffer(dAtA[:i])
  2743  			if err != nil {
  2744  				return 0, err
  2745  			}
  2746  			i -= size
  2747  			i = encodeVarintGenerated(dAtA, i, uint64(size))
  2748  		}
  2749  		i--
  2750  		dAtA[i] = 0xa
  2751  	}
  2752  	return len(dAtA) - i, nil
  2753  }
  2754  
  2755  func (m *IngressSpec) Marshal() (dAtA []byte, err error) {
  2756  	size := m.Size()
  2757  	dAtA = make([]byte, size)
  2758  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  2759  	if err != nil {
  2760  		return nil, err
  2761  	}
  2762  	return dAtA[:n], nil
  2763  }
  2764  
  2765  func (m *IngressSpec) MarshalTo(dAtA []byte) (int, error) {
  2766  	size := m.Size()
  2767  	return m.MarshalToSizedBuffer(dAtA[:size])
  2768  }
  2769  
  2770  func (m *IngressSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  2771  	i := len(dAtA)
  2772  	_ = i
  2773  	var l int
  2774  	_ = l
  2775  	if m.IngressClassName != nil {
  2776  		i -= len(*m.IngressClassName)
  2777  		copy(dAtA[i:], *m.IngressClassName)
  2778  		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.IngressClassName)))
  2779  		i--
  2780  		dAtA[i] = 0x22
  2781  	}
  2782  	if len(m.Rules) > 0 {
  2783  		for iNdEx := len(m.Rules) - 1; iNdEx >= 0; iNdEx-- {
  2784  			{
  2785  				size, err := m.Rules[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  2786  				if err != nil {
  2787  					return 0, err
  2788  				}
  2789  				i -= size
  2790  				i = encodeVarintGenerated(dAtA, i, uint64(size))
  2791  			}
  2792  			i--
  2793  			dAtA[i] = 0x1a
  2794  		}
  2795  	}
  2796  	if len(m.TLS) > 0 {
  2797  		for iNdEx := len(m.TLS) - 1; iNdEx >= 0; iNdEx-- {
  2798  			{
  2799  				size, err := m.TLS[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  2800  				if err != nil {
  2801  					return 0, err
  2802  				}
  2803  				i -= size
  2804  				i = encodeVarintGenerated(dAtA, i, uint64(size))
  2805  			}
  2806  			i--
  2807  			dAtA[i] = 0x12
  2808  		}
  2809  	}
  2810  	if m.Backend != nil {
  2811  		{
  2812  			size, err := m.Backend.MarshalToSizedBuffer(dAtA[:i])
  2813  			if err != nil {
  2814  				return 0, err
  2815  			}
  2816  			i -= size
  2817  			i = encodeVarintGenerated(dAtA, i, uint64(size))
  2818  		}
  2819  		i--
  2820  		dAtA[i] = 0xa
  2821  	}
  2822  	return len(dAtA) - i, nil
  2823  }
  2824  
  2825  func (m *IngressStatus) Marshal() (dAtA []byte, err error) {
  2826  	size := m.Size()
  2827  	dAtA = make([]byte, size)
  2828  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  2829  	if err != nil {
  2830  		return nil, err
  2831  	}
  2832  	return dAtA[:n], nil
  2833  }
  2834  
  2835  func (m *IngressStatus) MarshalTo(dAtA []byte) (int, error) {
  2836  	size := m.Size()
  2837  	return m.MarshalToSizedBuffer(dAtA[:size])
  2838  }
  2839  
  2840  func (m *IngressStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  2841  	i := len(dAtA)
  2842  	_ = i
  2843  	var l int
  2844  	_ = l
  2845  	{
  2846  		size, err := m.LoadBalancer.MarshalToSizedBuffer(dAtA[:i])
  2847  		if err != nil {
  2848  			return 0, err
  2849  		}
  2850  		i -= size
  2851  		i = encodeVarintGenerated(dAtA, i, uint64(size))
  2852  	}
  2853  	i--
  2854  	dAtA[i] = 0xa
  2855  	return len(dAtA) - i, nil
  2856  }
  2857  
  2858  func (m *IngressTLS) Marshal() (dAtA []byte, err error) {
  2859  	size := m.Size()
  2860  	dAtA = make([]byte, size)
  2861  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  2862  	if err != nil {
  2863  		return nil, err
  2864  	}
  2865  	return dAtA[:n], nil
  2866  }
  2867  
  2868  func (m *IngressTLS) MarshalTo(dAtA []byte) (int, error) {
  2869  	size := m.Size()
  2870  	return m.MarshalToSizedBuffer(dAtA[:size])
  2871  }
  2872  
  2873  func (m *IngressTLS) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  2874  	i := len(dAtA)
  2875  	_ = i
  2876  	var l int
  2877  	_ = l
  2878  	i -= len(m.SecretName)
  2879  	copy(dAtA[i:], m.SecretName)
  2880  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.SecretName)))
  2881  	i--
  2882  	dAtA[i] = 0x12
  2883  	if len(m.Hosts) > 0 {
  2884  		for iNdEx := len(m.Hosts) - 1; iNdEx >= 0; iNdEx-- {
  2885  			i -= len(m.Hosts[iNdEx])
  2886  			copy(dAtA[i:], m.Hosts[iNdEx])
  2887  			i = encodeVarintGenerated(dAtA, i, uint64(len(m.Hosts[iNdEx])))
  2888  			i--
  2889  			dAtA[i] = 0xa
  2890  		}
  2891  	}
  2892  	return len(dAtA) - i, nil
  2893  }
  2894  
  2895  func (m *NetworkPolicy) Marshal() (dAtA []byte, err error) {
  2896  	size := m.Size()
  2897  	dAtA = make([]byte, size)
  2898  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  2899  	if err != nil {
  2900  		return nil, err
  2901  	}
  2902  	return dAtA[:n], nil
  2903  }
  2904  
  2905  func (m *NetworkPolicy) MarshalTo(dAtA []byte) (int, error) {
  2906  	size := m.Size()
  2907  	return m.MarshalToSizedBuffer(dAtA[:size])
  2908  }
  2909  
  2910  func (m *NetworkPolicy) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  2911  	i := len(dAtA)
  2912  	_ = i
  2913  	var l int
  2914  	_ = l
  2915  	{
  2916  		size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i])
  2917  		if err != nil {
  2918  			return 0, err
  2919  		}
  2920  		i -= size
  2921  		i = encodeVarintGenerated(dAtA, i, uint64(size))
  2922  	}
  2923  	i--
  2924  	dAtA[i] = 0x12
  2925  	{
  2926  		size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
  2927  		if err != nil {
  2928  			return 0, err
  2929  		}
  2930  		i -= size
  2931  		i = encodeVarintGenerated(dAtA, i, uint64(size))
  2932  	}
  2933  	i--
  2934  	dAtA[i] = 0xa
  2935  	return len(dAtA) - i, nil
  2936  }
  2937  
  2938  func (m *NetworkPolicyEgressRule) Marshal() (dAtA []byte, err error) {
  2939  	size := m.Size()
  2940  	dAtA = make([]byte, size)
  2941  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  2942  	if err != nil {
  2943  		return nil, err
  2944  	}
  2945  	return dAtA[:n], nil
  2946  }
  2947  
  2948  func (m *NetworkPolicyEgressRule) MarshalTo(dAtA []byte) (int, error) {
  2949  	size := m.Size()
  2950  	return m.MarshalToSizedBuffer(dAtA[:size])
  2951  }
  2952  
  2953  func (m *NetworkPolicyEgressRule) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  2954  	i := len(dAtA)
  2955  	_ = i
  2956  	var l int
  2957  	_ = l
  2958  	if len(m.To) > 0 {
  2959  		for iNdEx := len(m.To) - 1; iNdEx >= 0; iNdEx-- {
  2960  			{
  2961  				size, err := m.To[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  2962  				if err != nil {
  2963  					return 0, err
  2964  				}
  2965  				i -= size
  2966  				i = encodeVarintGenerated(dAtA, i, uint64(size))
  2967  			}
  2968  			i--
  2969  			dAtA[i] = 0x12
  2970  		}
  2971  	}
  2972  	if len(m.Ports) > 0 {
  2973  		for iNdEx := len(m.Ports) - 1; iNdEx >= 0; iNdEx-- {
  2974  			{
  2975  				size, err := m.Ports[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  2976  				if err != nil {
  2977  					return 0, err
  2978  				}
  2979  				i -= size
  2980  				i = encodeVarintGenerated(dAtA, i, uint64(size))
  2981  			}
  2982  			i--
  2983  			dAtA[i] = 0xa
  2984  		}
  2985  	}
  2986  	return len(dAtA) - i, nil
  2987  }
  2988  
  2989  func (m *NetworkPolicyIngressRule) Marshal() (dAtA []byte, err error) {
  2990  	size := m.Size()
  2991  	dAtA = make([]byte, size)
  2992  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  2993  	if err != nil {
  2994  		return nil, err
  2995  	}
  2996  	return dAtA[:n], nil
  2997  }
  2998  
  2999  func (m *NetworkPolicyIngressRule) MarshalTo(dAtA []byte) (int, error) {
  3000  	size := m.Size()
  3001  	return m.MarshalToSizedBuffer(dAtA[:size])
  3002  }
  3003  
  3004  func (m *NetworkPolicyIngressRule) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  3005  	i := len(dAtA)
  3006  	_ = i
  3007  	var l int
  3008  	_ = l
  3009  	if len(m.From) > 0 {
  3010  		for iNdEx := len(m.From) - 1; iNdEx >= 0; iNdEx-- {
  3011  			{
  3012  				size, err := m.From[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  3013  				if err != nil {
  3014  					return 0, err
  3015  				}
  3016  				i -= size
  3017  				i = encodeVarintGenerated(dAtA, i, uint64(size))
  3018  			}
  3019  			i--
  3020  			dAtA[i] = 0x12
  3021  		}
  3022  	}
  3023  	if len(m.Ports) > 0 {
  3024  		for iNdEx := len(m.Ports) - 1; iNdEx >= 0; iNdEx-- {
  3025  			{
  3026  				size, err := m.Ports[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  3027  				if err != nil {
  3028  					return 0, err
  3029  				}
  3030  				i -= size
  3031  				i = encodeVarintGenerated(dAtA, i, uint64(size))
  3032  			}
  3033  			i--
  3034  			dAtA[i] = 0xa
  3035  		}
  3036  	}
  3037  	return len(dAtA) - i, nil
  3038  }
  3039  
  3040  func (m *NetworkPolicyList) Marshal() (dAtA []byte, err error) {
  3041  	size := m.Size()
  3042  	dAtA = make([]byte, size)
  3043  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  3044  	if err != nil {
  3045  		return nil, err
  3046  	}
  3047  	return dAtA[:n], nil
  3048  }
  3049  
  3050  func (m *NetworkPolicyList) MarshalTo(dAtA []byte) (int, error) {
  3051  	size := m.Size()
  3052  	return m.MarshalToSizedBuffer(dAtA[:size])
  3053  }
  3054  
  3055  func (m *NetworkPolicyList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  3056  	i := len(dAtA)
  3057  	_ = i
  3058  	var l int
  3059  	_ = l
  3060  	if len(m.Items) > 0 {
  3061  		for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
  3062  			{
  3063  				size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  3064  				if err != nil {
  3065  					return 0, err
  3066  				}
  3067  				i -= size
  3068  				i = encodeVarintGenerated(dAtA, i, uint64(size))
  3069  			}
  3070  			i--
  3071  			dAtA[i] = 0x12
  3072  		}
  3073  	}
  3074  	{
  3075  		size, err := m.ListMeta.MarshalToSizedBuffer(dAtA[:i])
  3076  		if err != nil {
  3077  			return 0, err
  3078  		}
  3079  		i -= size
  3080  		i = encodeVarintGenerated(dAtA, i, uint64(size))
  3081  	}
  3082  	i--
  3083  	dAtA[i] = 0xa
  3084  	return len(dAtA) - i, nil
  3085  }
  3086  
  3087  func (m *NetworkPolicyPeer) Marshal() (dAtA []byte, err error) {
  3088  	size := m.Size()
  3089  	dAtA = make([]byte, size)
  3090  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  3091  	if err != nil {
  3092  		return nil, err
  3093  	}
  3094  	return dAtA[:n], nil
  3095  }
  3096  
  3097  func (m *NetworkPolicyPeer) MarshalTo(dAtA []byte) (int, error) {
  3098  	size := m.Size()
  3099  	return m.MarshalToSizedBuffer(dAtA[:size])
  3100  }
  3101  
  3102  func (m *NetworkPolicyPeer) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  3103  	i := len(dAtA)
  3104  	_ = i
  3105  	var l int
  3106  	_ = l
  3107  	if m.IPBlock != nil {
  3108  		{
  3109  			size, err := m.IPBlock.MarshalToSizedBuffer(dAtA[:i])
  3110  			if err != nil {
  3111  				return 0, err
  3112  			}
  3113  			i -= size
  3114  			i = encodeVarintGenerated(dAtA, i, uint64(size))
  3115  		}
  3116  		i--
  3117  		dAtA[i] = 0x1a
  3118  	}
  3119  	if m.NamespaceSelector != nil {
  3120  		{
  3121  			size, err := m.NamespaceSelector.MarshalToSizedBuffer(dAtA[:i])
  3122  			if err != nil {
  3123  				return 0, err
  3124  			}
  3125  			i -= size
  3126  			i = encodeVarintGenerated(dAtA, i, uint64(size))
  3127  		}
  3128  		i--
  3129  		dAtA[i] = 0x12
  3130  	}
  3131  	if m.PodSelector != nil {
  3132  		{
  3133  			size, err := m.PodSelector.MarshalToSizedBuffer(dAtA[:i])
  3134  			if err != nil {
  3135  				return 0, err
  3136  			}
  3137  			i -= size
  3138  			i = encodeVarintGenerated(dAtA, i, uint64(size))
  3139  		}
  3140  		i--
  3141  		dAtA[i] = 0xa
  3142  	}
  3143  	return len(dAtA) - i, nil
  3144  }
  3145  
  3146  func (m *NetworkPolicyPort) Marshal() (dAtA []byte, err error) {
  3147  	size := m.Size()
  3148  	dAtA = make([]byte, size)
  3149  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  3150  	if err != nil {
  3151  		return nil, err
  3152  	}
  3153  	return dAtA[:n], nil
  3154  }
  3155  
  3156  func (m *NetworkPolicyPort) MarshalTo(dAtA []byte) (int, error) {
  3157  	size := m.Size()
  3158  	return m.MarshalToSizedBuffer(dAtA[:size])
  3159  }
  3160  
  3161  func (m *NetworkPolicyPort) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  3162  	i := len(dAtA)
  3163  	_ = i
  3164  	var l int
  3165  	_ = l
  3166  	if m.EndPort != nil {
  3167  		i = encodeVarintGenerated(dAtA, i, uint64(*m.EndPort))
  3168  		i--
  3169  		dAtA[i] = 0x18
  3170  	}
  3171  	if m.Port != nil {
  3172  		{
  3173  			size, err := m.Port.MarshalToSizedBuffer(dAtA[:i])
  3174  			if err != nil {
  3175  				return 0, err
  3176  			}
  3177  			i -= size
  3178  			i = encodeVarintGenerated(dAtA, i, uint64(size))
  3179  		}
  3180  		i--
  3181  		dAtA[i] = 0x12
  3182  	}
  3183  	if m.Protocol != nil {
  3184  		i -= len(*m.Protocol)
  3185  		copy(dAtA[i:], *m.Protocol)
  3186  		i = encodeVarintGenerated(dAtA, i, uint64(len(*m.Protocol)))
  3187  		i--
  3188  		dAtA[i] = 0xa
  3189  	}
  3190  	return len(dAtA) - i, nil
  3191  }
  3192  
  3193  func (m *NetworkPolicySpec) Marshal() (dAtA []byte, err error) {
  3194  	size := m.Size()
  3195  	dAtA = make([]byte, size)
  3196  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  3197  	if err != nil {
  3198  		return nil, err
  3199  	}
  3200  	return dAtA[:n], nil
  3201  }
  3202  
  3203  func (m *NetworkPolicySpec) MarshalTo(dAtA []byte) (int, error) {
  3204  	size := m.Size()
  3205  	return m.MarshalToSizedBuffer(dAtA[:size])
  3206  }
  3207  
  3208  func (m *NetworkPolicySpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  3209  	i := len(dAtA)
  3210  	_ = i
  3211  	var l int
  3212  	_ = l
  3213  	if len(m.PolicyTypes) > 0 {
  3214  		for iNdEx := len(m.PolicyTypes) - 1; iNdEx >= 0; iNdEx-- {
  3215  			i -= len(m.PolicyTypes[iNdEx])
  3216  			copy(dAtA[i:], m.PolicyTypes[iNdEx])
  3217  			i = encodeVarintGenerated(dAtA, i, uint64(len(m.PolicyTypes[iNdEx])))
  3218  			i--
  3219  			dAtA[i] = 0x22
  3220  		}
  3221  	}
  3222  	if len(m.Egress) > 0 {
  3223  		for iNdEx := len(m.Egress) - 1; iNdEx >= 0; iNdEx-- {
  3224  			{
  3225  				size, err := m.Egress[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  3226  				if err != nil {
  3227  					return 0, err
  3228  				}
  3229  				i -= size
  3230  				i = encodeVarintGenerated(dAtA, i, uint64(size))
  3231  			}
  3232  			i--
  3233  			dAtA[i] = 0x1a
  3234  		}
  3235  	}
  3236  	if len(m.Ingress) > 0 {
  3237  		for iNdEx := len(m.Ingress) - 1; iNdEx >= 0; iNdEx-- {
  3238  			{
  3239  				size, err := m.Ingress[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  3240  				if err != nil {
  3241  					return 0, err
  3242  				}
  3243  				i -= size
  3244  				i = encodeVarintGenerated(dAtA, i, uint64(size))
  3245  			}
  3246  			i--
  3247  			dAtA[i] = 0x12
  3248  		}
  3249  	}
  3250  	{
  3251  		size, err := m.PodSelector.MarshalToSizedBuffer(dAtA[:i])
  3252  		if err != nil {
  3253  			return 0, err
  3254  		}
  3255  		i -= size
  3256  		i = encodeVarintGenerated(dAtA, i, uint64(size))
  3257  	}
  3258  	i--
  3259  	dAtA[i] = 0xa
  3260  	return len(dAtA) - i, nil
  3261  }
  3262  
  3263  func (m *ReplicaSet) Marshal() (dAtA []byte, err error) {
  3264  	size := m.Size()
  3265  	dAtA = make([]byte, size)
  3266  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  3267  	if err != nil {
  3268  		return nil, err
  3269  	}
  3270  	return dAtA[:n], nil
  3271  }
  3272  
  3273  func (m *ReplicaSet) MarshalTo(dAtA []byte) (int, error) {
  3274  	size := m.Size()
  3275  	return m.MarshalToSizedBuffer(dAtA[:size])
  3276  }
  3277  
  3278  func (m *ReplicaSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  3279  	i := len(dAtA)
  3280  	_ = i
  3281  	var l int
  3282  	_ = l
  3283  	{
  3284  		size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
  3285  		if err != nil {
  3286  			return 0, err
  3287  		}
  3288  		i -= size
  3289  		i = encodeVarintGenerated(dAtA, i, uint64(size))
  3290  	}
  3291  	i--
  3292  	dAtA[i] = 0x1a
  3293  	{
  3294  		size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i])
  3295  		if err != nil {
  3296  			return 0, err
  3297  		}
  3298  		i -= size
  3299  		i = encodeVarintGenerated(dAtA, i, uint64(size))
  3300  	}
  3301  	i--
  3302  	dAtA[i] = 0x12
  3303  	{
  3304  		size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
  3305  		if err != nil {
  3306  			return 0, err
  3307  		}
  3308  		i -= size
  3309  		i = encodeVarintGenerated(dAtA, i, uint64(size))
  3310  	}
  3311  	i--
  3312  	dAtA[i] = 0xa
  3313  	return len(dAtA) - i, nil
  3314  }
  3315  
  3316  func (m *ReplicaSetCondition) Marshal() (dAtA []byte, err error) {
  3317  	size := m.Size()
  3318  	dAtA = make([]byte, size)
  3319  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  3320  	if err != nil {
  3321  		return nil, err
  3322  	}
  3323  	return dAtA[:n], nil
  3324  }
  3325  
  3326  func (m *ReplicaSetCondition) MarshalTo(dAtA []byte) (int, error) {
  3327  	size := m.Size()
  3328  	return m.MarshalToSizedBuffer(dAtA[:size])
  3329  }
  3330  
  3331  func (m *ReplicaSetCondition) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  3332  	i := len(dAtA)
  3333  	_ = i
  3334  	var l int
  3335  	_ = l
  3336  	i -= len(m.Message)
  3337  	copy(dAtA[i:], m.Message)
  3338  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message)))
  3339  	i--
  3340  	dAtA[i] = 0x2a
  3341  	i -= len(m.Reason)
  3342  	copy(dAtA[i:], m.Reason)
  3343  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Reason)))
  3344  	i--
  3345  	dAtA[i] = 0x22
  3346  	{
  3347  		size, err := m.LastTransitionTime.MarshalToSizedBuffer(dAtA[:i])
  3348  		if err != nil {
  3349  			return 0, err
  3350  		}
  3351  		i -= size
  3352  		i = encodeVarintGenerated(dAtA, i, uint64(size))
  3353  	}
  3354  	i--
  3355  	dAtA[i] = 0x1a
  3356  	i -= len(m.Status)
  3357  	copy(dAtA[i:], m.Status)
  3358  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Status)))
  3359  	i--
  3360  	dAtA[i] = 0x12
  3361  	i -= len(m.Type)
  3362  	copy(dAtA[i:], m.Type)
  3363  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
  3364  	i--
  3365  	dAtA[i] = 0xa
  3366  	return len(dAtA) - i, nil
  3367  }
  3368  
  3369  func (m *ReplicaSetList) Marshal() (dAtA []byte, err error) {
  3370  	size := m.Size()
  3371  	dAtA = make([]byte, size)
  3372  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  3373  	if err != nil {
  3374  		return nil, err
  3375  	}
  3376  	return dAtA[:n], nil
  3377  }
  3378  
  3379  func (m *ReplicaSetList) MarshalTo(dAtA []byte) (int, error) {
  3380  	size := m.Size()
  3381  	return m.MarshalToSizedBuffer(dAtA[:size])
  3382  }
  3383  
  3384  func (m *ReplicaSetList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  3385  	i := len(dAtA)
  3386  	_ = i
  3387  	var l int
  3388  	_ = l
  3389  	if len(m.Items) > 0 {
  3390  		for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
  3391  			{
  3392  				size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  3393  				if err != nil {
  3394  					return 0, err
  3395  				}
  3396  				i -= size
  3397  				i = encodeVarintGenerated(dAtA, i, uint64(size))
  3398  			}
  3399  			i--
  3400  			dAtA[i] = 0x12
  3401  		}
  3402  	}
  3403  	{
  3404  		size, err := m.ListMeta.MarshalToSizedBuffer(dAtA[:i])
  3405  		if err != nil {
  3406  			return 0, err
  3407  		}
  3408  		i -= size
  3409  		i = encodeVarintGenerated(dAtA, i, uint64(size))
  3410  	}
  3411  	i--
  3412  	dAtA[i] = 0xa
  3413  	return len(dAtA) - i, nil
  3414  }
  3415  
  3416  func (m *ReplicaSetSpec) Marshal() (dAtA []byte, err error) {
  3417  	size := m.Size()
  3418  	dAtA = make([]byte, size)
  3419  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  3420  	if err != nil {
  3421  		return nil, err
  3422  	}
  3423  	return dAtA[:n], nil
  3424  }
  3425  
  3426  func (m *ReplicaSetSpec) MarshalTo(dAtA []byte) (int, error) {
  3427  	size := m.Size()
  3428  	return m.MarshalToSizedBuffer(dAtA[:size])
  3429  }
  3430  
  3431  func (m *ReplicaSetSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  3432  	i := len(dAtA)
  3433  	_ = i
  3434  	var l int
  3435  	_ = l
  3436  	i = encodeVarintGenerated(dAtA, i, uint64(m.MinReadySeconds))
  3437  	i--
  3438  	dAtA[i] = 0x20
  3439  	{
  3440  		size, err := m.Template.MarshalToSizedBuffer(dAtA[:i])
  3441  		if err != nil {
  3442  			return 0, err
  3443  		}
  3444  		i -= size
  3445  		i = encodeVarintGenerated(dAtA, i, uint64(size))
  3446  	}
  3447  	i--
  3448  	dAtA[i] = 0x1a
  3449  	if m.Selector != nil {
  3450  		{
  3451  			size, err := m.Selector.MarshalToSizedBuffer(dAtA[:i])
  3452  			if err != nil {
  3453  				return 0, err
  3454  			}
  3455  			i -= size
  3456  			i = encodeVarintGenerated(dAtA, i, uint64(size))
  3457  		}
  3458  		i--
  3459  		dAtA[i] = 0x12
  3460  	}
  3461  	if m.Replicas != nil {
  3462  		i = encodeVarintGenerated(dAtA, i, uint64(*m.Replicas))
  3463  		i--
  3464  		dAtA[i] = 0x8
  3465  	}
  3466  	return len(dAtA) - i, nil
  3467  }
  3468  
  3469  func (m *ReplicaSetStatus) Marshal() (dAtA []byte, err error) {
  3470  	size := m.Size()
  3471  	dAtA = make([]byte, size)
  3472  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  3473  	if err != nil {
  3474  		return nil, err
  3475  	}
  3476  	return dAtA[:n], nil
  3477  }
  3478  
  3479  func (m *ReplicaSetStatus) MarshalTo(dAtA []byte) (int, error) {
  3480  	size := m.Size()
  3481  	return m.MarshalToSizedBuffer(dAtA[:size])
  3482  }
  3483  
  3484  func (m *ReplicaSetStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  3485  	i := len(dAtA)
  3486  	_ = i
  3487  	var l int
  3488  	_ = l
  3489  	if len(m.Conditions) > 0 {
  3490  		for iNdEx := len(m.Conditions) - 1; iNdEx >= 0; iNdEx-- {
  3491  			{
  3492  				size, err := m.Conditions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
  3493  				if err != nil {
  3494  					return 0, err
  3495  				}
  3496  				i -= size
  3497  				i = encodeVarintGenerated(dAtA, i, uint64(size))
  3498  			}
  3499  			i--
  3500  			dAtA[i] = 0x32
  3501  		}
  3502  	}
  3503  	i = encodeVarintGenerated(dAtA, i, uint64(m.AvailableReplicas))
  3504  	i--
  3505  	dAtA[i] = 0x28
  3506  	i = encodeVarintGenerated(dAtA, i, uint64(m.ReadyReplicas))
  3507  	i--
  3508  	dAtA[i] = 0x20
  3509  	i = encodeVarintGenerated(dAtA, i, uint64(m.ObservedGeneration))
  3510  	i--
  3511  	dAtA[i] = 0x18
  3512  	i = encodeVarintGenerated(dAtA, i, uint64(m.FullyLabeledReplicas))
  3513  	i--
  3514  	dAtA[i] = 0x10
  3515  	i = encodeVarintGenerated(dAtA, i, uint64(m.Replicas))
  3516  	i--
  3517  	dAtA[i] = 0x8
  3518  	return len(dAtA) - i, nil
  3519  }
  3520  
  3521  func (m *RollbackConfig) Marshal() (dAtA []byte, err error) {
  3522  	size := m.Size()
  3523  	dAtA = make([]byte, size)
  3524  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  3525  	if err != nil {
  3526  		return nil, err
  3527  	}
  3528  	return dAtA[:n], nil
  3529  }
  3530  
  3531  func (m *RollbackConfig) MarshalTo(dAtA []byte) (int, error) {
  3532  	size := m.Size()
  3533  	return m.MarshalToSizedBuffer(dAtA[:size])
  3534  }
  3535  
  3536  func (m *RollbackConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  3537  	i := len(dAtA)
  3538  	_ = i
  3539  	var l int
  3540  	_ = l
  3541  	i = encodeVarintGenerated(dAtA, i, uint64(m.Revision))
  3542  	i--
  3543  	dAtA[i] = 0x8
  3544  	return len(dAtA) - i, nil
  3545  }
  3546  
  3547  func (m *RollingUpdateDaemonSet) Marshal() (dAtA []byte, err error) {
  3548  	size := m.Size()
  3549  	dAtA = make([]byte, size)
  3550  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  3551  	if err != nil {
  3552  		return nil, err
  3553  	}
  3554  	return dAtA[:n], nil
  3555  }
  3556  
  3557  func (m *RollingUpdateDaemonSet) MarshalTo(dAtA []byte) (int, error) {
  3558  	size := m.Size()
  3559  	return m.MarshalToSizedBuffer(dAtA[:size])
  3560  }
  3561  
  3562  func (m *RollingUpdateDaemonSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  3563  	i := len(dAtA)
  3564  	_ = i
  3565  	var l int
  3566  	_ = l
  3567  	if m.MaxSurge != nil {
  3568  		{
  3569  			size, err := m.MaxSurge.MarshalToSizedBuffer(dAtA[:i])
  3570  			if err != nil {
  3571  				return 0, err
  3572  			}
  3573  			i -= size
  3574  			i = encodeVarintGenerated(dAtA, i, uint64(size))
  3575  		}
  3576  		i--
  3577  		dAtA[i] = 0x12
  3578  	}
  3579  	if m.MaxUnavailable != nil {
  3580  		{
  3581  			size, err := m.MaxUnavailable.MarshalToSizedBuffer(dAtA[:i])
  3582  			if err != nil {
  3583  				return 0, err
  3584  			}
  3585  			i -= size
  3586  			i = encodeVarintGenerated(dAtA, i, uint64(size))
  3587  		}
  3588  		i--
  3589  		dAtA[i] = 0xa
  3590  	}
  3591  	return len(dAtA) - i, nil
  3592  }
  3593  
  3594  func (m *RollingUpdateDeployment) Marshal() (dAtA []byte, err error) {
  3595  	size := m.Size()
  3596  	dAtA = make([]byte, size)
  3597  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  3598  	if err != nil {
  3599  		return nil, err
  3600  	}
  3601  	return dAtA[:n], nil
  3602  }
  3603  
  3604  func (m *RollingUpdateDeployment) MarshalTo(dAtA []byte) (int, error) {
  3605  	size := m.Size()
  3606  	return m.MarshalToSizedBuffer(dAtA[:size])
  3607  }
  3608  
  3609  func (m *RollingUpdateDeployment) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  3610  	i := len(dAtA)
  3611  	_ = i
  3612  	var l int
  3613  	_ = l
  3614  	if m.MaxSurge != nil {
  3615  		{
  3616  			size, err := m.MaxSurge.MarshalToSizedBuffer(dAtA[:i])
  3617  			if err != nil {
  3618  				return 0, err
  3619  			}
  3620  			i -= size
  3621  			i = encodeVarintGenerated(dAtA, i, uint64(size))
  3622  		}
  3623  		i--
  3624  		dAtA[i] = 0x12
  3625  	}
  3626  	if m.MaxUnavailable != nil {
  3627  		{
  3628  			size, err := m.MaxUnavailable.MarshalToSizedBuffer(dAtA[:i])
  3629  			if err != nil {
  3630  				return 0, err
  3631  			}
  3632  			i -= size
  3633  			i = encodeVarintGenerated(dAtA, i, uint64(size))
  3634  		}
  3635  		i--
  3636  		dAtA[i] = 0xa
  3637  	}
  3638  	return len(dAtA) - i, nil
  3639  }
  3640  
  3641  func (m *Scale) Marshal() (dAtA []byte, err error) {
  3642  	size := m.Size()
  3643  	dAtA = make([]byte, size)
  3644  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  3645  	if err != nil {
  3646  		return nil, err
  3647  	}
  3648  	return dAtA[:n], nil
  3649  }
  3650  
  3651  func (m *Scale) MarshalTo(dAtA []byte) (int, error) {
  3652  	size := m.Size()
  3653  	return m.MarshalToSizedBuffer(dAtA[:size])
  3654  }
  3655  
  3656  func (m *Scale) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  3657  	i := len(dAtA)
  3658  	_ = i
  3659  	var l int
  3660  	_ = l
  3661  	{
  3662  		size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
  3663  		if err != nil {
  3664  			return 0, err
  3665  		}
  3666  		i -= size
  3667  		i = encodeVarintGenerated(dAtA, i, uint64(size))
  3668  	}
  3669  	i--
  3670  	dAtA[i] = 0x1a
  3671  	{
  3672  		size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i])
  3673  		if err != nil {
  3674  			return 0, err
  3675  		}
  3676  		i -= size
  3677  		i = encodeVarintGenerated(dAtA, i, uint64(size))
  3678  	}
  3679  	i--
  3680  	dAtA[i] = 0x12
  3681  	{
  3682  		size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
  3683  		if err != nil {
  3684  			return 0, err
  3685  		}
  3686  		i -= size
  3687  		i = encodeVarintGenerated(dAtA, i, uint64(size))
  3688  	}
  3689  	i--
  3690  	dAtA[i] = 0xa
  3691  	return len(dAtA) - i, nil
  3692  }
  3693  
  3694  func (m *ScaleSpec) Marshal() (dAtA []byte, err error) {
  3695  	size := m.Size()
  3696  	dAtA = make([]byte, size)
  3697  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  3698  	if err != nil {
  3699  		return nil, err
  3700  	}
  3701  	return dAtA[:n], nil
  3702  }
  3703  
  3704  func (m *ScaleSpec) MarshalTo(dAtA []byte) (int, error) {
  3705  	size := m.Size()
  3706  	return m.MarshalToSizedBuffer(dAtA[:size])
  3707  }
  3708  
  3709  func (m *ScaleSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  3710  	i := len(dAtA)
  3711  	_ = i
  3712  	var l int
  3713  	_ = l
  3714  	i = encodeVarintGenerated(dAtA, i, uint64(m.Replicas))
  3715  	i--
  3716  	dAtA[i] = 0x8
  3717  	return len(dAtA) - i, nil
  3718  }
  3719  
  3720  func (m *ScaleStatus) Marshal() (dAtA []byte, err error) {
  3721  	size := m.Size()
  3722  	dAtA = make([]byte, size)
  3723  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
  3724  	if err != nil {
  3725  		return nil, err
  3726  	}
  3727  	return dAtA[:n], nil
  3728  }
  3729  
  3730  func (m *ScaleStatus) MarshalTo(dAtA []byte) (int, error) {
  3731  	size := m.Size()
  3732  	return m.MarshalToSizedBuffer(dAtA[:size])
  3733  }
  3734  
  3735  func (m *ScaleStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  3736  	i := len(dAtA)
  3737  	_ = i
  3738  	var l int
  3739  	_ = l
  3740  	i -= len(m.TargetSelector)
  3741  	copy(dAtA[i:], m.TargetSelector)
  3742  	i = encodeVarintGenerated(dAtA, i, uint64(len(m.TargetSelector)))
  3743  	i--
  3744  	dAtA[i] = 0x1a
  3745  	if len(m.Selector) > 0 {
  3746  		keysForSelector := make([]string, 0, len(m.Selector))
  3747  		for k := range m.Selector {
  3748  			keysForSelector = append(keysForSelector, string(k))
  3749  		}
  3750  		github_com_gogo_protobuf_sortkeys.Strings(keysForSelector)
  3751  		for iNdEx := len(keysForSelector) - 1; iNdEx >= 0; iNdEx-- {
  3752  			v := m.Selector[string(keysForSelector[iNdEx])]
  3753  			baseI := i
  3754  			i -= len(v)
  3755  			copy(dAtA[i:], v)
  3756  			i = encodeVarintGenerated(dAtA, i, uint64(len(v)))
  3757  			i--
  3758  			dAtA[i] = 0x12
  3759  			i -= len(keysForSelector[iNdEx])
  3760  			copy(dAtA[i:], keysForSelector[iNdEx])
  3761  			i = encodeVarintGenerated(dAtA, i, uint64(len(keysForSelector[iNdEx])))
  3762  			i--
  3763  			dAtA[i] = 0xa
  3764  			i = encodeVarintGenerated(dAtA, i, uint64(baseI-i))
  3765  			i--
  3766  			dAtA[i] = 0x12
  3767  		}
  3768  	}
  3769  	i = encodeVarintGenerated(dAtA, i, uint64(m.Replicas))
  3770  	i--
  3771  	dAtA[i] = 0x8
  3772  	return len(dAtA) - i, nil
  3773  }
  3774  
  3775  func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
  3776  	offset -= sovGenerated(v)
  3777  	base := offset
  3778  	for v >= 1<<7 {
  3779  		dAtA[offset] = uint8(v&0x7f | 0x80)
  3780  		v >>= 7
  3781  		offset++
  3782  	}
  3783  	dAtA[offset] = uint8(v)
  3784  	return base
  3785  }
  3786  func (m *DaemonSet) Size() (n int) {
  3787  	if m == nil {
  3788  		return 0
  3789  	}
  3790  	var l int
  3791  	_ = l
  3792  	l = m.ObjectMeta.Size()
  3793  	n += 1 + l + sovGenerated(uint64(l))
  3794  	l = m.Spec.Size()
  3795  	n += 1 + l + sovGenerated(uint64(l))
  3796  	l = m.Status.Size()
  3797  	n += 1 + l + sovGenerated(uint64(l))
  3798  	return n
  3799  }
  3800  
  3801  func (m *DaemonSetCondition) Size() (n int) {
  3802  	if m == nil {
  3803  		return 0
  3804  	}
  3805  	var l int
  3806  	_ = l
  3807  	l = len(m.Type)
  3808  	n += 1 + l + sovGenerated(uint64(l))
  3809  	l = len(m.Status)
  3810  	n += 1 + l + sovGenerated(uint64(l))
  3811  	l = m.LastTransitionTime.Size()
  3812  	n += 1 + l + sovGenerated(uint64(l))
  3813  	l = len(m.Reason)
  3814  	n += 1 + l + sovGenerated(uint64(l))
  3815  	l = len(m.Message)
  3816  	n += 1 + l + sovGenerated(uint64(l))
  3817  	return n
  3818  }
  3819  
  3820  func (m *DaemonSetList) Size() (n int) {
  3821  	if m == nil {
  3822  		return 0
  3823  	}
  3824  	var l int
  3825  	_ = l
  3826  	l = m.ListMeta.Size()
  3827  	n += 1 + l + sovGenerated(uint64(l))
  3828  	if len(m.Items) > 0 {
  3829  		for _, e := range m.Items {
  3830  			l = e.Size()
  3831  			n += 1 + l + sovGenerated(uint64(l))
  3832  		}
  3833  	}
  3834  	return n
  3835  }
  3836  
  3837  func (m *DaemonSetSpec) Size() (n int) {
  3838  	if m == nil {
  3839  		return 0
  3840  	}
  3841  	var l int
  3842  	_ = l
  3843  	if m.Selector != nil {
  3844  		l = m.Selector.Size()
  3845  		n += 1 + l + sovGenerated(uint64(l))
  3846  	}
  3847  	l = m.Template.Size()
  3848  	n += 1 + l + sovGenerated(uint64(l))
  3849  	l = m.UpdateStrategy.Size()
  3850  	n += 1 + l + sovGenerated(uint64(l))
  3851  	n += 1 + sovGenerated(uint64(m.MinReadySeconds))
  3852  	n += 1 + sovGenerated(uint64(m.TemplateGeneration))
  3853  	if m.RevisionHistoryLimit != nil {
  3854  		n += 1 + sovGenerated(uint64(*m.RevisionHistoryLimit))
  3855  	}
  3856  	return n
  3857  }
  3858  
  3859  func (m *DaemonSetStatus) Size() (n int) {
  3860  	if m == nil {
  3861  		return 0
  3862  	}
  3863  	var l int
  3864  	_ = l
  3865  	n += 1 + sovGenerated(uint64(m.CurrentNumberScheduled))
  3866  	n += 1 + sovGenerated(uint64(m.NumberMisscheduled))
  3867  	n += 1 + sovGenerated(uint64(m.DesiredNumberScheduled))
  3868  	n += 1 + sovGenerated(uint64(m.NumberReady))
  3869  	n += 1 + sovGenerated(uint64(m.ObservedGeneration))
  3870  	n += 1 + sovGenerated(uint64(m.UpdatedNumberScheduled))
  3871  	n += 1 + sovGenerated(uint64(m.NumberAvailable))
  3872  	n += 1 + sovGenerated(uint64(m.NumberUnavailable))
  3873  	if m.CollisionCount != nil {
  3874  		n += 1 + sovGenerated(uint64(*m.CollisionCount))
  3875  	}
  3876  	if len(m.Conditions) > 0 {
  3877  		for _, e := range m.Conditions {
  3878  			l = e.Size()
  3879  			n += 1 + l + sovGenerated(uint64(l))
  3880  		}
  3881  	}
  3882  	return n
  3883  }
  3884  
  3885  func (m *DaemonSetUpdateStrategy) Size() (n int) {
  3886  	if m == nil {
  3887  		return 0
  3888  	}
  3889  	var l int
  3890  	_ = l
  3891  	l = len(m.Type)
  3892  	n += 1 + l + sovGenerated(uint64(l))
  3893  	if m.RollingUpdate != nil {
  3894  		l = m.RollingUpdate.Size()
  3895  		n += 1 + l + sovGenerated(uint64(l))
  3896  	}
  3897  	return n
  3898  }
  3899  
  3900  func (m *Deployment) Size() (n int) {
  3901  	if m == nil {
  3902  		return 0
  3903  	}
  3904  	var l int
  3905  	_ = l
  3906  	l = m.ObjectMeta.Size()
  3907  	n += 1 + l + sovGenerated(uint64(l))
  3908  	l = m.Spec.Size()
  3909  	n += 1 + l + sovGenerated(uint64(l))
  3910  	l = m.Status.Size()
  3911  	n += 1 + l + sovGenerated(uint64(l))
  3912  	return n
  3913  }
  3914  
  3915  func (m *DeploymentCondition) Size() (n int) {
  3916  	if m == nil {
  3917  		return 0
  3918  	}
  3919  	var l int
  3920  	_ = l
  3921  	l = len(m.Type)
  3922  	n += 1 + l + sovGenerated(uint64(l))
  3923  	l = len(m.Status)
  3924  	n += 1 + l + sovGenerated(uint64(l))
  3925  	l = len(m.Reason)
  3926  	n += 1 + l + sovGenerated(uint64(l))
  3927  	l = len(m.Message)
  3928  	n += 1 + l + sovGenerated(uint64(l))
  3929  	l = m.LastUpdateTime.Size()
  3930  	n += 1 + l + sovGenerated(uint64(l))
  3931  	l = m.LastTransitionTime.Size()
  3932  	n += 1 + l + sovGenerated(uint64(l))
  3933  	return n
  3934  }
  3935  
  3936  func (m *DeploymentList) Size() (n int) {
  3937  	if m == nil {
  3938  		return 0
  3939  	}
  3940  	var l int
  3941  	_ = l
  3942  	l = m.ListMeta.Size()
  3943  	n += 1 + l + sovGenerated(uint64(l))
  3944  	if len(m.Items) > 0 {
  3945  		for _, e := range m.Items {
  3946  			l = e.Size()
  3947  			n += 1 + l + sovGenerated(uint64(l))
  3948  		}
  3949  	}
  3950  	return n
  3951  }
  3952  
  3953  func (m *DeploymentRollback) Size() (n int) {
  3954  	if m == nil {
  3955  		return 0
  3956  	}
  3957  	var l int
  3958  	_ = l
  3959  	l = len(m.Name)
  3960  	n += 1 + l + sovGenerated(uint64(l))
  3961  	if len(m.UpdatedAnnotations) > 0 {
  3962  		for k, v := range m.UpdatedAnnotations {
  3963  			_ = k
  3964  			_ = v
  3965  			mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
  3966  			n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
  3967  		}
  3968  	}
  3969  	l = m.RollbackTo.Size()
  3970  	n += 1 + l + sovGenerated(uint64(l))
  3971  	return n
  3972  }
  3973  
  3974  func (m *DeploymentSpec) Size() (n int) {
  3975  	if m == nil {
  3976  		return 0
  3977  	}
  3978  	var l int
  3979  	_ = l
  3980  	if m.Replicas != nil {
  3981  		n += 1 + sovGenerated(uint64(*m.Replicas))
  3982  	}
  3983  	if m.Selector != nil {
  3984  		l = m.Selector.Size()
  3985  		n += 1 + l + sovGenerated(uint64(l))
  3986  	}
  3987  	l = m.Template.Size()
  3988  	n += 1 + l + sovGenerated(uint64(l))
  3989  	l = m.Strategy.Size()
  3990  	n += 1 + l + sovGenerated(uint64(l))
  3991  	n += 1 + sovGenerated(uint64(m.MinReadySeconds))
  3992  	if m.RevisionHistoryLimit != nil {
  3993  		n += 1 + sovGenerated(uint64(*m.RevisionHistoryLimit))
  3994  	}
  3995  	n += 2
  3996  	if m.RollbackTo != nil {
  3997  		l = m.RollbackTo.Size()
  3998  		n += 1 + l + sovGenerated(uint64(l))
  3999  	}
  4000  	if m.ProgressDeadlineSeconds != nil {
  4001  		n += 1 + sovGenerated(uint64(*m.ProgressDeadlineSeconds))
  4002  	}
  4003  	return n
  4004  }
  4005  
  4006  func (m *DeploymentStatus) Size() (n int) {
  4007  	if m == nil {
  4008  		return 0
  4009  	}
  4010  	var l int
  4011  	_ = l
  4012  	n += 1 + sovGenerated(uint64(m.ObservedGeneration))
  4013  	n += 1 + sovGenerated(uint64(m.Replicas))
  4014  	n += 1 + sovGenerated(uint64(m.UpdatedReplicas))
  4015  	n += 1 + sovGenerated(uint64(m.AvailableReplicas))
  4016  	n += 1 + sovGenerated(uint64(m.UnavailableReplicas))
  4017  	if len(m.Conditions) > 0 {
  4018  		for _, e := range m.Conditions {
  4019  			l = e.Size()
  4020  			n += 1 + l + sovGenerated(uint64(l))
  4021  		}
  4022  	}
  4023  	n += 1 + sovGenerated(uint64(m.ReadyReplicas))
  4024  	if m.CollisionCount != nil {
  4025  		n += 1 + sovGenerated(uint64(*m.CollisionCount))
  4026  	}
  4027  	return n
  4028  }
  4029  
  4030  func (m *DeploymentStrategy) Size() (n int) {
  4031  	if m == nil {
  4032  		return 0
  4033  	}
  4034  	var l int
  4035  	_ = l
  4036  	l = len(m.Type)
  4037  	n += 1 + l + sovGenerated(uint64(l))
  4038  	if m.RollingUpdate != nil {
  4039  		l = m.RollingUpdate.Size()
  4040  		n += 1 + l + sovGenerated(uint64(l))
  4041  	}
  4042  	return n
  4043  }
  4044  
  4045  func (m *HTTPIngressPath) Size() (n int) {
  4046  	if m == nil {
  4047  		return 0
  4048  	}
  4049  	var l int
  4050  	_ = l
  4051  	l = len(m.Path)
  4052  	n += 1 + l + sovGenerated(uint64(l))
  4053  	l = m.Backend.Size()
  4054  	n += 1 + l + sovGenerated(uint64(l))
  4055  	if m.PathType != nil {
  4056  		l = len(*m.PathType)
  4057  		n += 1 + l + sovGenerated(uint64(l))
  4058  	}
  4059  	return n
  4060  }
  4061  
  4062  func (m *HTTPIngressRuleValue) Size() (n int) {
  4063  	if m == nil {
  4064  		return 0
  4065  	}
  4066  	var l int
  4067  	_ = l
  4068  	if len(m.Paths) > 0 {
  4069  		for _, e := range m.Paths {
  4070  			l = e.Size()
  4071  			n += 1 + l + sovGenerated(uint64(l))
  4072  		}
  4073  	}
  4074  	return n
  4075  }
  4076  
  4077  func (m *IPBlock) Size() (n int) {
  4078  	if m == nil {
  4079  		return 0
  4080  	}
  4081  	var l int
  4082  	_ = l
  4083  	l = len(m.CIDR)
  4084  	n += 1 + l + sovGenerated(uint64(l))
  4085  	if len(m.Except) > 0 {
  4086  		for _, s := range m.Except {
  4087  			l = len(s)
  4088  			n += 1 + l + sovGenerated(uint64(l))
  4089  		}
  4090  	}
  4091  	return n
  4092  }
  4093  
  4094  func (m *Ingress) Size() (n int) {
  4095  	if m == nil {
  4096  		return 0
  4097  	}
  4098  	var l int
  4099  	_ = l
  4100  	l = m.ObjectMeta.Size()
  4101  	n += 1 + l + sovGenerated(uint64(l))
  4102  	l = m.Spec.Size()
  4103  	n += 1 + l + sovGenerated(uint64(l))
  4104  	l = m.Status.Size()
  4105  	n += 1 + l + sovGenerated(uint64(l))
  4106  	return n
  4107  }
  4108  
  4109  func (m *IngressBackend) Size() (n int) {
  4110  	if m == nil {
  4111  		return 0
  4112  	}
  4113  	var l int
  4114  	_ = l
  4115  	l = len(m.ServiceName)
  4116  	n += 1 + l + sovGenerated(uint64(l))
  4117  	l = m.ServicePort.Size()
  4118  	n += 1 + l + sovGenerated(uint64(l))
  4119  	if m.Resource != nil {
  4120  		l = m.Resource.Size()
  4121  		n += 1 + l + sovGenerated(uint64(l))
  4122  	}
  4123  	return n
  4124  }
  4125  
  4126  func (m *IngressList) Size() (n int) {
  4127  	if m == nil {
  4128  		return 0
  4129  	}
  4130  	var l int
  4131  	_ = l
  4132  	l = m.ListMeta.Size()
  4133  	n += 1 + l + sovGenerated(uint64(l))
  4134  	if len(m.Items) > 0 {
  4135  		for _, e := range m.Items {
  4136  			l = e.Size()
  4137  			n += 1 + l + sovGenerated(uint64(l))
  4138  		}
  4139  	}
  4140  	return n
  4141  }
  4142  
  4143  func (m *IngressLoadBalancerIngress) Size() (n int) {
  4144  	if m == nil {
  4145  		return 0
  4146  	}
  4147  	var l int
  4148  	_ = l
  4149  	l = len(m.IP)
  4150  	n += 1 + l + sovGenerated(uint64(l))
  4151  	l = len(m.Hostname)
  4152  	n += 1 + l + sovGenerated(uint64(l))
  4153  	if len(m.Ports) > 0 {
  4154  		for _, e := range m.Ports {
  4155  			l = e.Size()
  4156  			n += 1 + l + sovGenerated(uint64(l))
  4157  		}
  4158  	}
  4159  	return n
  4160  }
  4161  
  4162  func (m *IngressLoadBalancerStatus) Size() (n int) {
  4163  	if m == nil {
  4164  		return 0
  4165  	}
  4166  	var l int
  4167  	_ = l
  4168  	if len(m.Ingress) > 0 {
  4169  		for _, e := range m.Ingress {
  4170  			l = e.Size()
  4171  			n += 1 + l + sovGenerated(uint64(l))
  4172  		}
  4173  	}
  4174  	return n
  4175  }
  4176  
  4177  func (m *IngressPortStatus) Size() (n int) {
  4178  	if m == nil {
  4179  		return 0
  4180  	}
  4181  	var l int
  4182  	_ = l
  4183  	n += 1 + sovGenerated(uint64(m.Port))
  4184  	l = len(m.Protocol)
  4185  	n += 1 + l + sovGenerated(uint64(l))
  4186  	if m.Error != nil {
  4187  		l = len(*m.Error)
  4188  		n += 1 + l + sovGenerated(uint64(l))
  4189  	}
  4190  	return n
  4191  }
  4192  
  4193  func (m *IngressRule) Size() (n int) {
  4194  	if m == nil {
  4195  		return 0
  4196  	}
  4197  	var l int
  4198  	_ = l
  4199  	l = len(m.Host)
  4200  	n += 1 + l + sovGenerated(uint64(l))
  4201  	l = m.IngressRuleValue.Size()
  4202  	n += 1 + l + sovGenerated(uint64(l))
  4203  	return n
  4204  }
  4205  
  4206  func (m *IngressRuleValue) Size() (n int) {
  4207  	if m == nil {
  4208  		return 0
  4209  	}
  4210  	var l int
  4211  	_ = l
  4212  	if m.HTTP != nil {
  4213  		l = m.HTTP.Size()
  4214  		n += 1 + l + sovGenerated(uint64(l))
  4215  	}
  4216  	return n
  4217  }
  4218  
  4219  func (m *IngressSpec) Size() (n int) {
  4220  	if m == nil {
  4221  		return 0
  4222  	}
  4223  	var l int
  4224  	_ = l
  4225  	if m.Backend != nil {
  4226  		l = m.Backend.Size()
  4227  		n += 1 + l + sovGenerated(uint64(l))
  4228  	}
  4229  	if len(m.TLS) > 0 {
  4230  		for _, e := range m.TLS {
  4231  			l = e.Size()
  4232  			n += 1 + l + sovGenerated(uint64(l))
  4233  		}
  4234  	}
  4235  	if len(m.Rules) > 0 {
  4236  		for _, e := range m.Rules {
  4237  			l = e.Size()
  4238  			n += 1 + l + sovGenerated(uint64(l))
  4239  		}
  4240  	}
  4241  	if m.IngressClassName != nil {
  4242  		l = len(*m.IngressClassName)
  4243  		n += 1 + l + sovGenerated(uint64(l))
  4244  	}
  4245  	return n
  4246  }
  4247  
  4248  func (m *IngressStatus) Size() (n int) {
  4249  	if m == nil {
  4250  		return 0
  4251  	}
  4252  	var l int
  4253  	_ = l
  4254  	l = m.LoadBalancer.Size()
  4255  	n += 1 + l + sovGenerated(uint64(l))
  4256  	return n
  4257  }
  4258  
  4259  func (m *IngressTLS) Size() (n int) {
  4260  	if m == nil {
  4261  		return 0
  4262  	}
  4263  	var l int
  4264  	_ = l
  4265  	if len(m.Hosts) > 0 {
  4266  		for _, s := range m.Hosts {
  4267  			l = len(s)
  4268  			n += 1 + l + sovGenerated(uint64(l))
  4269  		}
  4270  	}
  4271  	l = len(m.SecretName)
  4272  	n += 1 + l + sovGenerated(uint64(l))
  4273  	return n
  4274  }
  4275  
  4276  func (m *NetworkPolicy) Size() (n int) {
  4277  	if m == nil {
  4278  		return 0
  4279  	}
  4280  	var l int
  4281  	_ = l
  4282  	l = m.ObjectMeta.Size()
  4283  	n += 1 + l + sovGenerated(uint64(l))
  4284  	l = m.Spec.Size()
  4285  	n += 1 + l + sovGenerated(uint64(l))
  4286  	return n
  4287  }
  4288  
  4289  func (m *NetworkPolicyEgressRule) Size() (n int) {
  4290  	if m == nil {
  4291  		return 0
  4292  	}
  4293  	var l int
  4294  	_ = l
  4295  	if len(m.Ports) > 0 {
  4296  		for _, e := range m.Ports {
  4297  			l = e.Size()
  4298  			n += 1 + l + sovGenerated(uint64(l))
  4299  		}
  4300  	}
  4301  	if len(m.To) > 0 {
  4302  		for _, e := range m.To {
  4303  			l = e.Size()
  4304  			n += 1 + l + sovGenerated(uint64(l))
  4305  		}
  4306  	}
  4307  	return n
  4308  }
  4309  
  4310  func (m *NetworkPolicyIngressRule) Size() (n int) {
  4311  	if m == nil {
  4312  		return 0
  4313  	}
  4314  	var l int
  4315  	_ = l
  4316  	if len(m.Ports) > 0 {
  4317  		for _, e := range m.Ports {
  4318  			l = e.Size()
  4319  			n += 1 + l + sovGenerated(uint64(l))
  4320  		}
  4321  	}
  4322  	if len(m.From) > 0 {
  4323  		for _, e := range m.From {
  4324  			l = e.Size()
  4325  			n += 1 + l + sovGenerated(uint64(l))
  4326  		}
  4327  	}
  4328  	return n
  4329  }
  4330  
  4331  func (m *NetworkPolicyList) Size() (n int) {
  4332  	if m == nil {
  4333  		return 0
  4334  	}
  4335  	var l int
  4336  	_ = l
  4337  	l = m.ListMeta.Size()
  4338  	n += 1 + l + sovGenerated(uint64(l))
  4339  	if len(m.Items) > 0 {
  4340  		for _, e := range m.Items {
  4341  			l = e.Size()
  4342  			n += 1 + l + sovGenerated(uint64(l))
  4343  		}
  4344  	}
  4345  	return n
  4346  }
  4347  
  4348  func (m *NetworkPolicyPeer) Size() (n int) {
  4349  	if m == nil {
  4350  		return 0
  4351  	}
  4352  	var l int
  4353  	_ = l
  4354  	if m.PodSelector != nil {
  4355  		l = m.PodSelector.Size()
  4356  		n += 1 + l + sovGenerated(uint64(l))
  4357  	}
  4358  	if m.NamespaceSelector != nil {
  4359  		l = m.NamespaceSelector.Size()
  4360  		n += 1 + l + sovGenerated(uint64(l))
  4361  	}
  4362  	if m.IPBlock != nil {
  4363  		l = m.IPBlock.Size()
  4364  		n += 1 + l + sovGenerated(uint64(l))
  4365  	}
  4366  	return n
  4367  }
  4368  
  4369  func (m *NetworkPolicyPort) Size() (n int) {
  4370  	if m == nil {
  4371  		return 0
  4372  	}
  4373  	var l int
  4374  	_ = l
  4375  	if m.Protocol != nil {
  4376  		l = len(*m.Protocol)
  4377  		n += 1 + l + sovGenerated(uint64(l))
  4378  	}
  4379  	if m.Port != nil {
  4380  		l = m.Port.Size()
  4381  		n += 1 + l + sovGenerated(uint64(l))
  4382  	}
  4383  	if m.EndPort != nil {
  4384  		n += 1 + sovGenerated(uint64(*m.EndPort))
  4385  	}
  4386  	return n
  4387  }
  4388  
  4389  func (m *NetworkPolicySpec) Size() (n int) {
  4390  	if m == nil {
  4391  		return 0
  4392  	}
  4393  	var l int
  4394  	_ = l
  4395  	l = m.PodSelector.Size()
  4396  	n += 1 + l + sovGenerated(uint64(l))
  4397  	if len(m.Ingress) > 0 {
  4398  		for _, e := range m.Ingress {
  4399  			l = e.Size()
  4400  			n += 1 + l + sovGenerated(uint64(l))
  4401  		}
  4402  	}
  4403  	if len(m.Egress) > 0 {
  4404  		for _, e := range m.Egress {
  4405  			l = e.Size()
  4406  			n += 1 + l + sovGenerated(uint64(l))
  4407  		}
  4408  	}
  4409  	if len(m.PolicyTypes) > 0 {
  4410  		for _, s := range m.PolicyTypes {
  4411  			l = len(s)
  4412  			n += 1 + l + sovGenerated(uint64(l))
  4413  		}
  4414  	}
  4415  	return n
  4416  }
  4417  
  4418  func (m *ReplicaSet) Size() (n int) {
  4419  	if m == nil {
  4420  		return 0
  4421  	}
  4422  	var l int
  4423  	_ = l
  4424  	l = m.ObjectMeta.Size()
  4425  	n += 1 + l + sovGenerated(uint64(l))
  4426  	l = m.Spec.Size()
  4427  	n += 1 + l + sovGenerated(uint64(l))
  4428  	l = m.Status.Size()
  4429  	n += 1 + l + sovGenerated(uint64(l))
  4430  	return n
  4431  }
  4432  
  4433  func (m *ReplicaSetCondition) Size() (n int) {
  4434  	if m == nil {
  4435  		return 0
  4436  	}
  4437  	var l int
  4438  	_ = l
  4439  	l = len(m.Type)
  4440  	n += 1 + l + sovGenerated(uint64(l))
  4441  	l = len(m.Status)
  4442  	n += 1 + l + sovGenerated(uint64(l))
  4443  	l = m.LastTransitionTime.Size()
  4444  	n += 1 + l + sovGenerated(uint64(l))
  4445  	l = len(m.Reason)
  4446  	n += 1 + l + sovGenerated(uint64(l))
  4447  	l = len(m.Message)
  4448  	n += 1 + l + sovGenerated(uint64(l))
  4449  	return n
  4450  }
  4451  
  4452  func (m *ReplicaSetList) Size() (n int) {
  4453  	if m == nil {
  4454  		return 0
  4455  	}
  4456  	var l int
  4457  	_ = l
  4458  	l = m.ListMeta.Size()
  4459  	n += 1 + l + sovGenerated(uint64(l))
  4460  	if len(m.Items) > 0 {
  4461  		for _, e := range m.Items {
  4462  			l = e.Size()
  4463  			n += 1 + l + sovGenerated(uint64(l))
  4464  		}
  4465  	}
  4466  	return n
  4467  }
  4468  
  4469  func (m *ReplicaSetSpec) Size() (n int) {
  4470  	if m == nil {
  4471  		return 0
  4472  	}
  4473  	var l int
  4474  	_ = l
  4475  	if m.Replicas != nil {
  4476  		n += 1 + sovGenerated(uint64(*m.Replicas))
  4477  	}
  4478  	if m.Selector != nil {
  4479  		l = m.Selector.Size()
  4480  		n += 1 + l + sovGenerated(uint64(l))
  4481  	}
  4482  	l = m.Template.Size()
  4483  	n += 1 + l + sovGenerated(uint64(l))
  4484  	n += 1 + sovGenerated(uint64(m.MinReadySeconds))
  4485  	return n
  4486  }
  4487  
  4488  func (m *ReplicaSetStatus) Size() (n int) {
  4489  	if m == nil {
  4490  		return 0
  4491  	}
  4492  	var l int
  4493  	_ = l
  4494  	n += 1 + sovGenerated(uint64(m.Replicas))
  4495  	n += 1 + sovGenerated(uint64(m.FullyLabeledReplicas))
  4496  	n += 1 + sovGenerated(uint64(m.ObservedGeneration))
  4497  	n += 1 + sovGenerated(uint64(m.ReadyReplicas))
  4498  	n += 1 + sovGenerated(uint64(m.AvailableReplicas))
  4499  	if len(m.Conditions) > 0 {
  4500  		for _, e := range m.Conditions {
  4501  			l = e.Size()
  4502  			n += 1 + l + sovGenerated(uint64(l))
  4503  		}
  4504  	}
  4505  	return n
  4506  }
  4507  
  4508  func (m *RollbackConfig) Size() (n int) {
  4509  	if m == nil {
  4510  		return 0
  4511  	}
  4512  	var l int
  4513  	_ = l
  4514  	n += 1 + sovGenerated(uint64(m.Revision))
  4515  	return n
  4516  }
  4517  
  4518  func (m *RollingUpdateDaemonSet) Size() (n int) {
  4519  	if m == nil {
  4520  		return 0
  4521  	}
  4522  	var l int
  4523  	_ = l
  4524  	if m.MaxUnavailable != nil {
  4525  		l = m.MaxUnavailable.Size()
  4526  		n += 1 + l + sovGenerated(uint64(l))
  4527  	}
  4528  	if m.MaxSurge != nil {
  4529  		l = m.MaxSurge.Size()
  4530  		n += 1 + l + sovGenerated(uint64(l))
  4531  	}
  4532  	return n
  4533  }
  4534  
  4535  func (m *RollingUpdateDeployment) Size() (n int) {
  4536  	if m == nil {
  4537  		return 0
  4538  	}
  4539  	var l int
  4540  	_ = l
  4541  	if m.MaxUnavailable != nil {
  4542  		l = m.MaxUnavailable.Size()
  4543  		n += 1 + l + sovGenerated(uint64(l))
  4544  	}
  4545  	if m.MaxSurge != nil {
  4546  		l = m.MaxSurge.Size()
  4547  		n += 1 + l + sovGenerated(uint64(l))
  4548  	}
  4549  	return n
  4550  }
  4551  
  4552  func (m *Scale) Size() (n int) {
  4553  	if m == nil {
  4554  		return 0
  4555  	}
  4556  	var l int
  4557  	_ = l
  4558  	l = m.ObjectMeta.Size()
  4559  	n += 1 + l + sovGenerated(uint64(l))
  4560  	l = m.Spec.Size()
  4561  	n += 1 + l + sovGenerated(uint64(l))
  4562  	l = m.Status.Size()
  4563  	n += 1 + l + sovGenerated(uint64(l))
  4564  	return n
  4565  }
  4566  
  4567  func (m *ScaleSpec) Size() (n int) {
  4568  	if m == nil {
  4569  		return 0
  4570  	}
  4571  	var l int
  4572  	_ = l
  4573  	n += 1 + sovGenerated(uint64(m.Replicas))
  4574  	return n
  4575  }
  4576  
  4577  func (m *ScaleStatus) Size() (n int) {
  4578  	if m == nil {
  4579  		return 0
  4580  	}
  4581  	var l int
  4582  	_ = l
  4583  	n += 1 + sovGenerated(uint64(m.Replicas))
  4584  	if len(m.Selector) > 0 {
  4585  		for k, v := range m.Selector {
  4586  			_ = k
  4587  			_ = v
  4588  			mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v)))
  4589  			n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
  4590  		}
  4591  	}
  4592  	l = len(m.TargetSelector)
  4593  	n += 1 + l + sovGenerated(uint64(l))
  4594  	return n
  4595  }
  4596  
  4597  func sovGenerated(x uint64) (n int) {
  4598  	return (math_bits.Len64(x|1) + 6) / 7
  4599  }
  4600  func sozGenerated(x uint64) (n int) {
  4601  	return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
  4602  }
  4603  func (this *DaemonSet) String() string {
  4604  	if this == nil {
  4605  		return "nil"
  4606  	}
  4607  	s := strings.Join([]string{`&DaemonSet{`,
  4608  		`ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
  4609  		`Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "DaemonSetSpec", "DaemonSetSpec", 1), `&`, ``, 1) + `,`,
  4610  		`Status:` + strings.Replace(strings.Replace(this.Status.String(), "DaemonSetStatus", "DaemonSetStatus", 1), `&`, ``, 1) + `,`,
  4611  		`}`,
  4612  	}, "")
  4613  	return s
  4614  }
  4615  func (this *DaemonSetCondition) String() string {
  4616  	if this == nil {
  4617  		return "nil"
  4618  	}
  4619  	s := strings.Join([]string{`&DaemonSetCondition{`,
  4620  		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
  4621  		`Status:` + fmt.Sprintf("%v", this.Status) + `,`,
  4622  		`LastTransitionTime:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.LastTransitionTime), "Time", "v1.Time", 1), `&`, ``, 1) + `,`,
  4623  		`Reason:` + fmt.Sprintf("%v", this.Reason) + `,`,
  4624  		`Message:` + fmt.Sprintf("%v", this.Message) + `,`,
  4625  		`}`,
  4626  	}, "")
  4627  	return s
  4628  }
  4629  func (this *DaemonSetList) String() string {
  4630  	if this == nil {
  4631  		return "nil"
  4632  	}
  4633  	repeatedStringForItems := "[]DaemonSet{"
  4634  	for _, f := range this.Items {
  4635  		repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "DaemonSet", "DaemonSet", 1), `&`, ``, 1) + ","
  4636  	}
  4637  	repeatedStringForItems += "}"
  4638  	s := strings.Join([]string{`&DaemonSetList{`,
  4639  		`ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`,
  4640  		`Items:` + repeatedStringForItems + `,`,
  4641  		`}`,
  4642  	}, "")
  4643  	return s
  4644  }
  4645  func (this *DaemonSetSpec) String() string {
  4646  	if this == nil {
  4647  		return "nil"
  4648  	}
  4649  	s := strings.Join([]string{`&DaemonSetSpec{`,
  4650  		`Selector:` + strings.Replace(fmt.Sprintf("%v", this.Selector), "LabelSelector", "v1.LabelSelector", 1) + `,`,
  4651  		`Template:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Template), "PodTemplateSpec", "v11.PodTemplateSpec", 1), `&`, ``, 1) + `,`,
  4652  		`UpdateStrategy:` + strings.Replace(strings.Replace(this.UpdateStrategy.String(), "DaemonSetUpdateStrategy", "DaemonSetUpdateStrategy", 1), `&`, ``, 1) + `,`,
  4653  		`MinReadySeconds:` + fmt.Sprintf("%v", this.MinReadySeconds) + `,`,
  4654  		`TemplateGeneration:` + fmt.Sprintf("%v", this.TemplateGeneration) + `,`,
  4655  		`RevisionHistoryLimit:` + valueToStringGenerated(this.RevisionHistoryLimit) + `,`,
  4656  		`}`,
  4657  	}, "")
  4658  	return s
  4659  }
  4660  func (this *DaemonSetStatus) String() string {
  4661  	if this == nil {
  4662  		return "nil"
  4663  	}
  4664  	repeatedStringForConditions := "[]DaemonSetCondition{"
  4665  	for _, f := range this.Conditions {
  4666  		repeatedStringForConditions += strings.Replace(strings.Replace(f.String(), "DaemonSetCondition", "DaemonSetCondition", 1), `&`, ``, 1) + ","
  4667  	}
  4668  	repeatedStringForConditions += "}"
  4669  	s := strings.Join([]string{`&DaemonSetStatus{`,
  4670  		`CurrentNumberScheduled:` + fmt.Sprintf("%v", this.CurrentNumberScheduled) + `,`,
  4671  		`NumberMisscheduled:` + fmt.Sprintf("%v", this.NumberMisscheduled) + `,`,
  4672  		`DesiredNumberScheduled:` + fmt.Sprintf("%v", this.DesiredNumberScheduled) + `,`,
  4673  		`NumberReady:` + fmt.Sprintf("%v", this.NumberReady) + `,`,
  4674  		`ObservedGeneration:` + fmt.Sprintf("%v", this.ObservedGeneration) + `,`,
  4675  		`UpdatedNumberScheduled:` + fmt.Sprintf("%v", this.UpdatedNumberScheduled) + `,`,
  4676  		`NumberAvailable:` + fmt.Sprintf("%v", this.NumberAvailable) + `,`,
  4677  		`NumberUnavailable:` + fmt.Sprintf("%v", this.NumberUnavailable) + `,`,
  4678  		`CollisionCount:` + valueToStringGenerated(this.CollisionCount) + `,`,
  4679  		`Conditions:` + repeatedStringForConditions + `,`,
  4680  		`}`,
  4681  	}, "")
  4682  	return s
  4683  }
  4684  func (this *DaemonSetUpdateStrategy) String() string {
  4685  	if this == nil {
  4686  		return "nil"
  4687  	}
  4688  	s := strings.Join([]string{`&DaemonSetUpdateStrategy{`,
  4689  		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
  4690  		`RollingUpdate:` + strings.Replace(this.RollingUpdate.String(), "RollingUpdateDaemonSet", "RollingUpdateDaemonSet", 1) + `,`,
  4691  		`}`,
  4692  	}, "")
  4693  	return s
  4694  }
  4695  func (this *Deployment) String() string {
  4696  	if this == nil {
  4697  		return "nil"
  4698  	}
  4699  	s := strings.Join([]string{`&Deployment{`,
  4700  		`ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
  4701  		`Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "DeploymentSpec", "DeploymentSpec", 1), `&`, ``, 1) + `,`,
  4702  		`Status:` + strings.Replace(strings.Replace(this.Status.String(), "DeploymentStatus", "DeploymentStatus", 1), `&`, ``, 1) + `,`,
  4703  		`}`,
  4704  	}, "")
  4705  	return s
  4706  }
  4707  func (this *DeploymentCondition) String() string {
  4708  	if this == nil {
  4709  		return "nil"
  4710  	}
  4711  	s := strings.Join([]string{`&DeploymentCondition{`,
  4712  		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
  4713  		`Status:` + fmt.Sprintf("%v", this.Status) + `,`,
  4714  		`Reason:` + fmt.Sprintf("%v", this.Reason) + `,`,
  4715  		`Message:` + fmt.Sprintf("%v", this.Message) + `,`,
  4716  		`LastUpdateTime:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.LastUpdateTime), "Time", "v1.Time", 1), `&`, ``, 1) + `,`,
  4717  		`LastTransitionTime:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.LastTransitionTime), "Time", "v1.Time", 1), `&`, ``, 1) + `,`,
  4718  		`}`,
  4719  	}, "")
  4720  	return s
  4721  }
  4722  func (this *DeploymentList) String() string {
  4723  	if this == nil {
  4724  		return "nil"
  4725  	}
  4726  	repeatedStringForItems := "[]Deployment{"
  4727  	for _, f := range this.Items {
  4728  		repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "Deployment", "Deployment", 1), `&`, ``, 1) + ","
  4729  	}
  4730  	repeatedStringForItems += "}"
  4731  	s := strings.Join([]string{`&DeploymentList{`,
  4732  		`ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`,
  4733  		`Items:` + repeatedStringForItems + `,`,
  4734  		`}`,
  4735  	}, "")
  4736  	return s
  4737  }
  4738  func (this *DeploymentRollback) String() string {
  4739  	if this == nil {
  4740  		return "nil"
  4741  	}
  4742  	keysForUpdatedAnnotations := make([]string, 0, len(this.UpdatedAnnotations))
  4743  	for k := range this.UpdatedAnnotations {
  4744  		keysForUpdatedAnnotations = append(keysForUpdatedAnnotations, k)
  4745  	}
  4746  	github_com_gogo_protobuf_sortkeys.Strings(keysForUpdatedAnnotations)
  4747  	mapStringForUpdatedAnnotations := "map[string]string{"
  4748  	for _, k := range keysForUpdatedAnnotations {
  4749  		mapStringForUpdatedAnnotations += fmt.Sprintf("%v: %v,", k, this.UpdatedAnnotations[k])
  4750  	}
  4751  	mapStringForUpdatedAnnotations += "}"
  4752  	s := strings.Join([]string{`&DeploymentRollback{`,
  4753  		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
  4754  		`UpdatedAnnotations:` + mapStringForUpdatedAnnotations + `,`,
  4755  		`RollbackTo:` + strings.Replace(strings.Replace(this.RollbackTo.String(), "RollbackConfig", "RollbackConfig", 1), `&`, ``, 1) + `,`,
  4756  		`}`,
  4757  	}, "")
  4758  	return s
  4759  }
  4760  func (this *DeploymentSpec) String() string {
  4761  	if this == nil {
  4762  		return "nil"
  4763  	}
  4764  	s := strings.Join([]string{`&DeploymentSpec{`,
  4765  		`Replicas:` + valueToStringGenerated(this.Replicas) + `,`,
  4766  		`Selector:` + strings.Replace(fmt.Sprintf("%v", this.Selector), "LabelSelector", "v1.LabelSelector", 1) + `,`,
  4767  		`Template:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Template), "PodTemplateSpec", "v11.PodTemplateSpec", 1), `&`, ``, 1) + `,`,
  4768  		`Strategy:` + strings.Replace(strings.Replace(this.Strategy.String(), "DeploymentStrategy", "DeploymentStrategy", 1), `&`, ``, 1) + `,`,
  4769  		`MinReadySeconds:` + fmt.Sprintf("%v", this.MinReadySeconds) + `,`,
  4770  		`RevisionHistoryLimit:` + valueToStringGenerated(this.RevisionHistoryLimit) + `,`,
  4771  		`Paused:` + fmt.Sprintf("%v", this.Paused) + `,`,
  4772  		`RollbackTo:` + strings.Replace(this.RollbackTo.String(), "RollbackConfig", "RollbackConfig", 1) + `,`,
  4773  		`ProgressDeadlineSeconds:` + valueToStringGenerated(this.ProgressDeadlineSeconds) + `,`,
  4774  		`}`,
  4775  	}, "")
  4776  	return s
  4777  }
  4778  func (this *DeploymentStatus) String() string {
  4779  	if this == nil {
  4780  		return "nil"
  4781  	}
  4782  	repeatedStringForConditions := "[]DeploymentCondition{"
  4783  	for _, f := range this.Conditions {
  4784  		repeatedStringForConditions += strings.Replace(strings.Replace(f.String(), "DeploymentCondition", "DeploymentCondition", 1), `&`, ``, 1) + ","
  4785  	}
  4786  	repeatedStringForConditions += "}"
  4787  	s := strings.Join([]string{`&DeploymentStatus{`,
  4788  		`ObservedGeneration:` + fmt.Sprintf("%v", this.ObservedGeneration) + `,`,
  4789  		`Replicas:` + fmt.Sprintf("%v", this.Replicas) + `,`,
  4790  		`UpdatedReplicas:` + fmt.Sprintf("%v", this.UpdatedReplicas) + `,`,
  4791  		`AvailableReplicas:` + fmt.Sprintf("%v", this.AvailableReplicas) + `,`,
  4792  		`UnavailableReplicas:` + fmt.Sprintf("%v", this.UnavailableReplicas) + `,`,
  4793  		`Conditions:` + repeatedStringForConditions + `,`,
  4794  		`ReadyReplicas:` + fmt.Sprintf("%v", this.ReadyReplicas) + `,`,
  4795  		`CollisionCount:` + valueToStringGenerated(this.CollisionCount) + `,`,
  4796  		`}`,
  4797  	}, "")
  4798  	return s
  4799  }
  4800  func (this *DeploymentStrategy) String() string {
  4801  	if this == nil {
  4802  		return "nil"
  4803  	}
  4804  	s := strings.Join([]string{`&DeploymentStrategy{`,
  4805  		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
  4806  		`RollingUpdate:` + strings.Replace(this.RollingUpdate.String(), "RollingUpdateDeployment", "RollingUpdateDeployment", 1) + `,`,
  4807  		`}`,
  4808  	}, "")
  4809  	return s
  4810  }
  4811  func (this *HTTPIngressPath) String() string {
  4812  	if this == nil {
  4813  		return "nil"
  4814  	}
  4815  	s := strings.Join([]string{`&HTTPIngressPath{`,
  4816  		`Path:` + fmt.Sprintf("%v", this.Path) + `,`,
  4817  		`Backend:` + strings.Replace(strings.Replace(this.Backend.String(), "IngressBackend", "IngressBackend", 1), `&`, ``, 1) + `,`,
  4818  		`PathType:` + valueToStringGenerated(this.PathType) + `,`,
  4819  		`}`,
  4820  	}, "")
  4821  	return s
  4822  }
  4823  func (this *HTTPIngressRuleValue) String() string {
  4824  	if this == nil {
  4825  		return "nil"
  4826  	}
  4827  	repeatedStringForPaths := "[]HTTPIngressPath{"
  4828  	for _, f := range this.Paths {
  4829  		repeatedStringForPaths += strings.Replace(strings.Replace(f.String(), "HTTPIngressPath", "HTTPIngressPath", 1), `&`, ``, 1) + ","
  4830  	}
  4831  	repeatedStringForPaths += "}"
  4832  	s := strings.Join([]string{`&HTTPIngressRuleValue{`,
  4833  		`Paths:` + repeatedStringForPaths + `,`,
  4834  		`}`,
  4835  	}, "")
  4836  	return s
  4837  }
  4838  func (this *IPBlock) String() string {
  4839  	if this == nil {
  4840  		return "nil"
  4841  	}
  4842  	s := strings.Join([]string{`&IPBlock{`,
  4843  		`CIDR:` + fmt.Sprintf("%v", this.CIDR) + `,`,
  4844  		`Except:` + fmt.Sprintf("%v", this.Except) + `,`,
  4845  		`}`,
  4846  	}, "")
  4847  	return s
  4848  }
  4849  func (this *Ingress) String() string {
  4850  	if this == nil {
  4851  		return "nil"
  4852  	}
  4853  	s := strings.Join([]string{`&Ingress{`,
  4854  		`ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
  4855  		`Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "IngressSpec", "IngressSpec", 1), `&`, ``, 1) + `,`,
  4856  		`Status:` + strings.Replace(strings.Replace(this.Status.String(), "IngressStatus", "IngressStatus", 1), `&`, ``, 1) + `,`,
  4857  		`}`,
  4858  	}, "")
  4859  	return s
  4860  }
  4861  func (this *IngressBackend) String() string {
  4862  	if this == nil {
  4863  		return "nil"
  4864  	}
  4865  	s := strings.Join([]string{`&IngressBackend{`,
  4866  		`ServiceName:` + fmt.Sprintf("%v", this.ServiceName) + `,`,
  4867  		`ServicePort:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ServicePort), "IntOrString", "intstr.IntOrString", 1), `&`, ``, 1) + `,`,
  4868  		`Resource:` + strings.Replace(fmt.Sprintf("%v", this.Resource), "TypedLocalObjectReference", "v11.TypedLocalObjectReference", 1) + `,`,
  4869  		`}`,
  4870  	}, "")
  4871  	return s
  4872  }
  4873  func (this *IngressList) String() string {
  4874  	if this == nil {
  4875  		return "nil"
  4876  	}
  4877  	repeatedStringForItems := "[]Ingress{"
  4878  	for _, f := range this.Items {
  4879  		repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "Ingress", "Ingress", 1), `&`, ``, 1) + ","
  4880  	}
  4881  	repeatedStringForItems += "}"
  4882  	s := strings.Join([]string{`&IngressList{`,
  4883  		`ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`,
  4884  		`Items:` + repeatedStringForItems + `,`,
  4885  		`}`,
  4886  	}, "")
  4887  	return s
  4888  }
  4889  func (this *IngressLoadBalancerIngress) String() string {
  4890  	if this == nil {
  4891  		return "nil"
  4892  	}
  4893  	repeatedStringForPorts := "[]IngressPortStatus{"
  4894  	for _, f := range this.Ports {
  4895  		repeatedStringForPorts += strings.Replace(strings.Replace(f.String(), "IngressPortStatus", "IngressPortStatus", 1), `&`, ``, 1) + ","
  4896  	}
  4897  	repeatedStringForPorts += "}"
  4898  	s := strings.Join([]string{`&IngressLoadBalancerIngress{`,
  4899  		`IP:` + fmt.Sprintf("%v", this.IP) + `,`,
  4900  		`Hostname:` + fmt.Sprintf("%v", this.Hostname) + `,`,
  4901  		`Ports:` + repeatedStringForPorts + `,`,
  4902  		`}`,
  4903  	}, "")
  4904  	return s
  4905  }
  4906  func (this *IngressLoadBalancerStatus) String() string {
  4907  	if this == nil {
  4908  		return "nil"
  4909  	}
  4910  	repeatedStringForIngress := "[]IngressLoadBalancerIngress{"
  4911  	for _, f := range this.Ingress {
  4912  		repeatedStringForIngress += strings.Replace(strings.Replace(f.String(), "IngressLoadBalancerIngress", "IngressLoadBalancerIngress", 1), `&`, ``, 1) + ","
  4913  	}
  4914  	repeatedStringForIngress += "}"
  4915  	s := strings.Join([]string{`&IngressLoadBalancerStatus{`,
  4916  		`Ingress:` + repeatedStringForIngress + `,`,
  4917  		`}`,
  4918  	}, "")
  4919  	return s
  4920  }
  4921  func (this *IngressPortStatus) String() string {
  4922  	if this == nil {
  4923  		return "nil"
  4924  	}
  4925  	s := strings.Join([]string{`&IngressPortStatus{`,
  4926  		`Port:` + fmt.Sprintf("%v", this.Port) + `,`,
  4927  		`Protocol:` + fmt.Sprintf("%v", this.Protocol) + `,`,
  4928  		`Error:` + valueToStringGenerated(this.Error) + `,`,
  4929  		`}`,
  4930  	}, "")
  4931  	return s
  4932  }
  4933  func (this *IngressRule) String() string {
  4934  	if this == nil {
  4935  		return "nil"
  4936  	}
  4937  	s := strings.Join([]string{`&IngressRule{`,
  4938  		`Host:` + fmt.Sprintf("%v", this.Host) + `,`,
  4939  		`IngressRuleValue:` + strings.Replace(strings.Replace(this.IngressRuleValue.String(), "IngressRuleValue", "IngressRuleValue", 1), `&`, ``, 1) + `,`,
  4940  		`}`,
  4941  	}, "")
  4942  	return s
  4943  }
  4944  func (this *IngressRuleValue) String() string {
  4945  	if this == nil {
  4946  		return "nil"
  4947  	}
  4948  	s := strings.Join([]string{`&IngressRuleValue{`,
  4949  		`HTTP:` + strings.Replace(this.HTTP.String(), "HTTPIngressRuleValue", "HTTPIngressRuleValue", 1) + `,`,
  4950  		`}`,
  4951  	}, "")
  4952  	return s
  4953  }
  4954  func (this *IngressSpec) String() string {
  4955  	if this == nil {
  4956  		return "nil"
  4957  	}
  4958  	repeatedStringForTLS := "[]IngressTLS{"
  4959  	for _, f := range this.TLS {
  4960  		repeatedStringForTLS += strings.Replace(strings.Replace(f.String(), "IngressTLS", "IngressTLS", 1), `&`, ``, 1) + ","
  4961  	}
  4962  	repeatedStringForTLS += "}"
  4963  	repeatedStringForRules := "[]IngressRule{"
  4964  	for _, f := range this.Rules {
  4965  		repeatedStringForRules += strings.Replace(strings.Replace(f.String(), "IngressRule", "IngressRule", 1), `&`, ``, 1) + ","
  4966  	}
  4967  	repeatedStringForRules += "}"
  4968  	s := strings.Join([]string{`&IngressSpec{`,
  4969  		`Backend:` + strings.Replace(this.Backend.String(), "IngressBackend", "IngressBackend", 1) + `,`,
  4970  		`TLS:` + repeatedStringForTLS + `,`,
  4971  		`Rules:` + repeatedStringForRules + `,`,
  4972  		`IngressClassName:` + valueToStringGenerated(this.IngressClassName) + `,`,
  4973  		`}`,
  4974  	}, "")
  4975  	return s
  4976  }
  4977  func (this *IngressStatus) String() string {
  4978  	if this == nil {
  4979  		return "nil"
  4980  	}
  4981  	s := strings.Join([]string{`&IngressStatus{`,
  4982  		`LoadBalancer:` + strings.Replace(strings.Replace(this.LoadBalancer.String(), "IngressLoadBalancerStatus", "IngressLoadBalancerStatus", 1), `&`, ``, 1) + `,`,
  4983  		`}`,
  4984  	}, "")
  4985  	return s
  4986  }
  4987  func (this *IngressTLS) String() string {
  4988  	if this == nil {
  4989  		return "nil"
  4990  	}
  4991  	s := strings.Join([]string{`&IngressTLS{`,
  4992  		`Hosts:` + fmt.Sprintf("%v", this.Hosts) + `,`,
  4993  		`SecretName:` + fmt.Sprintf("%v", this.SecretName) + `,`,
  4994  		`}`,
  4995  	}, "")
  4996  	return s
  4997  }
  4998  func (this *NetworkPolicy) String() string {
  4999  	if this == nil {
  5000  		return "nil"
  5001  	}
  5002  	s := strings.Join([]string{`&NetworkPolicy{`,
  5003  		`ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
  5004  		`Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "NetworkPolicySpec", "NetworkPolicySpec", 1), `&`, ``, 1) + `,`,
  5005  		`}`,
  5006  	}, "")
  5007  	return s
  5008  }
  5009  func (this *NetworkPolicyEgressRule) String() string {
  5010  	if this == nil {
  5011  		return "nil"
  5012  	}
  5013  	repeatedStringForPorts := "[]NetworkPolicyPort{"
  5014  	for _, f := range this.Ports {
  5015  		repeatedStringForPorts += strings.Replace(strings.Replace(f.String(), "NetworkPolicyPort", "NetworkPolicyPort", 1), `&`, ``, 1) + ","
  5016  	}
  5017  	repeatedStringForPorts += "}"
  5018  	repeatedStringForTo := "[]NetworkPolicyPeer{"
  5019  	for _, f := range this.To {
  5020  		repeatedStringForTo += strings.Replace(strings.Replace(f.String(), "NetworkPolicyPeer", "NetworkPolicyPeer", 1), `&`, ``, 1) + ","
  5021  	}
  5022  	repeatedStringForTo += "}"
  5023  	s := strings.Join([]string{`&NetworkPolicyEgressRule{`,
  5024  		`Ports:` + repeatedStringForPorts + `,`,
  5025  		`To:` + repeatedStringForTo + `,`,
  5026  		`}`,
  5027  	}, "")
  5028  	return s
  5029  }
  5030  func (this *NetworkPolicyIngressRule) String() string {
  5031  	if this == nil {
  5032  		return "nil"
  5033  	}
  5034  	repeatedStringForPorts := "[]NetworkPolicyPort{"
  5035  	for _, f := range this.Ports {
  5036  		repeatedStringForPorts += strings.Replace(strings.Replace(f.String(), "NetworkPolicyPort", "NetworkPolicyPort", 1), `&`, ``, 1) + ","
  5037  	}
  5038  	repeatedStringForPorts += "}"
  5039  	repeatedStringForFrom := "[]NetworkPolicyPeer{"
  5040  	for _, f := range this.From {
  5041  		repeatedStringForFrom += strings.Replace(strings.Replace(f.String(), "NetworkPolicyPeer", "NetworkPolicyPeer", 1), `&`, ``, 1) + ","
  5042  	}
  5043  	repeatedStringForFrom += "}"
  5044  	s := strings.Join([]string{`&NetworkPolicyIngressRule{`,
  5045  		`Ports:` + repeatedStringForPorts + `,`,
  5046  		`From:` + repeatedStringForFrom + `,`,
  5047  		`}`,
  5048  	}, "")
  5049  	return s
  5050  }
  5051  func (this *NetworkPolicyList) String() string {
  5052  	if this == nil {
  5053  		return "nil"
  5054  	}
  5055  	repeatedStringForItems := "[]NetworkPolicy{"
  5056  	for _, f := range this.Items {
  5057  		repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "NetworkPolicy", "NetworkPolicy", 1), `&`, ``, 1) + ","
  5058  	}
  5059  	repeatedStringForItems += "}"
  5060  	s := strings.Join([]string{`&NetworkPolicyList{`,
  5061  		`ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`,
  5062  		`Items:` + repeatedStringForItems + `,`,
  5063  		`}`,
  5064  	}, "")
  5065  	return s
  5066  }
  5067  func (this *NetworkPolicyPeer) String() string {
  5068  	if this == nil {
  5069  		return "nil"
  5070  	}
  5071  	s := strings.Join([]string{`&NetworkPolicyPeer{`,
  5072  		`PodSelector:` + strings.Replace(fmt.Sprintf("%v", this.PodSelector), "LabelSelector", "v1.LabelSelector", 1) + `,`,
  5073  		`NamespaceSelector:` + strings.Replace(fmt.Sprintf("%v", this.NamespaceSelector), "LabelSelector", "v1.LabelSelector", 1) + `,`,
  5074  		`IPBlock:` + strings.Replace(this.IPBlock.String(), "IPBlock", "IPBlock", 1) + `,`,
  5075  		`}`,
  5076  	}, "")
  5077  	return s
  5078  }
  5079  func (this *NetworkPolicyPort) String() string {
  5080  	if this == nil {
  5081  		return "nil"
  5082  	}
  5083  	s := strings.Join([]string{`&NetworkPolicyPort{`,
  5084  		`Protocol:` + valueToStringGenerated(this.Protocol) + `,`,
  5085  		`Port:` + strings.Replace(fmt.Sprintf("%v", this.Port), "IntOrString", "intstr.IntOrString", 1) + `,`,
  5086  		`EndPort:` + valueToStringGenerated(this.EndPort) + `,`,
  5087  		`}`,
  5088  	}, "")
  5089  	return s
  5090  }
  5091  func (this *NetworkPolicySpec) String() string {
  5092  	if this == nil {
  5093  		return "nil"
  5094  	}
  5095  	repeatedStringForIngress := "[]NetworkPolicyIngressRule{"
  5096  	for _, f := range this.Ingress {
  5097  		repeatedStringForIngress += strings.Replace(strings.Replace(f.String(), "NetworkPolicyIngressRule", "NetworkPolicyIngressRule", 1), `&`, ``, 1) + ","
  5098  	}
  5099  	repeatedStringForIngress += "}"
  5100  	repeatedStringForEgress := "[]NetworkPolicyEgressRule{"
  5101  	for _, f := range this.Egress {
  5102  		repeatedStringForEgress += strings.Replace(strings.Replace(f.String(), "NetworkPolicyEgressRule", "NetworkPolicyEgressRule", 1), `&`, ``, 1) + ","
  5103  	}
  5104  	repeatedStringForEgress += "}"
  5105  	s := strings.Join([]string{`&NetworkPolicySpec{`,
  5106  		`PodSelector:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.PodSelector), "LabelSelector", "v1.LabelSelector", 1), `&`, ``, 1) + `,`,
  5107  		`Ingress:` + repeatedStringForIngress + `,`,
  5108  		`Egress:` + repeatedStringForEgress + `,`,
  5109  		`PolicyTypes:` + fmt.Sprintf("%v", this.PolicyTypes) + `,`,
  5110  		`}`,
  5111  	}, "")
  5112  	return s
  5113  }
  5114  func (this *ReplicaSet) String() string {
  5115  	if this == nil {
  5116  		return "nil"
  5117  	}
  5118  	s := strings.Join([]string{`&ReplicaSet{`,
  5119  		`ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
  5120  		`Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "ReplicaSetSpec", "ReplicaSetSpec", 1), `&`, ``, 1) + `,`,
  5121  		`Status:` + strings.Replace(strings.Replace(this.Status.String(), "ReplicaSetStatus", "ReplicaSetStatus", 1), `&`, ``, 1) + `,`,
  5122  		`}`,
  5123  	}, "")
  5124  	return s
  5125  }
  5126  func (this *ReplicaSetCondition) String() string {
  5127  	if this == nil {
  5128  		return "nil"
  5129  	}
  5130  	s := strings.Join([]string{`&ReplicaSetCondition{`,
  5131  		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
  5132  		`Status:` + fmt.Sprintf("%v", this.Status) + `,`,
  5133  		`LastTransitionTime:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.LastTransitionTime), "Time", "v1.Time", 1), `&`, ``, 1) + `,`,
  5134  		`Reason:` + fmt.Sprintf("%v", this.Reason) + `,`,
  5135  		`Message:` + fmt.Sprintf("%v", this.Message) + `,`,
  5136  		`}`,
  5137  	}, "")
  5138  	return s
  5139  }
  5140  func (this *ReplicaSetList) String() string {
  5141  	if this == nil {
  5142  		return "nil"
  5143  	}
  5144  	repeatedStringForItems := "[]ReplicaSet{"
  5145  	for _, f := range this.Items {
  5146  		repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "ReplicaSet", "ReplicaSet", 1), `&`, ``, 1) + ","
  5147  	}
  5148  	repeatedStringForItems += "}"
  5149  	s := strings.Join([]string{`&ReplicaSetList{`,
  5150  		`ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`,
  5151  		`Items:` + repeatedStringForItems + `,`,
  5152  		`}`,
  5153  	}, "")
  5154  	return s
  5155  }
  5156  func (this *ReplicaSetSpec) String() string {
  5157  	if this == nil {
  5158  		return "nil"
  5159  	}
  5160  	s := strings.Join([]string{`&ReplicaSetSpec{`,
  5161  		`Replicas:` + valueToStringGenerated(this.Replicas) + `,`,
  5162  		`Selector:` + strings.Replace(fmt.Sprintf("%v", this.Selector), "LabelSelector", "v1.LabelSelector", 1) + `,`,
  5163  		`Template:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Template), "PodTemplateSpec", "v11.PodTemplateSpec", 1), `&`, ``, 1) + `,`,
  5164  		`MinReadySeconds:` + fmt.Sprintf("%v", this.MinReadySeconds) + `,`,
  5165  		`}`,
  5166  	}, "")
  5167  	return s
  5168  }
  5169  func (this *ReplicaSetStatus) String() string {
  5170  	if this == nil {
  5171  		return "nil"
  5172  	}
  5173  	repeatedStringForConditions := "[]ReplicaSetCondition{"
  5174  	for _, f := range this.Conditions {
  5175  		repeatedStringForConditions += strings.Replace(strings.Replace(f.String(), "ReplicaSetCondition", "ReplicaSetCondition", 1), `&`, ``, 1) + ","
  5176  	}
  5177  	repeatedStringForConditions += "}"
  5178  	s := strings.Join([]string{`&ReplicaSetStatus{`,
  5179  		`Replicas:` + fmt.Sprintf("%v", this.Replicas) + `,`,
  5180  		`FullyLabeledReplicas:` + fmt.Sprintf("%v", this.FullyLabeledReplicas) + `,`,
  5181  		`ObservedGeneration:` + fmt.Sprintf("%v", this.ObservedGeneration) + `,`,
  5182  		`ReadyReplicas:` + fmt.Sprintf("%v", this.ReadyReplicas) + `,`,
  5183  		`AvailableReplicas:` + fmt.Sprintf("%v", this.AvailableReplicas) + `,`,
  5184  		`Conditions:` + repeatedStringForConditions + `,`,
  5185  		`}`,
  5186  	}, "")
  5187  	return s
  5188  }
  5189  func (this *RollbackConfig) String() string {
  5190  	if this == nil {
  5191  		return "nil"
  5192  	}
  5193  	s := strings.Join([]string{`&RollbackConfig{`,
  5194  		`Revision:` + fmt.Sprintf("%v", this.Revision) + `,`,
  5195  		`}`,
  5196  	}, "")
  5197  	return s
  5198  }
  5199  func (this *RollingUpdateDaemonSet) String() string {
  5200  	if this == nil {
  5201  		return "nil"
  5202  	}
  5203  	s := strings.Join([]string{`&RollingUpdateDaemonSet{`,
  5204  		`MaxUnavailable:` + strings.Replace(fmt.Sprintf("%v", this.MaxUnavailable), "IntOrString", "intstr.IntOrString", 1) + `,`,
  5205  		`MaxSurge:` + strings.Replace(fmt.Sprintf("%v", this.MaxSurge), "IntOrString", "intstr.IntOrString", 1) + `,`,
  5206  		`}`,
  5207  	}, "")
  5208  	return s
  5209  }
  5210  func (this *RollingUpdateDeployment) String() string {
  5211  	if this == nil {
  5212  		return "nil"
  5213  	}
  5214  	s := strings.Join([]string{`&RollingUpdateDeployment{`,
  5215  		`MaxUnavailable:` + strings.Replace(fmt.Sprintf("%v", this.MaxUnavailable), "IntOrString", "intstr.IntOrString", 1) + `,`,
  5216  		`MaxSurge:` + strings.Replace(fmt.Sprintf("%v", this.MaxSurge), "IntOrString", "intstr.IntOrString", 1) + `,`,
  5217  		`}`,
  5218  	}, "")
  5219  	return s
  5220  }
  5221  func (this *Scale) String() string {
  5222  	if this == nil {
  5223  		return "nil"
  5224  	}
  5225  	s := strings.Join([]string{`&Scale{`,
  5226  		`ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
  5227  		`Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "ScaleSpec", "ScaleSpec", 1), `&`, ``, 1) + `,`,
  5228  		`Status:` + strings.Replace(strings.Replace(this.Status.String(), "ScaleStatus", "ScaleStatus", 1), `&`, ``, 1) + `,`,
  5229  		`}`,
  5230  	}, "")
  5231  	return s
  5232  }
  5233  func (this *ScaleSpec) String() string {
  5234  	if this == nil {
  5235  		return "nil"
  5236  	}
  5237  	s := strings.Join([]string{`&ScaleSpec{`,
  5238  		`Replicas:` + fmt.Sprintf("%v", this.Replicas) + `,`,
  5239  		`}`,
  5240  	}, "")
  5241  	return s
  5242  }
  5243  func (this *ScaleStatus) String() string {
  5244  	if this == nil {
  5245  		return "nil"
  5246  	}
  5247  	keysForSelector := make([]string, 0, len(this.Selector))
  5248  	for k := range this.Selector {
  5249  		keysForSelector = append(keysForSelector, k)
  5250  	}
  5251  	github_com_gogo_protobuf_sortkeys.Strings(keysForSelector)
  5252  	mapStringForSelector := "map[string]string{"
  5253  	for _, k := range keysForSelector {
  5254  		mapStringForSelector += fmt.Sprintf("%v: %v,", k, this.Selector[k])
  5255  	}
  5256  	mapStringForSelector += "}"
  5257  	s := strings.Join([]string{`&ScaleStatus{`,
  5258  		`Replicas:` + fmt.Sprintf("%v", this.Replicas) + `,`,
  5259  		`Selector:` + mapStringForSelector + `,`,
  5260  		`TargetSelector:` + fmt.Sprintf("%v", this.TargetSelector) + `,`,
  5261  		`}`,
  5262  	}, "")
  5263  	return s
  5264  }
  5265  func valueToStringGenerated(v interface{}) string {
  5266  	rv := reflect.ValueOf(v)
  5267  	if rv.IsNil() {
  5268  		return "nil"
  5269  	}
  5270  	pv := reflect.Indirect(rv).Interface()
  5271  	return fmt.Sprintf("*%v", pv)
  5272  }
  5273  func (m *DaemonSet) Unmarshal(dAtA []byte) error {
  5274  	l := len(dAtA)
  5275  	iNdEx := 0
  5276  	for iNdEx < l {
  5277  		preIndex := iNdEx
  5278  		var wire uint64
  5279  		for shift := uint(0); ; shift += 7 {
  5280  			if shift >= 64 {
  5281  				return ErrIntOverflowGenerated
  5282  			}
  5283  			if iNdEx >= l {
  5284  				return io.ErrUnexpectedEOF
  5285  			}
  5286  			b := dAtA[iNdEx]
  5287  			iNdEx++
  5288  			wire |= uint64(b&0x7F) << shift
  5289  			if b < 0x80 {
  5290  				break
  5291  			}
  5292  		}
  5293  		fieldNum := int32(wire >> 3)
  5294  		wireType := int(wire & 0x7)
  5295  		if wireType == 4 {
  5296  			return fmt.Errorf("proto: DaemonSet: wiretype end group for non-group")
  5297  		}
  5298  		if fieldNum <= 0 {
  5299  			return fmt.Errorf("proto: DaemonSet: illegal tag %d (wire type %d)", fieldNum, wire)
  5300  		}
  5301  		switch fieldNum {
  5302  		case 1:
  5303  			if wireType != 2 {
  5304  				return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
  5305  			}
  5306  			var msglen int
  5307  			for shift := uint(0); ; shift += 7 {
  5308  				if shift >= 64 {
  5309  					return ErrIntOverflowGenerated
  5310  				}
  5311  				if iNdEx >= l {
  5312  					return io.ErrUnexpectedEOF
  5313  				}
  5314  				b := dAtA[iNdEx]
  5315  				iNdEx++
  5316  				msglen |= int(b&0x7F) << shift
  5317  				if b < 0x80 {
  5318  					break
  5319  				}
  5320  			}
  5321  			if msglen < 0 {
  5322  				return ErrInvalidLengthGenerated
  5323  			}
  5324  			postIndex := iNdEx + msglen
  5325  			if postIndex < 0 {
  5326  				return ErrInvalidLengthGenerated
  5327  			}
  5328  			if postIndex > l {
  5329  				return io.ErrUnexpectedEOF
  5330  			}
  5331  			if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  5332  				return err
  5333  			}
  5334  			iNdEx = postIndex
  5335  		case 2:
  5336  			if wireType != 2 {
  5337  				return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
  5338  			}
  5339  			var msglen int
  5340  			for shift := uint(0); ; shift += 7 {
  5341  				if shift >= 64 {
  5342  					return ErrIntOverflowGenerated
  5343  				}
  5344  				if iNdEx >= l {
  5345  					return io.ErrUnexpectedEOF
  5346  				}
  5347  				b := dAtA[iNdEx]
  5348  				iNdEx++
  5349  				msglen |= int(b&0x7F) << shift
  5350  				if b < 0x80 {
  5351  					break
  5352  				}
  5353  			}
  5354  			if msglen < 0 {
  5355  				return ErrInvalidLengthGenerated
  5356  			}
  5357  			postIndex := iNdEx + msglen
  5358  			if postIndex < 0 {
  5359  				return ErrInvalidLengthGenerated
  5360  			}
  5361  			if postIndex > l {
  5362  				return io.ErrUnexpectedEOF
  5363  			}
  5364  			if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  5365  				return err
  5366  			}
  5367  			iNdEx = postIndex
  5368  		case 3:
  5369  			if wireType != 2 {
  5370  				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
  5371  			}
  5372  			var msglen int
  5373  			for shift := uint(0); ; shift += 7 {
  5374  				if shift >= 64 {
  5375  					return ErrIntOverflowGenerated
  5376  				}
  5377  				if iNdEx >= l {
  5378  					return io.ErrUnexpectedEOF
  5379  				}
  5380  				b := dAtA[iNdEx]
  5381  				iNdEx++
  5382  				msglen |= int(b&0x7F) << shift
  5383  				if b < 0x80 {
  5384  					break
  5385  				}
  5386  			}
  5387  			if msglen < 0 {
  5388  				return ErrInvalidLengthGenerated
  5389  			}
  5390  			postIndex := iNdEx + msglen
  5391  			if postIndex < 0 {
  5392  				return ErrInvalidLengthGenerated
  5393  			}
  5394  			if postIndex > l {
  5395  				return io.ErrUnexpectedEOF
  5396  			}
  5397  			if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  5398  				return err
  5399  			}
  5400  			iNdEx = postIndex
  5401  		default:
  5402  			iNdEx = preIndex
  5403  			skippy, err := skipGenerated(dAtA[iNdEx:])
  5404  			if err != nil {
  5405  				return err
  5406  			}
  5407  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  5408  				return ErrInvalidLengthGenerated
  5409  			}
  5410  			if (iNdEx + skippy) > l {
  5411  				return io.ErrUnexpectedEOF
  5412  			}
  5413  			iNdEx += skippy
  5414  		}
  5415  	}
  5416  
  5417  	if iNdEx > l {
  5418  		return io.ErrUnexpectedEOF
  5419  	}
  5420  	return nil
  5421  }
  5422  func (m *DaemonSetCondition) Unmarshal(dAtA []byte) error {
  5423  	l := len(dAtA)
  5424  	iNdEx := 0
  5425  	for iNdEx < l {
  5426  		preIndex := iNdEx
  5427  		var wire uint64
  5428  		for shift := uint(0); ; shift += 7 {
  5429  			if shift >= 64 {
  5430  				return ErrIntOverflowGenerated
  5431  			}
  5432  			if iNdEx >= l {
  5433  				return io.ErrUnexpectedEOF
  5434  			}
  5435  			b := dAtA[iNdEx]
  5436  			iNdEx++
  5437  			wire |= uint64(b&0x7F) << shift
  5438  			if b < 0x80 {
  5439  				break
  5440  			}
  5441  		}
  5442  		fieldNum := int32(wire >> 3)
  5443  		wireType := int(wire & 0x7)
  5444  		if wireType == 4 {
  5445  			return fmt.Errorf("proto: DaemonSetCondition: wiretype end group for non-group")
  5446  		}
  5447  		if fieldNum <= 0 {
  5448  			return fmt.Errorf("proto: DaemonSetCondition: illegal tag %d (wire type %d)", fieldNum, wire)
  5449  		}
  5450  		switch fieldNum {
  5451  		case 1:
  5452  			if wireType != 2 {
  5453  				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
  5454  			}
  5455  			var stringLen uint64
  5456  			for shift := uint(0); ; shift += 7 {
  5457  				if shift >= 64 {
  5458  					return ErrIntOverflowGenerated
  5459  				}
  5460  				if iNdEx >= l {
  5461  					return io.ErrUnexpectedEOF
  5462  				}
  5463  				b := dAtA[iNdEx]
  5464  				iNdEx++
  5465  				stringLen |= uint64(b&0x7F) << shift
  5466  				if b < 0x80 {
  5467  					break
  5468  				}
  5469  			}
  5470  			intStringLen := int(stringLen)
  5471  			if intStringLen < 0 {
  5472  				return ErrInvalidLengthGenerated
  5473  			}
  5474  			postIndex := iNdEx + intStringLen
  5475  			if postIndex < 0 {
  5476  				return ErrInvalidLengthGenerated
  5477  			}
  5478  			if postIndex > l {
  5479  				return io.ErrUnexpectedEOF
  5480  			}
  5481  			m.Type = DaemonSetConditionType(dAtA[iNdEx:postIndex])
  5482  			iNdEx = postIndex
  5483  		case 2:
  5484  			if wireType != 2 {
  5485  				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
  5486  			}
  5487  			var stringLen uint64
  5488  			for shift := uint(0); ; shift += 7 {
  5489  				if shift >= 64 {
  5490  					return ErrIntOverflowGenerated
  5491  				}
  5492  				if iNdEx >= l {
  5493  					return io.ErrUnexpectedEOF
  5494  				}
  5495  				b := dAtA[iNdEx]
  5496  				iNdEx++
  5497  				stringLen |= uint64(b&0x7F) << shift
  5498  				if b < 0x80 {
  5499  					break
  5500  				}
  5501  			}
  5502  			intStringLen := int(stringLen)
  5503  			if intStringLen < 0 {
  5504  				return ErrInvalidLengthGenerated
  5505  			}
  5506  			postIndex := iNdEx + intStringLen
  5507  			if postIndex < 0 {
  5508  				return ErrInvalidLengthGenerated
  5509  			}
  5510  			if postIndex > l {
  5511  				return io.ErrUnexpectedEOF
  5512  			}
  5513  			m.Status = k8s_io_api_core_v1.ConditionStatus(dAtA[iNdEx:postIndex])
  5514  			iNdEx = postIndex
  5515  		case 3:
  5516  			if wireType != 2 {
  5517  				return fmt.Errorf("proto: wrong wireType = %d for field LastTransitionTime", wireType)
  5518  			}
  5519  			var msglen int
  5520  			for shift := uint(0); ; shift += 7 {
  5521  				if shift >= 64 {
  5522  					return ErrIntOverflowGenerated
  5523  				}
  5524  				if iNdEx >= l {
  5525  					return io.ErrUnexpectedEOF
  5526  				}
  5527  				b := dAtA[iNdEx]
  5528  				iNdEx++
  5529  				msglen |= int(b&0x7F) << shift
  5530  				if b < 0x80 {
  5531  					break
  5532  				}
  5533  			}
  5534  			if msglen < 0 {
  5535  				return ErrInvalidLengthGenerated
  5536  			}
  5537  			postIndex := iNdEx + msglen
  5538  			if postIndex < 0 {
  5539  				return ErrInvalidLengthGenerated
  5540  			}
  5541  			if postIndex > l {
  5542  				return io.ErrUnexpectedEOF
  5543  			}
  5544  			if err := m.LastTransitionTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  5545  				return err
  5546  			}
  5547  			iNdEx = postIndex
  5548  		case 4:
  5549  			if wireType != 2 {
  5550  				return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
  5551  			}
  5552  			var stringLen uint64
  5553  			for shift := uint(0); ; shift += 7 {
  5554  				if shift >= 64 {
  5555  					return ErrIntOverflowGenerated
  5556  				}
  5557  				if iNdEx >= l {
  5558  					return io.ErrUnexpectedEOF
  5559  				}
  5560  				b := dAtA[iNdEx]
  5561  				iNdEx++
  5562  				stringLen |= uint64(b&0x7F) << shift
  5563  				if b < 0x80 {
  5564  					break
  5565  				}
  5566  			}
  5567  			intStringLen := int(stringLen)
  5568  			if intStringLen < 0 {
  5569  				return ErrInvalidLengthGenerated
  5570  			}
  5571  			postIndex := iNdEx + intStringLen
  5572  			if postIndex < 0 {
  5573  				return ErrInvalidLengthGenerated
  5574  			}
  5575  			if postIndex > l {
  5576  				return io.ErrUnexpectedEOF
  5577  			}
  5578  			m.Reason = string(dAtA[iNdEx:postIndex])
  5579  			iNdEx = postIndex
  5580  		case 5:
  5581  			if wireType != 2 {
  5582  				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
  5583  			}
  5584  			var stringLen uint64
  5585  			for shift := uint(0); ; shift += 7 {
  5586  				if shift >= 64 {
  5587  					return ErrIntOverflowGenerated
  5588  				}
  5589  				if iNdEx >= l {
  5590  					return io.ErrUnexpectedEOF
  5591  				}
  5592  				b := dAtA[iNdEx]
  5593  				iNdEx++
  5594  				stringLen |= uint64(b&0x7F) << shift
  5595  				if b < 0x80 {
  5596  					break
  5597  				}
  5598  			}
  5599  			intStringLen := int(stringLen)
  5600  			if intStringLen < 0 {
  5601  				return ErrInvalidLengthGenerated
  5602  			}
  5603  			postIndex := iNdEx + intStringLen
  5604  			if postIndex < 0 {
  5605  				return ErrInvalidLengthGenerated
  5606  			}
  5607  			if postIndex > l {
  5608  				return io.ErrUnexpectedEOF
  5609  			}
  5610  			m.Message = string(dAtA[iNdEx:postIndex])
  5611  			iNdEx = postIndex
  5612  		default:
  5613  			iNdEx = preIndex
  5614  			skippy, err := skipGenerated(dAtA[iNdEx:])
  5615  			if err != nil {
  5616  				return err
  5617  			}
  5618  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  5619  				return ErrInvalidLengthGenerated
  5620  			}
  5621  			if (iNdEx + skippy) > l {
  5622  				return io.ErrUnexpectedEOF
  5623  			}
  5624  			iNdEx += skippy
  5625  		}
  5626  	}
  5627  
  5628  	if iNdEx > l {
  5629  		return io.ErrUnexpectedEOF
  5630  	}
  5631  	return nil
  5632  }
  5633  func (m *DaemonSetList) Unmarshal(dAtA []byte) error {
  5634  	l := len(dAtA)
  5635  	iNdEx := 0
  5636  	for iNdEx < l {
  5637  		preIndex := iNdEx
  5638  		var wire uint64
  5639  		for shift := uint(0); ; shift += 7 {
  5640  			if shift >= 64 {
  5641  				return ErrIntOverflowGenerated
  5642  			}
  5643  			if iNdEx >= l {
  5644  				return io.ErrUnexpectedEOF
  5645  			}
  5646  			b := dAtA[iNdEx]
  5647  			iNdEx++
  5648  			wire |= uint64(b&0x7F) << shift
  5649  			if b < 0x80 {
  5650  				break
  5651  			}
  5652  		}
  5653  		fieldNum := int32(wire >> 3)
  5654  		wireType := int(wire & 0x7)
  5655  		if wireType == 4 {
  5656  			return fmt.Errorf("proto: DaemonSetList: wiretype end group for non-group")
  5657  		}
  5658  		if fieldNum <= 0 {
  5659  			return fmt.Errorf("proto: DaemonSetList: illegal tag %d (wire type %d)", fieldNum, wire)
  5660  		}
  5661  		switch fieldNum {
  5662  		case 1:
  5663  			if wireType != 2 {
  5664  				return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
  5665  			}
  5666  			var msglen int
  5667  			for shift := uint(0); ; shift += 7 {
  5668  				if shift >= 64 {
  5669  					return ErrIntOverflowGenerated
  5670  				}
  5671  				if iNdEx >= l {
  5672  					return io.ErrUnexpectedEOF
  5673  				}
  5674  				b := dAtA[iNdEx]
  5675  				iNdEx++
  5676  				msglen |= int(b&0x7F) << shift
  5677  				if b < 0x80 {
  5678  					break
  5679  				}
  5680  			}
  5681  			if msglen < 0 {
  5682  				return ErrInvalidLengthGenerated
  5683  			}
  5684  			postIndex := iNdEx + msglen
  5685  			if postIndex < 0 {
  5686  				return ErrInvalidLengthGenerated
  5687  			}
  5688  			if postIndex > l {
  5689  				return io.ErrUnexpectedEOF
  5690  			}
  5691  			if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  5692  				return err
  5693  			}
  5694  			iNdEx = postIndex
  5695  		case 2:
  5696  			if wireType != 2 {
  5697  				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
  5698  			}
  5699  			var msglen int
  5700  			for shift := uint(0); ; shift += 7 {
  5701  				if shift >= 64 {
  5702  					return ErrIntOverflowGenerated
  5703  				}
  5704  				if iNdEx >= l {
  5705  					return io.ErrUnexpectedEOF
  5706  				}
  5707  				b := dAtA[iNdEx]
  5708  				iNdEx++
  5709  				msglen |= int(b&0x7F) << shift
  5710  				if b < 0x80 {
  5711  					break
  5712  				}
  5713  			}
  5714  			if msglen < 0 {
  5715  				return ErrInvalidLengthGenerated
  5716  			}
  5717  			postIndex := iNdEx + msglen
  5718  			if postIndex < 0 {
  5719  				return ErrInvalidLengthGenerated
  5720  			}
  5721  			if postIndex > l {
  5722  				return io.ErrUnexpectedEOF
  5723  			}
  5724  			m.Items = append(m.Items, DaemonSet{})
  5725  			if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  5726  				return err
  5727  			}
  5728  			iNdEx = postIndex
  5729  		default:
  5730  			iNdEx = preIndex
  5731  			skippy, err := skipGenerated(dAtA[iNdEx:])
  5732  			if err != nil {
  5733  				return err
  5734  			}
  5735  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  5736  				return ErrInvalidLengthGenerated
  5737  			}
  5738  			if (iNdEx + skippy) > l {
  5739  				return io.ErrUnexpectedEOF
  5740  			}
  5741  			iNdEx += skippy
  5742  		}
  5743  	}
  5744  
  5745  	if iNdEx > l {
  5746  		return io.ErrUnexpectedEOF
  5747  	}
  5748  	return nil
  5749  }
  5750  func (m *DaemonSetSpec) Unmarshal(dAtA []byte) error {
  5751  	l := len(dAtA)
  5752  	iNdEx := 0
  5753  	for iNdEx < l {
  5754  		preIndex := iNdEx
  5755  		var wire uint64
  5756  		for shift := uint(0); ; shift += 7 {
  5757  			if shift >= 64 {
  5758  				return ErrIntOverflowGenerated
  5759  			}
  5760  			if iNdEx >= l {
  5761  				return io.ErrUnexpectedEOF
  5762  			}
  5763  			b := dAtA[iNdEx]
  5764  			iNdEx++
  5765  			wire |= uint64(b&0x7F) << shift
  5766  			if b < 0x80 {
  5767  				break
  5768  			}
  5769  		}
  5770  		fieldNum := int32(wire >> 3)
  5771  		wireType := int(wire & 0x7)
  5772  		if wireType == 4 {
  5773  			return fmt.Errorf("proto: DaemonSetSpec: wiretype end group for non-group")
  5774  		}
  5775  		if fieldNum <= 0 {
  5776  			return fmt.Errorf("proto: DaemonSetSpec: illegal tag %d (wire type %d)", fieldNum, wire)
  5777  		}
  5778  		switch fieldNum {
  5779  		case 1:
  5780  			if wireType != 2 {
  5781  				return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType)
  5782  			}
  5783  			var msglen int
  5784  			for shift := uint(0); ; shift += 7 {
  5785  				if shift >= 64 {
  5786  					return ErrIntOverflowGenerated
  5787  				}
  5788  				if iNdEx >= l {
  5789  					return io.ErrUnexpectedEOF
  5790  				}
  5791  				b := dAtA[iNdEx]
  5792  				iNdEx++
  5793  				msglen |= int(b&0x7F) << shift
  5794  				if b < 0x80 {
  5795  					break
  5796  				}
  5797  			}
  5798  			if msglen < 0 {
  5799  				return ErrInvalidLengthGenerated
  5800  			}
  5801  			postIndex := iNdEx + msglen
  5802  			if postIndex < 0 {
  5803  				return ErrInvalidLengthGenerated
  5804  			}
  5805  			if postIndex > l {
  5806  				return io.ErrUnexpectedEOF
  5807  			}
  5808  			if m.Selector == nil {
  5809  				m.Selector = &v1.LabelSelector{}
  5810  			}
  5811  			if err := m.Selector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  5812  				return err
  5813  			}
  5814  			iNdEx = postIndex
  5815  		case 2:
  5816  			if wireType != 2 {
  5817  				return fmt.Errorf("proto: wrong wireType = %d for field Template", wireType)
  5818  			}
  5819  			var msglen int
  5820  			for shift := uint(0); ; shift += 7 {
  5821  				if shift >= 64 {
  5822  					return ErrIntOverflowGenerated
  5823  				}
  5824  				if iNdEx >= l {
  5825  					return io.ErrUnexpectedEOF
  5826  				}
  5827  				b := dAtA[iNdEx]
  5828  				iNdEx++
  5829  				msglen |= int(b&0x7F) << shift
  5830  				if b < 0x80 {
  5831  					break
  5832  				}
  5833  			}
  5834  			if msglen < 0 {
  5835  				return ErrInvalidLengthGenerated
  5836  			}
  5837  			postIndex := iNdEx + msglen
  5838  			if postIndex < 0 {
  5839  				return ErrInvalidLengthGenerated
  5840  			}
  5841  			if postIndex > l {
  5842  				return io.ErrUnexpectedEOF
  5843  			}
  5844  			if err := m.Template.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  5845  				return err
  5846  			}
  5847  			iNdEx = postIndex
  5848  		case 3:
  5849  			if wireType != 2 {
  5850  				return fmt.Errorf("proto: wrong wireType = %d for field UpdateStrategy", wireType)
  5851  			}
  5852  			var msglen int
  5853  			for shift := uint(0); ; shift += 7 {
  5854  				if shift >= 64 {
  5855  					return ErrIntOverflowGenerated
  5856  				}
  5857  				if iNdEx >= l {
  5858  					return io.ErrUnexpectedEOF
  5859  				}
  5860  				b := dAtA[iNdEx]
  5861  				iNdEx++
  5862  				msglen |= int(b&0x7F) << shift
  5863  				if b < 0x80 {
  5864  					break
  5865  				}
  5866  			}
  5867  			if msglen < 0 {
  5868  				return ErrInvalidLengthGenerated
  5869  			}
  5870  			postIndex := iNdEx + msglen
  5871  			if postIndex < 0 {
  5872  				return ErrInvalidLengthGenerated
  5873  			}
  5874  			if postIndex > l {
  5875  				return io.ErrUnexpectedEOF
  5876  			}
  5877  			if err := m.UpdateStrategy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  5878  				return err
  5879  			}
  5880  			iNdEx = postIndex
  5881  		case 4:
  5882  			if wireType != 0 {
  5883  				return fmt.Errorf("proto: wrong wireType = %d for field MinReadySeconds", wireType)
  5884  			}
  5885  			m.MinReadySeconds = 0
  5886  			for shift := uint(0); ; shift += 7 {
  5887  				if shift >= 64 {
  5888  					return ErrIntOverflowGenerated
  5889  				}
  5890  				if iNdEx >= l {
  5891  					return io.ErrUnexpectedEOF
  5892  				}
  5893  				b := dAtA[iNdEx]
  5894  				iNdEx++
  5895  				m.MinReadySeconds |= int32(b&0x7F) << shift
  5896  				if b < 0x80 {
  5897  					break
  5898  				}
  5899  			}
  5900  		case 5:
  5901  			if wireType != 0 {
  5902  				return fmt.Errorf("proto: wrong wireType = %d for field TemplateGeneration", wireType)
  5903  			}
  5904  			m.TemplateGeneration = 0
  5905  			for shift := uint(0); ; shift += 7 {
  5906  				if shift >= 64 {
  5907  					return ErrIntOverflowGenerated
  5908  				}
  5909  				if iNdEx >= l {
  5910  					return io.ErrUnexpectedEOF
  5911  				}
  5912  				b := dAtA[iNdEx]
  5913  				iNdEx++
  5914  				m.TemplateGeneration |= int64(b&0x7F) << shift
  5915  				if b < 0x80 {
  5916  					break
  5917  				}
  5918  			}
  5919  		case 6:
  5920  			if wireType != 0 {
  5921  				return fmt.Errorf("proto: wrong wireType = %d for field RevisionHistoryLimit", wireType)
  5922  			}
  5923  			var v int32
  5924  			for shift := uint(0); ; shift += 7 {
  5925  				if shift >= 64 {
  5926  					return ErrIntOverflowGenerated
  5927  				}
  5928  				if iNdEx >= l {
  5929  					return io.ErrUnexpectedEOF
  5930  				}
  5931  				b := dAtA[iNdEx]
  5932  				iNdEx++
  5933  				v |= int32(b&0x7F) << shift
  5934  				if b < 0x80 {
  5935  					break
  5936  				}
  5937  			}
  5938  			m.RevisionHistoryLimit = &v
  5939  		default:
  5940  			iNdEx = preIndex
  5941  			skippy, err := skipGenerated(dAtA[iNdEx:])
  5942  			if err != nil {
  5943  				return err
  5944  			}
  5945  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  5946  				return ErrInvalidLengthGenerated
  5947  			}
  5948  			if (iNdEx + skippy) > l {
  5949  				return io.ErrUnexpectedEOF
  5950  			}
  5951  			iNdEx += skippy
  5952  		}
  5953  	}
  5954  
  5955  	if iNdEx > l {
  5956  		return io.ErrUnexpectedEOF
  5957  	}
  5958  	return nil
  5959  }
  5960  func (m *DaemonSetStatus) Unmarshal(dAtA []byte) error {
  5961  	l := len(dAtA)
  5962  	iNdEx := 0
  5963  	for iNdEx < l {
  5964  		preIndex := iNdEx
  5965  		var wire uint64
  5966  		for shift := uint(0); ; shift += 7 {
  5967  			if shift >= 64 {
  5968  				return ErrIntOverflowGenerated
  5969  			}
  5970  			if iNdEx >= l {
  5971  				return io.ErrUnexpectedEOF
  5972  			}
  5973  			b := dAtA[iNdEx]
  5974  			iNdEx++
  5975  			wire |= uint64(b&0x7F) << shift
  5976  			if b < 0x80 {
  5977  				break
  5978  			}
  5979  		}
  5980  		fieldNum := int32(wire >> 3)
  5981  		wireType := int(wire & 0x7)
  5982  		if wireType == 4 {
  5983  			return fmt.Errorf("proto: DaemonSetStatus: wiretype end group for non-group")
  5984  		}
  5985  		if fieldNum <= 0 {
  5986  			return fmt.Errorf("proto: DaemonSetStatus: illegal tag %d (wire type %d)", fieldNum, wire)
  5987  		}
  5988  		switch fieldNum {
  5989  		case 1:
  5990  			if wireType != 0 {
  5991  				return fmt.Errorf("proto: wrong wireType = %d for field CurrentNumberScheduled", wireType)
  5992  			}
  5993  			m.CurrentNumberScheduled = 0
  5994  			for shift := uint(0); ; shift += 7 {
  5995  				if shift >= 64 {
  5996  					return ErrIntOverflowGenerated
  5997  				}
  5998  				if iNdEx >= l {
  5999  					return io.ErrUnexpectedEOF
  6000  				}
  6001  				b := dAtA[iNdEx]
  6002  				iNdEx++
  6003  				m.CurrentNumberScheduled |= int32(b&0x7F) << shift
  6004  				if b < 0x80 {
  6005  					break
  6006  				}
  6007  			}
  6008  		case 2:
  6009  			if wireType != 0 {
  6010  				return fmt.Errorf("proto: wrong wireType = %d for field NumberMisscheduled", wireType)
  6011  			}
  6012  			m.NumberMisscheduled = 0
  6013  			for shift := uint(0); ; shift += 7 {
  6014  				if shift >= 64 {
  6015  					return ErrIntOverflowGenerated
  6016  				}
  6017  				if iNdEx >= l {
  6018  					return io.ErrUnexpectedEOF
  6019  				}
  6020  				b := dAtA[iNdEx]
  6021  				iNdEx++
  6022  				m.NumberMisscheduled |= int32(b&0x7F) << shift
  6023  				if b < 0x80 {
  6024  					break
  6025  				}
  6026  			}
  6027  		case 3:
  6028  			if wireType != 0 {
  6029  				return fmt.Errorf("proto: wrong wireType = %d for field DesiredNumberScheduled", wireType)
  6030  			}
  6031  			m.DesiredNumberScheduled = 0
  6032  			for shift := uint(0); ; shift += 7 {
  6033  				if shift >= 64 {
  6034  					return ErrIntOverflowGenerated
  6035  				}
  6036  				if iNdEx >= l {
  6037  					return io.ErrUnexpectedEOF
  6038  				}
  6039  				b := dAtA[iNdEx]
  6040  				iNdEx++
  6041  				m.DesiredNumberScheduled |= int32(b&0x7F) << shift
  6042  				if b < 0x80 {
  6043  					break
  6044  				}
  6045  			}
  6046  		case 4:
  6047  			if wireType != 0 {
  6048  				return fmt.Errorf("proto: wrong wireType = %d for field NumberReady", wireType)
  6049  			}
  6050  			m.NumberReady = 0
  6051  			for shift := uint(0); ; shift += 7 {
  6052  				if shift >= 64 {
  6053  					return ErrIntOverflowGenerated
  6054  				}
  6055  				if iNdEx >= l {
  6056  					return io.ErrUnexpectedEOF
  6057  				}
  6058  				b := dAtA[iNdEx]
  6059  				iNdEx++
  6060  				m.NumberReady |= int32(b&0x7F) << shift
  6061  				if b < 0x80 {
  6062  					break
  6063  				}
  6064  			}
  6065  		case 5:
  6066  			if wireType != 0 {
  6067  				return fmt.Errorf("proto: wrong wireType = %d for field ObservedGeneration", wireType)
  6068  			}
  6069  			m.ObservedGeneration = 0
  6070  			for shift := uint(0); ; shift += 7 {
  6071  				if shift >= 64 {
  6072  					return ErrIntOverflowGenerated
  6073  				}
  6074  				if iNdEx >= l {
  6075  					return io.ErrUnexpectedEOF
  6076  				}
  6077  				b := dAtA[iNdEx]
  6078  				iNdEx++
  6079  				m.ObservedGeneration |= int64(b&0x7F) << shift
  6080  				if b < 0x80 {
  6081  					break
  6082  				}
  6083  			}
  6084  		case 6:
  6085  			if wireType != 0 {
  6086  				return fmt.Errorf("proto: wrong wireType = %d for field UpdatedNumberScheduled", wireType)
  6087  			}
  6088  			m.UpdatedNumberScheduled = 0
  6089  			for shift := uint(0); ; shift += 7 {
  6090  				if shift >= 64 {
  6091  					return ErrIntOverflowGenerated
  6092  				}
  6093  				if iNdEx >= l {
  6094  					return io.ErrUnexpectedEOF
  6095  				}
  6096  				b := dAtA[iNdEx]
  6097  				iNdEx++
  6098  				m.UpdatedNumberScheduled |= int32(b&0x7F) << shift
  6099  				if b < 0x80 {
  6100  					break
  6101  				}
  6102  			}
  6103  		case 7:
  6104  			if wireType != 0 {
  6105  				return fmt.Errorf("proto: wrong wireType = %d for field NumberAvailable", wireType)
  6106  			}
  6107  			m.NumberAvailable = 0
  6108  			for shift := uint(0); ; shift += 7 {
  6109  				if shift >= 64 {
  6110  					return ErrIntOverflowGenerated
  6111  				}
  6112  				if iNdEx >= l {
  6113  					return io.ErrUnexpectedEOF
  6114  				}
  6115  				b := dAtA[iNdEx]
  6116  				iNdEx++
  6117  				m.NumberAvailable |= int32(b&0x7F) << shift
  6118  				if b < 0x80 {
  6119  					break
  6120  				}
  6121  			}
  6122  		case 8:
  6123  			if wireType != 0 {
  6124  				return fmt.Errorf("proto: wrong wireType = %d for field NumberUnavailable", wireType)
  6125  			}
  6126  			m.NumberUnavailable = 0
  6127  			for shift := uint(0); ; shift += 7 {
  6128  				if shift >= 64 {
  6129  					return ErrIntOverflowGenerated
  6130  				}
  6131  				if iNdEx >= l {
  6132  					return io.ErrUnexpectedEOF
  6133  				}
  6134  				b := dAtA[iNdEx]
  6135  				iNdEx++
  6136  				m.NumberUnavailable |= int32(b&0x7F) << shift
  6137  				if b < 0x80 {
  6138  					break
  6139  				}
  6140  			}
  6141  		case 9:
  6142  			if wireType != 0 {
  6143  				return fmt.Errorf("proto: wrong wireType = %d for field CollisionCount", wireType)
  6144  			}
  6145  			var v int32
  6146  			for shift := uint(0); ; shift += 7 {
  6147  				if shift >= 64 {
  6148  					return ErrIntOverflowGenerated
  6149  				}
  6150  				if iNdEx >= l {
  6151  					return io.ErrUnexpectedEOF
  6152  				}
  6153  				b := dAtA[iNdEx]
  6154  				iNdEx++
  6155  				v |= int32(b&0x7F) << shift
  6156  				if b < 0x80 {
  6157  					break
  6158  				}
  6159  			}
  6160  			m.CollisionCount = &v
  6161  		case 10:
  6162  			if wireType != 2 {
  6163  				return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType)
  6164  			}
  6165  			var msglen int
  6166  			for shift := uint(0); ; shift += 7 {
  6167  				if shift >= 64 {
  6168  					return ErrIntOverflowGenerated
  6169  				}
  6170  				if iNdEx >= l {
  6171  					return io.ErrUnexpectedEOF
  6172  				}
  6173  				b := dAtA[iNdEx]
  6174  				iNdEx++
  6175  				msglen |= int(b&0x7F) << shift
  6176  				if b < 0x80 {
  6177  					break
  6178  				}
  6179  			}
  6180  			if msglen < 0 {
  6181  				return ErrInvalidLengthGenerated
  6182  			}
  6183  			postIndex := iNdEx + msglen
  6184  			if postIndex < 0 {
  6185  				return ErrInvalidLengthGenerated
  6186  			}
  6187  			if postIndex > l {
  6188  				return io.ErrUnexpectedEOF
  6189  			}
  6190  			m.Conditions = append(m.Conditions, DaemonSetCondition{})
  6191  			if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  6192  				return err
  6193  			}
  6194  			iNdEx = postIndex
  6195  		default:
  6196  			iNdEx = preIndex
  6197  			skippy, err := skipGenerated(dAtA[iNdEx:])
  6198  			if err != nil {
  6199  				return err
  6200  			}
  6201  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  6202  				return ErrInvalidLengthGenerated
  6203  			}
  6204  			if (iNdEx + skippy) > l {
  6205  				return io.ErrUnexpectedEOF
  6206  			}
  6207  			iNdEx += skippy
  6208  		}
  6209  	}
  6210  
  6211  	if iNdEx > l {
  6212  		return io.ErrUnexpectedEOF
  6213  	}
  6214  	return nil
  6215  }
  6216  func (m *DaemonSetUpdateStrategy) Unmarshal(dAtA []byte) error {
  6217  	l := len(dAtA)
  6218  	iNdEx := 0
  6219  	for iNdEx < l {
  6220  		preIndex := iNdEx
  6221  		var wire uint64
  6222  		for shift := uint(0); ; shift += 7 {
  6223  			if shift >= 64 {
  6224  				return ErrIntOverflowGenerated
  6225  			}
  6226  			if iNdEx >= l {
  6227  				return io.ErrUnexpectedEOF
  6228  			}
  6229  			b := dAtA[iNdEx]
  6230  			iNdEx++
  6231  			wire |= uint64(b&0x7F) << shift
  6232  			if b < 0x80 {
  6233  				break
  6234  			}
  6235  		}
  6236  		fieldNum := int32(wire >> 3)
  6237  		wireType := int(wire & 0x7)
  6238  		if wireType == 4 {
  6239  			return fmt.Errorf("proto: DaemonSetUpdateStrategy: wiretype end group for non-group")
  6240  		}
  6241  		if fieldNum <= 0 {
  6242  			return fmt.Errorf("proto: DaemonSetUpdateStrategy: illegal tag %d (wire type %d)", fieldNum, wire)
  6243  		}
  6244  		switch fieldNum {
  6245  		case 1:
  6246  			if wireType != 2 {
  6247  				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
  6248  			}
  6249  			var stringLen uint64
  6250  			for shift := uint(0); ; shift += 7 {
  6251  				if shift >= 64 {
  6252  					return ErrIntOverflowGenerated
  6253  				}
  6254  				if iNdEx >= l {
  6255  					return io.ErrUnexpectedEOF
  6256  				}
  6257  				b := dAtA[iNdEx]
  6258  				iNdEx++
  6259  				stringLen |= uint64(b&0x7F) << shift
  6260  				if b < 0x80 {
  6261  					break
  6262  				}
  6263  			}
  6264  			intStringLen := int(stringLen)
  6265  			if intStringLen < 0 {
  6266  				return ErrInvalidLengthGenerated
  6267  			}
  6268  			postIndex := iNdEx + intStringLen
  6269  			if postIndex < 0 {
  6270  				return ErrInvalidLengthGenerated
  6271  			}
  6272  			if postIndex > l {
  6273  				return io.ErrUnexpectedEOF
  6274  			}
  6275  			m.Type = DaemonSetUpdateStrategyType(dAtA[iNdEx:postIndex])
  6276  			iNdEx = postIndex
  6277  		case 2:
  6278  			if wireType != 2 {
  6279  				return fmt.Errorf("proto: wrong wireType = %d for field RollingUpdate", wireType)
  6280  			}
  6281  			var msglen int
  6282  			for shift := uint(0); ; shift += 7 {
  6283  				if shift >= 64 {
  6284  					return ErrIntOverflowGenerated
  6285  				}
  6286  				if iNdEx >= l {
  6287  					return io.ErrUnexpectedEOF
  6288  				}
  6289  				b := dAtA[iNdEx]
  6290  				iNdEx++
  6291  				msglen |= int(b&0x7F) << shift
  6292  				if b < 0x80 {
  6293  					break
  6294  				}
  6295  			}
  6296  			if msglen < 0 {
  6297  				return ErrInvalidLengthGenerated
  6298  			}
  6299  			postIndex := iNdEx + msglen
  6300  			if postIndex < 0 {
  6301  				return ErrInvalidLengthGenerated
  6302  			}
  6303  			if postIndex > l {
  6304  				return io.ErrUnexpectedEOF
  6305  			}
  6306  			if m.RollingUpdate == nil {
  6307  				m.RollingUpdate = &RollingUpdateDaemonSet{}
  6308  			}
  6309  			if err := m.RollingUpdate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  6310  				return err
  6311  			}
  6312  			iNdEx = postIndex
  6313  		default:
  6314  			iNdEx = preIndex
  6315  			skippy, err := skipGenerated(dAtA[iNdEx:])
  6316  			if err != nil {
  6317  				return err
  6318  			}
  6319  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  6320  				return ErrInvalidLengthGenerated
  6321  			}
  6322  			if (iNdEx + skippy) > l {
  6323  				return io.ErrUnexpectedEOF
  6324  			}
  6325  			iNdEx += skippy
  6326  		}
  6327  	}
  6328  
  6329  	if iNdEx > l {
  6330  		return io.ErrUnexpectedEOF
  6331  	}
  6332  	return nil
  6333  }
  6334  func (m *Deployment) Unmarshal(dAtA []byte) error {
  6335  	l := len(dAtA)
  6336  	iNdEx := 0
  6337  	for iNdEx < l {
  6338  		preIndex := iNdEx
  6339  		var wire uint64
  6340  		for shift := uint(0); ; shift += 7 {
  6341  			if shift >= 64 {
  6342  				return ErrIntOverflowGenerated
  6343  			}
  6344  			if iNdEx >= l {
  6345  				return io.ErrUnexpectedEOF
  6346  			}
  6347  			b := dAtA[iNdEx]
  6348  			iNdEx++
  6349  			wire |= uint64(b&0x7F) << shift
  6350  			if b < 0x80 {
  6351  				break
  6352  			}
  6353  		}
  6354  		fieldNum := int32(wire >> 3)
  6355  		wireType := int(wire & 0x7)
  6356  		if wireType == 4 {
  6357  			return fmt.Errorf("proto: Deployment: wiretype end group for non-group")
  6358  		}
  6359  		if fieldNum <= 0 {
  6360  			return fmt.Errorf("proto: Deployment: illegal tag %d (wire type %d)", fieldNum, wire)
  6361  		}
  6362  		switch fieldNum {
  6363  		case 1:
  6364  			if wireType != 2 {
  6365  				return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
  6366  			}
  6367  			var msglen int
  6368  			for shift := uint(0); ; shift += 7 {
  6369  				if shift >= 64 {
  6370  					return ErrIntOverflowGenerated
  6371  				}
  6372  				if iNdEx >= l {
  6373  					return io.ErrUnexpectedEOF
  6374  				}
  6375  				b := dAtA[iNdEx]
  6376  				iNdEx++
  6377  				msglen |= int(b&0x7F) << shift
  6378  				if b < 0x80 {
  6379  					break
  6380  				}
  6381  			}
  6382  			if msglen < 0 {
  6383  				return ErrInvalidLengthGenerated
  6384  			}
  6385  			postIndex := iNdEx + msglen
  6386  			if postIndex < 0 {
  6387  				return ErrInvalidLengthGenerated
  6388  			}
  6389  			if postIndex > l {
  6390  				return io.ErrUnexpectedEOF
  6391  			}
  6392  			if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  6393  				return err
  6394  			}
  6395  			iNdEx = postIndex
  6396  		case 2:
  6397  			if wireType != 2 {
  6398  				return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
  6399  			}
  6400  			var msglen int
  6401  			for shift := uint(0); ; shift += 7 {
  6402  				if shift >= 64 {
  6403  					return ErrIntOverflowGenerated
  6404  				}
  6405  				if iNdEx >= l {
  6406  					return io.ErrUnexpectedEOF
  6407  				}
  6408  				b := dAtA[iNdEx]
  6409  				iNdEx++
  6410  				msglen |= int(b&0x7F) << shift
  6411  				if b < 0x80 {
  6412  					break
  6413  				}
  6414  			}
  6415  			if msglen < 0 {
  6416  				return ErrInvalidLengthGenerated
  6417  			}
  6418  			postIndex := iNdEx + msglen
  6419  			if postIndex < 0 {
  6420  				return ErrInvalidLengthGenerated
  6421  			}
  6422  			if postIndex > l {
  6423  				return io.ErrUnexpectedEOF
  6424  			}
  6425  			if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  6426  				return err
  6427  			}
  6428  			iNdEx = postIndex
  6429  		case 3:
  6430  			if wireType != 2 {
  6431  				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
  6432  			}
  6433  			var msglen int
  6434  			for shift := uint(0); ; shift += 7 {
  6435  				if shift >= 64 {
  6436  					return ErrIntOverflowGenerated
  6437  				}
  6438  				if iNdEx >= l {
  6439  					return io.ErrUnexpectedEOF
  6440  				}
  6441  				b := dAtA[iNdEx]
  6442  				iNdEx++
  6443  				msglen |= int(b&0x7F) << shift
  6444  				if b < 0x80 {
  6445  					break
  6446  				}
  6447  			}
  6448  			if msglen < 0 {
  6449  				return ErrInvalidLengthGenerated
  6450  			}
  6451  			postIndex := iNdEx + msglen
  6452  			if postIndex < 0 {
  6453  				return ErrInvalidLengthGenerated
  6454  			}
  6455  			if postIndex > l {
  6456  				return io.ErrUnexpectedEOF
  6457  			}
  6458  			if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  6459  				return err
  6460  			}
  6461  			iNdEx = postIndex
  6462  		default:
  6463  			iNdEx = preIndex
  6464  			skippy, err := skipGenerated(dAtA[iNdEx:])
  6465  			if err != nil {
  6466  				return err
  6467  			}
  6468  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  6469  				return ErrInvalidLengthGenerated
  6470  			}
  6471  			if (iNdEx + skippy) > l {
  6472  				return io.ErrUnexpectedEOF
  6473  			}
  6474  			iNdEx += skippy
  6475  		}
  6476  	}
  6477  
  6478  	if iNdEx > l {
  6479  		return io.ErrUnexpectedEOF
  6480  	}
  6481  	return nil
  6482  }
  6483  func (m *DeploymentCondition) Unmarshal(dAtA []byte) error {
  6484  	l := len(dAtA)
  6485  	iNdEx := 0
  6486  	for iNdEx < l {
  6487  		preIndex := iNdEx
  6488  		var wire uint64
  6489  		for shift := uint(0); ; shift += 7 {
  6490  			if shift >= 64 {
  6491  				return ErrIntOverflowGenerated
  6492  			}
  6493  			if iNdEx >= l {
  6494  				return io.ErrUnexpectedEOF
  6495  			}
  6496  			b := dAtA[iNdEx]
  6497  			iNdEx++
  6498  			wire |= uint64(b&0x7F) << shift
  6499  			if b < 0x80 {
  6500  				break
  6501  			}
  6502  		}
  6503  		fieldNum := int32(wire >> 3)
  6504  		wireType := int(wire & 0x7)
  6505  		if wireType == 4 {
  6506  			return fmt.Errorf("proto: DeploymentCondition: wiretype end group for non-group")
  6507  		}
  6508  		if fieldNum <= 0 {
  6509  			return fmt.Errorf("proto: DeploymentCondition: illegal tag %d (wire type %d)", fieldNum, wire)
  6510  		}
  6511  		switch fieldNum {
  6512  		case 1:
  6513  			if wireType != 2 {
  6514  				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
  6515  			}
  6516  			var stringLen uint64
  6517  			for shift := uint(0); ; shift += 7 {
  6518  				if shift >= 64 {
  6519  					return ErrIntOverflowGenerated
  6520  				}
  6521  				if iNdEx >= l {
  6522  					return io.ErrUnexpectedEOF
  6523  				}
  6524  				b := dAtA[iNdEx]
  6525  				iNdEx++
  6526  				stringLen |= uint64(b&0x7F) << shift
  6527  				if b < 0x80 {
  6528  					break
  6529  				}
  6530  			}
  6531  			intStringLen := int(stringLen)
  6532  			if intStringLen < 0 {
  6533  				return ErrInvalidLengthGenerated
  6534  			}
  6535  			postIndex := iNdEx + intStringLen
  6536  			if postIndex < 0 {
  6537  				return ErrInvalidLengthGenerated
  6538  			}
  6539  			if postIndex > l {
  6540  				return io.ErrUnexpectedEOF
  6541  			}
  6542  			m.Type = DeploymentConditionType(dAtA[iNdEx:postIndex])
  6543  			iNdEx = postIndex
  6544  		case 2:
  6545  			if wireType != 2 {
  6546  				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
  6547  			}
  6548  			var stringLen uint64
  6549  			for shift := uint(0); ; shift += 7 {
  6550  				if shift >= 64 {
  6551  					return ErrIntOverflowGenerated
  6552  				}
  6553  				if iNdEx >= l {
  6554  					return io.ErrUnexpectedEOF
  6555  				}
  6556  				b := dAtA[iNdEx]
  6557  				iNdEx++
  6558  				stringLen |= uint64(b&0x7F) << shift
  6559  				if b < 0x80 {
  6560  					break
  6561  				}
  6562  			}
  6563  			intStringLen := int(stringLen)
  6564  			if intStringLen < 0 {
  6565  				return ErrInvalidLengthGenerated
  6566  			}
  6567  			postIndex := iNdEx + intStringLen
  6568  			if postIndex < 0 {
  6569  				return ErrInvalidLengthGenerated
  6570  			}
  6571  			if postIndex > l {
  6572  				return io.ErrUnexpectedEOF
  6573  			}
  6574  			m.Status = k8s_io_api_core_v1.ConditionStatus(dAtA[iNdEx:postIndex])
  6575  			iNdEx = postIndex
  6576  		case 4:
  6577  			if wireType != 2 {
  6578  				return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
  6579  			}
  6580  			var stringLen uint64
  6581  			for shift := uint(0); ; shift += 7 {
  6582  				if shift >= 64 {
  6583  					return ErrIntOverflowGenerated
  6584  				}
  6585  				if iNdEx >= l {
  6586  					return io.ErrUnexpectedEOF
  6587  				}
  6588  				b := dAtA[iNdEx]
  6589  				iNdEx++
  6590  				stringLen |= uint64(b&0x7F) << shift
  6591  				if b < 0x80 {
  6592  					break
  6593  				}
  6594  			}
  6595  			intStringLen := int(stringLen)
  6596  			if intStringLen < 0 {
  6597  				return ErrInvalidLengthGenerated
  6598  			}
  6599  			postIndex := iNdEx + intStringLen
  6600  			if postIndex < 0 {
  6601  				return ErrInvalidLengthGenerated
  6602  			}
  6603  			if postIndex > l {
  6604  				return io.ErrUnexpectedEOF
  6605  			}
  6606  			m.Reason = string(dAtA[iNdEx:postIndex])
  6607  			iNdEx = postIndex
  6608  		case 5:
  6609  			if wireType != 2 {
  6610  				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
  6611  			}
  6612  			var stringLen uint64
  6613  			for shift := uint(0); ; shift += 7 {
  6614  				if shift >= 64 {
  6615  					return ErrIntOverflowGenerated
  6616  				}
  6617  				if iNdEx >= l {
  6618  					return io.ErrUnexpectedEOF
  6619  				}
  6620  				b := dAtA[iNdEx]
  6621  				iNdEx++
  6622  				stringLen |= uint64(b&0x7F) << shift
  6623  				if b < 0x80 {
  6624  					break
  6625  				}
  6626  			}
  6627  			intStringLen := int(stringLen)
  6628  			if intStringLen < 0 {
  6629  				return ErrInvalidLengthGenerated
  6630  			}
  6631  			postIndex := iNdEx + intStringLen
  6632  			if postIndex < 0 {
  6633  				return ErrInvalidLengthGenerated
  6634  			}
  6635  			if postIndex > l {
  6636  				return io.ErrUnexpectedEOF
  6637  			}
  6638  			m.Message = string(dAtA[iNdEx:postIndex])
  6639  			iNdEx = postIndex
  6640  		case 6:
  6641  			if wireType != 2 {
  6642  				return fmt.Errorf("proto: wrong wireType = %d for field LastUpdateTime", wireType)
  6643  			}
  6644  			var msglen int
  6645  			for shift := uint(0); ; shift += 7 {
  6646  				if shift >= 64 {
  6647  					return ErrIntOverflowGenerated
  6648  				}
  6649  				if iNdEx >= l {
  6650  					return io.ErrUnexpectedEOF
  6651  				}
  6652  				b := dAtA[iNdEx]
  6653  				iNdEx++
  6654  				msglen |= int(b&0x7F) << shift
  6655  				if b < 0x80 {
  6656  					break
  6657  				}
  6658  			}
  6659  			if msglen < 0 {
  6660  				return ErrInvalidLengthGenerated
  6661  			}
  6662  			postIndex := iNdEx + msglen
  6663  			if postIndex < 0 {
  6664  				return ErrInvalidLengthGenerated
  6665  			}
  6666  			if postIndex > l {
  6667  				return io.ErrUnexpectedEOF
  6668  			}
  6669  			if err := m.LastUpdateTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  6670  				return err
  6671  			}
  6672  			iNdEx = postIndex
  6673  		case 7:
  6674  			if wireType != 2 {
  6675  				return fmt.Errorf("proto: wrong wireType = %d for field LastTransitionTime", wireType)
  6676  			}
  6677  			var msglen int
  6678  			for shift := uint(0); ; shift += 7 {
  6679  				if shift >= 64 {
  6680  					return ErrIntOverflowGenerated
  6681  				}
  6682  				if iNdEx >= l {
  6683  					return io.ErrUnexpectedEOF
  6684  				}
  6685  				b := dAtA[iNdEx]
  6686  				iNdEx++
  6687  				msglen |= int(b&0x7F) << shift
  6688  				if b < 0x80 {
  6689  					break
  6690  				}
  6691  			}
  6692  			if msglen < 0 {
  6693  				return ErrInvalidLengthGenerated
  6694  			}
  6695  			postIndex := iNdEx + msglen
  6696  			if postIndex < 0 {
  6697  				return ErrInvalidLengthGenerated
  6698  			}
  6699  			if postIndex > l {
  6700  				return io.ErrUnexpectedEOF
  6701  			}
  6702  			if err := m.LastTransitionTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  6703  				return err
  6704  			}
  6705  			iNdEx = postIndex
  6706  		default:
  6707  			iNdEx = preIndex
  6708  			skippy, err := skipGenerated(dAtA[iNdEx:])
  6709  			if err != nil {
  6710  				return err
  6711  			}
  6712  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  6713  				return ErrInvalidLengthGenerated
  6714  			}
  6715  			if (iNdEx + skippy) > l {
  6716  				return io.ErrUnexpectedEOF
  6717  			}
  6718  			iNdEx += skippy
  6719  		}
  6720  	}
  6721  
  6722  	if iNdEx > l {
  6723  		return io.ErrUnexpectedEOF
  6724  	}
  6725  	return nil
  6726  }
  6727  func (m *DeploymentList) Unmarshal(dAtA []byte) error {
  6728  	l := len(dAtA)
  6729  	iNdEx := 0
  6730  	for iNdEx < l {
  6731  		preIndex := iNdEx
  6732  		var wire uint64
  6733  		for shift := uint(0); ; shift += 7 {
  6734  			if shift >= 64 {
  6735  				return ErrIntOverflowGenerated
  6736  			}
  6737  			if iNdEx >= l {
  6738  				return io.ErrUnexpectedEOF
  6739  			}
  6740  			b := dAtA[iNdEx]
  6741  			iNdEx++
  6742  			wire |= uint64(b&0x7F) << shift
  6743  			if b < 0x80 {
  6744  				break
  6745  			}
  6746  		}
  6747  		fieldNum := int32(wire >> 3)
  6748  		wireType := int(wire & 0x7)
  6749  		if wireType == 4 {
  6750  			return fmt.Errorf("proto: DeploymentList: wiretype end group for non-group")
  6751  		}
  6752  		if fieldNum <= 0 {
  6753  			return fmt.Errorf("proto: DeploymentList: illegal tag %d (wire type %d)", fieldNum, wire)
  6754  		}
  6755  		switch fieldNum {
  6756  		case 1:
  6757  			if wireType != 2 {
  6758  				return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
  6759  			}
  6760  			var msglen int
  6761  			for shift := uint(0); ; shift += 7 {
  6762  				if shift >= 64 {
  6763  					return ErrIntOverflowGenerated
  6764  				}
  6765  				if iNdEx >= l {
  6766  					return io.ErrUnexpectedEOF
  6767  				}
  6768  				b := dAtA[iNdEx]
  6769  				iNdEx++
  6770  				msglen |= int(b&0x7F) << shift
  6771  				if b < 0x80 {
  6772  					break
  6773  				}
  6774  			}
  6775  			if msglen < 0 {
  6776  				return ErrInvalidLengthGenerated
  6777  			}
  6778  			postIndex := iNdEx + msglen
  6779  			if postIndex < 0 {
  6780  				return ErrInvalidLengthGenerated
  6781  			}
  6782  			if postIndex > l {
  6783  				return io.ErrUnexpectedEOF
  6784  			}
  6785  			if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  6786  				return err
  6787  			}
  6788  			iNdEx = postIndex
  6789  		case 2:
  6790  			if wireType != 2 {
  6791  				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
  6792  			}
  6793  			var msglen int
  6794  			for shift := uint(0); ; shift += 7 {
  6795  				if shift >= 64 {
  6796  					return ErrIntOverflowGenerated
  6797  				}
  6798  				if iNdEx >= l {
  6799  					return io.ErrUnexpectedEOF
  6800  				}
  6801  				b := dAtA[iNdEx]
  6802  				iNdEx++
  6803  				msglen |= int(b&0x7F) << shift
  6804  				if b < 0x80 {
  6805  					break
  6806  				}
  6807  			}
  6808  			if msglen < 0 {
  6809  				return ErrInvalidLengthGenerated
  6810  			}
  6811  			postIndex := iNdEx + msglen
  6812  			if postIndex < 0 {
  6813  				return ErrInvalidLengthGenerated
  6814  			}
  6815  			if postIndex > l {
  6816  				return io.ErrUnexpectedEOF
  6817  			}
  6818  			m.Items = append(m.Items, Deployment{})
  6819  			if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  6820  				return err
  6821  			}
  6822  			iNdEx = postIndex
  6823  		default:
  6824  			iNdEx = preIndex
  6825  			skippy, err := skipGenerated(dAtA[iNdEx:])
  6826  			if err != nil {
  6827  				return err
  6828  			}
  6829  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  6830  				return ErrInvalidLengthGenerated
  6831  			}
  6832  			if (iNdEx + skippy) > l {
  6833  				return io.ErrUnexpectedEOF
  6834  			}
  6835  			iNdEx += skippy
  6836  		}
  6837  	}
  6838  
  6839  	if iNdEx > l {
  6840  		return io.ErrUnexpectedEOF
  6841  	}
  6842  	return nil
  6843  }
  6844  func (m *DeploymentRollback) Unmarshal(dAtA []byte) error {
  6845  	l := len(dAtA)
  6846  	iNdEx := 0
  6847  	for iNdEx < l {
  6848  		preIndex := iNdEx
  6849  		var wire uint64
  6850  		for shift := uint(0); ; shift += 7 {
  6851  			if shift >= 64 {
  6852  				return ErrIntOverflowGenerated
  6853  			}
  6854  			if iNdEx >= l {
  6855  				return io.ErrUnexpectedEOF
  6856  			}
  6857  			b := dAtA[iNdEx]
  6858  			iNdEx++
  6859  			wire |= uint64(b&0x7F) << shift
  6860  			if b < 0x80 {
  6861  				break
  6862  			}
  6863  		}
  6864  		fieldNum := int32(wire >> 3)
  6865  		wireType := int(wire & 0x7)
  6866  		if wireType == 4 {
  6867  			return fmt.Errorf("proto: DeploymentRollback: wiretype end group for non-group")
  6868  		}
  6869  		if fieldNum <= 0 {
  6870  			return fmt.Errorf("proto: DeploymentRollback: illegal tag %d (wire type %d)", fieldNum, wire)
  6871  		}
  6872  		switch fieldNum {
  6873  		case 1:
  6874  			if wireType != 2 {
  6875  				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
  6876  			}
  6877  			var stringLen uint64
  6878  			for shift := uint(0); ; shift += 7 {
  6879  				if shift >= 64 {
  6880  					return ErrIntOverflowGenerated
  6881  				}
  6882  				if iNdEx >= l {
  6883  					return io.ErrUnexpectedEOF
  6884  				}
  6885  				b := dAtA[iNdEx]
  6886  				iNdEx++
  6887  				stringLen |= uint64(b&0x7F) << shift
  6888  				if b < 0x80 {
  6889  					break
  6890  				}
  6891  			}
  6892  			intStringLen := int(stringLen)
  6893  			if intStringLen < 0 {
  6894  				return ErrInvalidLengthGenerated
  6895  			}
  6896  			postIndex := iNdEx + intStringLen
  6897  			if postIndex < 0 {
  6898  				return ErrInvalidLengthGenerated
  6899  			}
  6900  			if postIndex > l {
  6901  				return io.ErrUnexpectedEOF
  6902  			}
  6903  			m.Name = string(dAtA[iNdEx:postIndex])
  6904  			iNdEx = postIndex
  6905  		case 2:
  6906  			if wireType != 2 {
  6907  				return fmt.Errorf("proto: wrong wireType = %d for field UpdatedAnnotations", wireType)
  6908  			}
  6909  			var msglen int
  6910  			for shift := uint(0); ; shift += 7 {
  6911  				if shift >= 64 {
  6912  					return ErrIntOverflowGenerated
  6913  				}
  6914  				if iNdEx >= l {
  6915  					return io.ErrUnexpectedEOF
  6916  				}
  6917  				b := dAtA[iNdEx]
  6918  				iNdEx++
  6919  				msglen |= int(b&0x7F) << shift
  6920  				if b < 0x80 {
  6921  					break
  6922  				}
  6923  			}
  6924  			if msglen < 0 {
  6925  				return ErrInvalidLengthGenerated
  6926  			}
  6927  			postIndex := iNdEx + msglen
  6928  			if postIndex < 0 {
  6929  				return ErrInvalidLengthGenerated
  6930  			}
  6931  			if postIndex > l {
  6932  				return io.ErrUnexpectedEOF
  6933  			}
  6934  			if m.UpdatedAnnotations == nil {
  6935  				m.UpdatedAnnotations = make(map[string]string)
  6936  			}
  6937  			var mapkey string
  6938  			var mapvalue string
  6939  			for iNdEx < postIndex {
  6940  				entryPreIndex := iNdEx
  6941  				var wire uint64
  6942  				for shift := uint(0); ; shift += 7 {
  6943  					if shift >= 64 {
  6944  						return ErrIntOverflowGenerated
  6945  					}
  6946  					if iNdEx >= l {
  6947  						return io.ErrUnexpectedEOF
  6948  					}
  6949  					b := dAtA[iNdEx]
  6950  					iNdEx++
  6951  					wire |= uint64(b&0x7F) << shift
  6952  					if b < 0x80 {
  6953  						break
  6954  					}
  6955  				}
  6956  				fieldNum := int32(wire >> 3)
  6957  				if fieldNum == 1 {
  6958  					var stringLenmapkey uint64
  6959  					for shift := uint(0); ; shift += 7 {
  6960  						if shift >= 64 {
  6961  							return ErrIntOverflowGenerated
  6962  						}
  6963  						if iNdEx >= l {
  6964  							return io.ErrUnexpectedEOF
  6965  						}
  6966  						b := dAtA[iNdEx]
  6967  						iNdEx++
  6968  						stringLenmapkey |= uint64(b&0x7F) << shift
  6969  						if b < 0x80 {
  6970  							break
  6971  						}
  6972  					}
  6973  					intStringLenmapkey := int(stringLenmapkey)
  6974  					if intStringLenmapkey < 0 {
  6975  						return ErrInvalidLengthGenerated
  6976  					}
  6977  					postStringIndexmapkey := iNdEx + intStringLenmapkey
  6978  					if postStringIndexmapkey < 0 {
  6979  						return ErrInvalidLengthGenerated
  6980  					}
  6981  					if postStringIndexmapkey > l {
  6982  						return io.ErrUnexpectedEOF
  6983  					}
  6984  					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
  6985  					iNdEx = postStringIndexmapkey
  6986  				} else if fieldNum == 2 {
  6987  					var stringLenmapvalue uint64
  6988  					for shift := uint(0); ; shift += 7 {
  6989  						if shift >= 64 {
  6990  							return ErrIntOverflowGenerated
  6991  						}
  6992  						if iNdEx >= l {
  6993  							return io.ErrUnexpectedEOF
  6994  						}
  6995  						b := dAtA[iNdEx]
  6996  						iNdEx++
  6997  						stringLenmapvalue |= uint64(b&0x7F) << shift
  6998  						if b < 0x80 {
  6999  							break
  7000  						}
  7001  					}
  7002  					intStringLenmapvalue := int(stringLenmapvalue)
  7003  					if intStringLenmapvalue < 0 {
  7004  						return ErrInvalidLengthGenerated
  7005  					}
  7006  					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
  7007  					if postStringIndexmapvalue < 0 {
  7008  						return ErrInvalidLengthGenerated
  7009  					}
  7010  					if postStringIndexmapvalue > l {
  7011  						return io.ErrUnexpectedEOF
  7012  					}
  7013  					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
  7014  					iNdEx = postStringIndexmapvalue
  7015  				} else {
  7016  					iNdEx = entryPreIndex
  7017  					skippy, err := skipGenerated(dAtA[iNdEx:])
  7018  					if err != nil {
  7019  						return err
  7020  					}
  7021  					if (skippy < 0) || (iNdEx+skippy) < 0 {
  7022  						return ErrInvalidLengthGenerated
  7023  					}
  7024  					if (iNdEx + skippy) > postIndex {
  7025  						return io.ErrUnexpectedEOF
  7026  					}
  7027  					iNdEx += skippy
  7028  				}
  7029  			}
  7030  			m.UpdatedAnnotations[mapkey] = mapvalue
  7031  			iNdEx = postIndex
  7032  		case 3:
  7033  			if wireType != 2 {
  7034  				return fmt.Errorf("proto: wrong wireType = %d for field RollbackTo", wireType)
  7035  			}
  7036  			var msglen int
  7037  			for shift := uint(0); ; shift += 7 {
  7038  				if shift >= 64 {
  7039  					return ErrIntOverflowGenerated
  7040  				}
  7041  				if iNdEx >= l {
  7042  					return io.ErrUnexpectedEOF
  7043  				}
  7044  				b := dAtA[iNdEx]
  7045  				iNdEx++
  7046  				msglen |= int(b&0x7F) << shift
  7047  				if b < 0x80 {
  7048  					break
  7049  				}
  7050  			}
  7051  			if msglen < 0 {
  7052  				return ErrInvalidLengthGenerated
  7053  			}
  7054  			postIndex := iNdEx + msglen
  7055  			if postIndex < 0 {
  7056  				return ErrInvalidLengthGenerated
  7057  			}
  7058  			if postIndex > l {
  7059  				return io.ErrUnexpectedEOF
  7060  			}
  7061  			if err := m.RollbackTo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  7062  				return err
  7063  			}
  7064  			iNdEx = postIndex
  7065  		default:
  7066  			iNdEx = preIndex
  7067  			skippy, err := skipGenerated(dAtA[iNdEx:])
  7068  			if err != nil {
  7069  				return err
  7070  			}
  7071  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  7072  				return ErrInvalidLengthGenerated
  7073  			}
  7074  			if (iNdEx + skippy) > l {
  7075  				return io.ErrUnexpectedEOF
  7076  			}
  7077  			iNdEx += skippy
  7078  		}
  7079  	}
  7080  
  7081  	if iNdEx > l {
  7082  		return io.ErrUnexpectedEOF
  7083  	}
  7084  	return nil
  7085  }
  7086  func (m *DeploymentSpec) Unmarshal(dAtA []byte) error {
  7087  	l := len(dAtA)
  7088  	iNdEx := 0
  7089  	for iNdEx < l {
  7090  		preIndex := iNdEx
  7091  		var wire uint64
  7092  		for shift := uint(0); ; shift += 7 {
  7093  			if shift >= 64 {
  7094  				return ErrIntOverflowGenerated
  7095  			}
  7096  			if iNdEx >= l {
  7097  				return io.ErrUnexpectedEOF
  7098  			}
  7099  			b := dAtA[iNdEx]
  7100  			iNdEx++
  7101  			wire |= uint64(b&0x7F) << shift
  7102  			if b < 0x80 {
  7103  				break
  7104  			}
  7105  		}
  7106  		fieldNum := int32(wire >> 3)
  7107  		wireType := int(wire & 0x7)
  7108  		if wireType == 4 {
  7109  			return fmt.Errorf("proto: DeploymentSpec: wiretype end group for non-group")
  7110  		}
  7111  		if fieldNum <= 0 {
  7112  			return fmt.Errorf("proto: DeploymentSpec: illegal tag %d (wire type %d)", fieldNum, wire)
  7113  		}
  7114  		switch fieldNum {
  7115  		case 1:
  7116  			if wireType != 0 {
  7117  				return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
  7118  			}
  7119  			var v int32
  7120  			for shift := uint(0); ; shift += 7 {
  7121  				if shift >= 64 {
  7122  					return ErrIntOverflowGenerated
  7123  				}
  7124  				if iNdEx >= l {
  7125  					return io.ErrUnexpectedEOF
  7126  				}
  7127  				b := dAtA[iNdEx]
  7128  				iNdEx++
  7129  				v |= int32(b&0x7F) << shift
  7130  				if b < 0x80 {
  7131  					break
  7132  				}
  7133  			}
  7134  			m.Replicas = &v
  7135  		case 2:
  7136  			if wireType != 2 {
  7137  				return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType)
  7138  			}
  7139  			var msglen int
  7140  			for shift := uint(0); ; shift += 7 {
  7141  				if shift >= 64 {
  7142  					return ErrIntOverflowGenerated
  7143  				}
  7144  				if iNdEx >= l {
  7145  					return io.ErrUnexpectedEOF
  7146  				}
  7147  				b := dAtA[iNdEx]
  7148  				iNdEx++
  7149  				msglen |= int(b&0x7F) << shift
  7150  				if b < 0x80 {
  7151  					break
  7152  				}
  7153  			}
  7154  			if msglen < 0 {
  7155  				return ErrInvalidLengthGenerated
  7156  			}
  7157  			postIndex := iNdEx + msglen
  7158  			if postIndex < 0 {
  7159  				return ErrInvalidLengthGenerated
  7160  			}
  7161  			if postIndex > l {
  7162  				return io.ErrUnexpectedEOF
  7163  			}
  7164  			if m.Selector == nil {
  7165  				m.Selector = &v1.LabelSelector{}
  7166  			}
  7167  			if err := m.Selector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  7168  				return err
  7169  			}
  7170  			iNdEx = postIndex
  7171  		case 3:
  7172  			if wireType != 2 {
  7173  				return fmt.Errorf("proto: wrong wireType = %d for field Template", wireType)
  7174  			}
  7175  			var msglen int
  7176  			for shift := uint(0); ; shift += 7 {
  7177  				if shift >= 64 {
  7178  					return ErrIntOverflowGenerated
  7179  				}
  7180  				if iNdEx >= l {
  7181  					return io.ErrUnexpectedEOF
  7182  				}
  7183  				b := dAtA[iNdEx]
  7184  				iNdEx++
  7185  				msglen |= int(b&0x7F) << shift
  7186  				if b < 0x80 {
  7187  					break
  7188  				}
  7189  			}
  7190  			if msglen < 0 {
  7191  				return ErrInvalidLengthGenerated
  7192  			}
  7193  			postIndex := iNdEx + msglen
  7194  			if postIndex < 0 {
  7195  				return ErrInvalidLengthGenerated
  7196  			}
  7197  			if postIndex > l {
  7198  				return io.ErrUnexpectedEOF
  7199  			}
  7200  			if err := m.Template.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  7201  				return err
  7202  			}
  7203  			iNdEx = postIndex
  7204  		case 4:
  7205  			if wireType != 2 {
  7206  				return fmt.Errorf("proto: wrong wireType = %d for field Strategy", wireType)
  7207  			}
  7208  			var msglen int
  7209  			for shift := uint(0); ; shift += 7 {
  7210  				if shift >= 64 {
  7211  					return ErrIntOverflowGenerated
  7212  				}
  7213  				if iNdEx >= l {
  7214  					return io.ErrUnexpectedEOF
  7215  				}
  7216  				b := dAtA[iNdEx]
  7217  				iNdEx++
  7218  				msglen |= int(b&0x7F) << shift
  7219  				if b < 0x80 {
  7220  					break
  7221  				}
  7222  			}
  7223  			if msglen < 0 {
  7224  				return ErrInvalidLengthGenerated
  7225  			}
  7226  			postIndex := iNdEx + msglen
  7227  			if postIndex < 0 {
  7228  				return ErrInvalidLengthGenerated
  7229  			}
  7230  			if postIndex > l {
  7231  				return io.ErrUnexpectedEOF
  7232  			}
  7233  			if err := m.Strategy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  7234  				return err
  7235  			}
  7236  			iNdEx = postIndex
  7237  		case 5:
  7238  			if wireType != 0 {
  7239  				return fmt.Errorf("proto: wrong wireType = %d for field MinReadySeconds", wireType)
  7240  			}
  7241  			m.MinReadySeconds = 0
  7242  			for shift := uint(0); ; shift += 7 {
  7243  				if shift >= 64 {
  7244  					return ErrIntOverflowGenerated
  7245  				}
  7246  				if iNdEx >= l {
  7247  					return io.ErrUnexpectedEOF
  7248  				}
  7249  				b := dAtA[iNdEx]
  7250  				iNdEx++
  7251  				m.MinReadySeconds |= int32(b&0x7F) << shift
  7252  				if b < 0x80 {
  7253  					break
  7254  				}
  7255  			}
  7256  		case 6:
  7257  			if wireType != 0 {
  7258  				return fmt.Errorf("proto: wrong wireType = %d for field RevisionHistoryLimit", wireType)
  7259  			}
  7260  			var v int32
  7261  			for shift := uint(0); ; shift += 7 {
  7262  				if shift >= 64 {
  7263  					return ErrIntOverflowGenerated
  7264  				}
  7265  				if iNdEx >= l {
  7266  					return io.ErrUnexpectedEOF
  7267  				}
  7268  				b := dAtA[iNdEx]
  7269  				iNdEx++
  7270  				v |= int32(b&0x7F) << shift
  7271  				if b < 0x80 {
  7272  					break
  7273  				}
  7274  			}
  7275  			m.RevisionHistoryLimit = &v
  7276  		case 7:
  7277  			if wireType != 0 {
  7278  				return fmt.Errorf("proto: wrong wireType = %d for field Paused", wireType)
  7279  			}
  7280  			var v int
  7281  			for shift := uint(0); ; shift += 7 {
  7282  				if shift >= 64 {
  7283  					return ErrIntOverflowGenerated
  7284  				}
  7285  				if iNdEx >= l {
  7286  					return io.ErrUnexpectedEOF
  7287  				}
  7288  				b := dAtA[iNdEx]
  7289  				iNdEx++
  7290  				v |= int(b&0x7F) << shift
  7291  				if b < 0x80 {
  7292  					break
  7293  				}
  7294  			}
  7295  			m.Paused = bool(v != 0)
  7296  		case 8:
  7297  			if wireType != 2 {
  7298  				return fmt.Errorf("proto: wrong wireType = %d for field RollbackTo", wireType)
  7299  			}
  7300  			var msglen int
  7301  			for shift := uint(0); ; shift += 7 {
  7302  				if shift >= 64 {
  7303  					return ErrIntOverflowGenerated
  7304  				}
  7305  				if iNdEx >= l {
  7306  					return io.ErrUnexpectedEOF
  7307  				}
  7308  				b := dAtA[iNdEx]
  7309  				iNdEx++
  7310  				msglen |= int(b&0x7F) << shift
  7311  				if b < 0x80 {
  7312  					break
  7313  				}
  7314  			}
  7315  			if msglen < 0 {
  7316  				return ErrInvalidLengthGenerated
  7317  			}
  7318  			postIndex := iNdEx + msglen
  7319  			if postIndex < 0 {
  7320  				return ErrInvalidLengthGenerated
  7321  			}
  7322  			if postIndex > l {
  7323  				return io.ErrUnexpectedEOF
  7324  			}
  7325  			if m.RollbackTo == nil {
  7326  				m.RollbackTo = &RollbackConfig{}
  7327  			}
  7328  			if err := m.RollbackTo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  7329  				return err
  7330  			}
  7331  			iNdEx = postIndex
  7332  		case 9:
  7333  			if wireType != 0 {
  7334  				return fmt.Errorf("proto: wrong wireType = %d for field ProgressDeadlineSeconds", wireType)
  7335  			}
  7336  			var v int32
  7337  			for shift := uint(0); ; shift += 7 {
  7338  				if shift >= 64 {
  7339  					return ErrIntOverflowGenerated
  7340  				}
  7341  				if iNdEx >= l {
  7342  					return io.ErrUnexpectedEOF
  7343  				}
  7344  				b := dAtA[iNdEx]
  7345  				iNdEx++
  7346  				v |= int32(b&0x7F) << shift
  7347  				if b < 0x80 {
  7348  					break
  7349  				}
  7350  			}
  7351  			m.ProgressDeadlineSeconds = &v
  7352  		default:
  7353  			iNdEx = preIndex
  7354  			skippy, err := skipGenerated(dAtA[iNdEx:])
  7355  			if err != nil {
  7356  				return err
  7357  			}
  7358  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  7359  				return ErrInvalidLengthGenerated
  7360  			}
  7361  			if (iNdEx + skippy) > l {
  7362  				return io.ErrUnexpectedEOF
  7363  			}
  7364  			iNdEx += skippy
  7365  		}
  7366  	}
  7367  
  7368  	if iNdEx > l {
  7369  		return io.ErrUnexpectedEOF
  7370  	}
  7371  	return nil
  7372  }
  7373  func (m *DeploymentStatus) Unmarshal(dAtA []byte) error {
  7374  	l := len(dAtA)
  7375  	iNdEx := 0
  7376  	for iNdEx < l {
  7377  		preIndex := iNdEx
  7378  		var wire uint64
  7379  		for shift := uint(0); ; shift += 7 {
  7380  			if shift >= 64 {
  7381  				return ErrIntOverflowGenerated
  7382  			}
  7383  			if iNdEx >= l {
  7384  				return io.ErrUnexpectedEOF
  7385  			}
  7386  			b := dAtA[iNdEx]
  7387  			iNdEx++
  7388  			wire |= uint64(b&0x7F) << shift
  7389  			if b < 0x80 {
  7390  				break
  7391  			}
  7392  		}
  7393  		fieldNum := int32(wire >> 3)
  7394  		wireType := int(wire & 0x7)
  7395  		if wireType == 4 {
  7396  			return fmt.Errorf("proto: DeploymentStatus: wiretype end group for non-group")
  7397  		}
  7398  		if fieldNum <= 0 {
  7399  			return fmt.Errorf("proto: DeploymentStatus: illegal tag %d (wire type %d)", fieldNum, wire)
  7400  		}
  7401  		switch fieldNum {
  7402  		case 1:
  7403  			if wireType != 0 {
  7404  				return fmt.Errorf("proto: wrong wireType = %d for field ObservedGeneration", wireType)
  7405  			}
  7406  			m.ObservedGeneration = 0
  7407  			for shift := uint(0); ; shift += 7 {
  7408  				if shift >= 64 {
  7409  					return ErrIntOverflowGenerated
  7410  				}
  7411  				if iNdEx >= l {
  7412  					return io.ErrUnexpectedEOF
  7413  				}
  7414  				b := dAtA[iNdEx]
  7415  				iNdEx++
  7416  				m.ObservedGeneration |= int64(b&0x7F) << shift
  7417  				if b < 0x80 {
  7418  					break
  7419  				}
  7420  			}
  7421  		case 2:
  7422  			if wireType != 0 {
  7423  				return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
  7424  			}
  7425  			m.Replicas = 0
  7426  			for shift := uint(0); ; shift += 7 {
  7427  				if shift >= 64 {
  7428  					return ErrIntOverflowGenerated
  7429  				}
  7430  				if iNdEx >= l {
  7431  					return io.ErrUnexpectedEOF
  7432  				}
  7433  				b := dAtA[iNdEx]
  7434  				iNdEx++
  7435  				m.Replicas |= int32(b&0x7F) << shift
  7436  				if b < 0x80 {
  7437  					break
  7438  				}
  7439  			}
  7440  		case 3:
  7441  			if wireType != 0 {
  7442  				return fmt.Errorf("proto: wrong wireType = %d for field UpdatedReplicas", wireType)
  7443  			}
  7444  			m.UpdatedReplicas = 0
  7445  			for shift := uint(0); ; shift += 7 {
  7446  				if shift >= 64 {
  7447  					return ErrIntOverflowGenerated
  7448  				}
  7449  				if iNdEx >= l {
  7450  					return io.ErrUnexpectedEOF
  7451  				}
  7452  				b := dAtA[iNdEx]
  7453  				iNdEx++
  7454  				m.UpdatedReplicas |= int32(b&0x7F) << shift
  7455  				if b < 0x80 {
  7456  					break
  7457  				}
  7458  			}
  7459  		case 4:
  7460  			if wireType != 0 {
  7461  				return fmt.Errorf("proto: wrong wireType = %d for field AvailableReplicas", wireType)
  7462  			}
  7463  			m.AvailableReplicas = 0
  7464  			for shift := uint(0); ; shift += 7 {
  7465  				if shift >= 64 {
  7466  					return ErrIntOverflowGenerated
  7467  				}
  7468  				if iNdEx >= l {
  7469  					return io.ErrUnexpectedEOF
  7470  				}
  7471  				b := dAtA[iNdEx]
  7472  				iNdEx++
  7473  				m.AvailableReplicas |= int32(b&0x7F) << shift
  7474  				if b < 0x80 {
  7475  					break
  7476  				}
  7477  			}
  7478  		case 5:
  7479  			if wireType != 0 {
  7480  				return fmt.Errorf("proto: wrong wireType = %d for field UnavailableReplicas", wireType)
  7481  			}
  7482  			m.UnavailableReplicas = 0
  7483  			for shift := uint(0); ; shift += 7 {
  7484  				if shift >= 64 {
  7485  					return ErrIntOverflowGenerated
  7486  				}
  7487  				if iNdEx >= l {
  7488  					return io.ErrUnexpectedEOF
  7489  				}
  7490  				b := dAtA[iNdEx]
  7491  				iNdEx++
  7492  				m.UnavailableReplicas |= int32(b&0x7F) << shift
  7493  				if b < 0x80 {
  7494  					break
  7495  				}
  7496  			}
  7497  		case 6:
  7498  			if wireType != 2 {
  7499  				return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType)
  7500  			}
  7501  			var msglen int
  7502  			for shift := uint(0); ; shift += 7 {
  7503  				if shift >= 64 {
  7504  					return ErrIntOverflowGenerated
  7505  				}
  7506  				if iNdEx >= l {
  7507  					return io.ErrUnexpectedEOF
  7508  				}
  7509  				b := dAtA[iNdEx]
  7510  				iNdEx++
  7511  				msglen |= int(b&0x7F) << shift
  7512  				if b < 0x80 {
  7513  					break
  7514  				}
  7515  			}
  7516  			if msglen < 0 {
  7517  				return ErrInvalidLengthGenerated
  7518  			}
  7519  			postIndex := iNdEx + msglen
  7520  			if postIndex < 0 {
  7521  				return ErrInvalidLengthGenerated
  7522  			}
  7523  			if postIndex > l {
  7524  				return io.ErrUnexpectedEOF
  7525  			}
  7526  			m.Conditions = append(m.Conditions, DeploymentCondition{})
  7527  			if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  7528  				return err
  7529  			}
  7530  			iNdEx = postIndex
  7531  		case 7:
  7532  			if wireType != 0 {
  7533  				return fmt.Errorf("proto: wrong wireType = %d for field ReadyReplicas", wireType)
  7534  			}
  7535  			m.ReadyReplicas = 0
  7536  			for shift := uint(0); ; shift += 7 {
  7537  				if shift >= 64 {
  7538  					return ErrIntOverflowGenerated
  7539  				}
  7540  				if iNdEx >= l {
  7541  					return io.ErrUnexpectedEOF
  7542  				}
  7543  				b := dAtA[iNdEx]
  7544  				iNdEx++
  7545  				m.ReadyReplicas |= int32(b&0x7F) << shift
  7546  				if b < 0x80 {
  7547  					break
  7548  				}
  7549  			}
  7550  		case 8:
  7551  			if wireType != 0 {
  7552  				return fmt.Errorf("proto: wrong wireType = %d for field CollisionCount", wireType)
  7553  			}
  7554  			var v int32
  7555  			for shift := uint(0); ; shift += 7 {
  7556  				if shift >= 64 {
  7557  					return ErrIntOverflowGenerated
  7558  				}
  7559  				if iNdEx >= l {
  7560  					return io.ErrUnexpectedEOF
  7561  				}
  7562  				b := dAtA[iNdEx]
  7563  				iNdEx++
  7564  				v |= int32(b&0x7F) << shift
  7565  				if b < 0x80 {
  7566  					break
  7567  				}
  7568  			}
  7569  			m.CollisionCount = &v
  7570  		default:
  7571  			iNdEx = preIndex
  7572  			skippy, err := skipGenerated(dAtA[iNdEx:])
  7573  			if err != nil {
  7574  				return err
  7575  			}
  7576  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  7577  				return ErrInvalidLengthGenerated
  7578  			}
  7579  			if (iNdEx + skippy) > l {
  7580  				return io.ErrUnexpectedEOF
  7581  			}
  7582  			iNdEx += skippy
  7583  		}
  7584  	}
  7585  
  7586  	if iNdEx > l {
  7587  		return io.ErrUnexpectedEOF
  7588  	}
  7589  	return nil
  7590  }
  7591  func (m *DeploymentStrategy) Unmarshal(dAtA []byte) error {
  7592  	l := len(dAtA)
  7593  	iNdEx := 0
  7594  	for iNdEx < l {
  7595  		preIndex := iNdEx
  7596  		var wire uint64
  7597  		for shift := uint(0); ; shift += 7 {
  7598  			if shift >= 64 {
  7599  				return ErrIntOverflowGenerated
  7600  			}
  7601  			if iNdEx >= l {
  7602  				return io.ErrUnexpectedEOF
  7603  			}
  7604  			b := dAtA[iNdEx]
  7605  			iNdEx++
  7606  			wire |= uint64(b&0x7F) << shift
  7607  			if b < 0x80 {
  7608  				break
  7609  			}
  7610  		}
  7611  		fieldNum := int32(wire >> 3)
  7612  		wireType := int(wire & 0x7)
  7613  		if wireType == 4 {
  7614  			return fmt.Errorf("proto: DeploymentStrategy: wiretype end group for non-group")
  7615  		}
  7616  		if fieldNum <= 0 {
  7617  			return fmt.Errorf("proto: DeploymentStrategy: illegal tag %d (wire type %d)", fieldNum, wire)
  7618  		}
  7619  		switch fieldNum {
  7620  		case 1:
  7621  			if wireType != 2 {
  7622  				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
  7623  			}
  7624  			var stringLen uint64
  7625  			for shift := uint(0); ; shift += 7 {
  7626  				if shift >= 64 {
  7627  					return ErrIntOverflowGenerated
  7628  				}
  7629  				if iNdEx >= l {
  7630  					return io.ErrUnexpectedEOF
  7631  				}
  7632  				b := dAtA[iNdEx]
  7633  				iNdEx++
  7634  				stringLen |= uint64(b&0x7F) << shift
  7635  				if b < 0x80 {
  7636  					break
  7637  				}
  7638  			}
  7639  			intStringLen := int(stringLen)
  7640  			if intStringLen < 0 {
  7641  				return ErrInvalidLengthGenerated
  7642  			}
  7643  			postIndex := iNdEx + intStringLen
  7644  			if postIndex < 0 {
  7645  				return ErrInvalidLengthGenerated
  7646  			}
  7647  			if postIndex > l {
  7648  				return io.ErrUnexpectedEOF
  7649  			}
  7650  			m.Type = DeploymentStrategyType(dAtA[iNdEx:postIndex])
  7651  			iNdEx = postIndex
  7652  		case 2:
  7653  			if wireType != 2 {
  7654  				return fmt.Errorf("proto: wrong wireType = %d for field RollingUpdate", wireType)
  7655  			}
  7656  			var msglen int
  7657  			for shift := uint(0); ; shift += 7 {
  7658  				if shift >= 64 {
  7659  					return ErrIntOverflowGenerated
  7660  				}
  7661  				if iNdEx >= l {
  7662  					return io.ErrUnexpectedEOF
  7663  				}
  7664  				b := dAtA[iNdEx]
  7665  				iNdEx++
  7666  				msglen |= int(b&0x7F) << shift
  7667  				if b < 0x80 {
  7668  					break
  7669  				}
  7670  			}
  7671  			if msglen < 0 {
  7672  				return ErrInvalidLengthGenerated
  7673  			}
  7674  			postIndex := iNdEx + msglen
  7675  			if postIndex < 0 {
  7676  				return ErrInvalidLengthGenerated
  7677  			}
  7678  			if postIndex > l {
  7679  				return io.ErrUnexpectedEOF
  7680  			}
  7681  			if m.RollingUpdate == nil {
  7682  				m.RollingUpdate = &RollingUpdateDeployment{}
  7683  			}
  7684  			if err := m.RollingUpdate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  7685  				return err
  7686  			}
  7687  			iNdEx = postIndex
  7688  		default:
  7689  			iNdEx = preIndex
  7690  			skippy, err := skipGenerated(dAtA[iNdEx:])
  7691  			if err != nil {
  7692  				return err
  7693  			}
  7694  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  7695  				return ErrInvalidLengthGenerated
  7696  			}
  7697  			if (iNdEx + skippy) > l {
  7698  				return io.ErrUnexpectedEOF
  7699  			}
  7700  			iNdEx += skippy
  7701  		}
  7702  	}
  7703  
  7704  	if iNdEx > l {
  7705  		return io.ErrUnexpectedEOF
  7706  	}
  7707  	return nil
  7708  }
  7709  func (m *HTTPIngressPath) Unmarshal(dAtA []byte) error {
  7710  	l := len(dAtA)
  7711  	iNdEx := 0
  7712  	for iNdEx < l {
  7713  		preIndex := iNdEx
  7714  		var wire uint64
  7715  		for shift := uint(0); ; shift += 7 {
  7716  			if shift >= 64 {
  7717  				return ErrIntOverflowGenerated
  7718  			}
  7719  			if iNdEx >= l {
  7720  				return io.ErrUnexpectedEOF
  7721  			}
  7722  			b := dAtA[iNdEx]
  7723  			iNdEx++
  7724  			wire |= uint64(b&0x7F) << shift
  7725  			if b < 0x80 {
  7726  				break
  7727  			}
  7728  		}
  7729  		fieldNum := int32(wire >> 3)
  7730  		wireType := int(wire & 0x7)
  7731  		if wireType == 4 {
  7732  			return fmt.Errorf("proto: HTTPIngressPath: wiretype end group for non-group")
  7733  		}
  7734  		if fieldNum <= 0 {
  7735  			return fmt.Errorf("proto: HTTPIngressPath: illegal tag %d (wire type %d)", fieldNum, wire)
  7736  		}
  7737  		switch fieldNum {
  7738  		case 1:
  7739  			if wireType != 2 {
  7740  				return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
  7741  			}
  7742  			var stringLen uint64
  7743  			for shift := uint(0); ; shift += 7 {
  7744  				if shift >= 64 {
  7745  					return ErrIntOverflowGenerated
  7746  				}
  7747  				if iNdEx >= l {
  7748  					return io.ErrUnexpectedEOF
  7749  				}
  7750  				b := dAtA[iNdEx]
  7751  				iNdEx++
  7752  				stringLen |= uint64(b&0x7F) << shift
  7753  				if b < 0x80 {
  7754  					break
  7755  				}
  7756  			}
  7757  			intStringLen := int(stringLen)
  7758  			if intStringLen < 0 {
  7759  				return ErrInvalidLengthGenerated
  7760  			}
  7761  			postIndex := iNdEx + intStringLen
  7762  			if postIndex < 0 {
  7763  				return ErrInvalidLengthGenerated
  7764  			}
  7765  			if postIndex > l {
  7766  				return io.ErrUnexpectedEOF
  7767  			}
  7768  			m.Path = string(dAtA[iNdEx:postIndex])
  7769  			iNdEx = postIndex
  7770  		case 2:
  7771  			if wireType != 2 {
  7772  				return fmt.Errorf("proto: wrong wireType = %d for field Backend", wireType)
  7773  			}
  7774  			var msglen int
  7775  			for shift := uint(0); ; shift += 7 {
  7776  				if shift >= 64 {
  7777  					return ErrIntOverflowGenerated
  7778  				}
  7779  				if iNdEx >= l {
  7780  					return io.ErrUnexpectedEOF
  7781  				}
  7782  				b := dAtA[iNdEx]
  7783  				iNdEx++
  7784  				msglen |= int(b&0x7F) << shift
  7785  				if b < 0x80 {
  7786  					break
  7787  				}
  7788  			}
  7789  			if msglen < 0 {
  7790  				return ErrInvalidLengthGenerated
  7791  			}
  7792  			postIndex := iNdEx + msglen
  7793  			if postIndex < 0 {
  7794  				return ErrInvalidLengthGenerated
  7795  			}
  7796  			if postIndex > l {
  7797  				return io.ErrUnexpectedEOF
  7798  			}
  7799  			if err := m.Backend.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  7800  				return err
  7801  			}
  7802  			iNdEx = postIndex
  7803  		case 3:
  7804  			if wireType != 2 {
  7805  				return fmt.Errorf("proto: wrong wireType = %d for field PathType", wireType)
  7806  			}
  7807  			var stringLen uint64
  7808  			for shift := uint(0); ; shift += 7 {
  7809  				if shift >= 64 {
  7810  					return ErrIntOverflowGenerated
  7811  				}
  7812  				if iNdEx >= l {
  7813  					return io.ErrUnexpectedEOF
  7814  				}
  7815  				b := dAtA[iNdEx]
  7816  				iNdEx++
  7817  				stringLen |= uint64(b&0x7F) << shift
  7818  				if b < 0x80 {
  7819  					break
  7820  				}
  7821  			}
  7822  			intStringLen := int(stringLen)
  7823  			if intStringLen < 0 {
  7824  				return ErrInvalidLengthGenerated
  7825  			}
  7826  			postIndex := iNdEx + intStringLen
  7827  			if postIndex < 0 {
  7828  				return ErrInvalidLengthGenerated
  7829  			}
  7830  			if postIndex > l {
  7831  				return io.ErrUnexpectedEOF
  7832  			}
  7833  			s := PathType(dAtA[iNdEx:postIndex])
  7834  			m.PathType = &s
  7835  			iNdEx = postIndex
  7836  		default:
  7837  			iNdEx = preIndex
  7838  			skippy, err := skipGenerated(dAtA[iNdEx:])
  7839  			if err != nil {
  7840  				return err
  7841  			}
  7842  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  7843  				return ErrInvalidLengthGenerated
  7844  			}
  7845  			if (iNdEx + skippy) > l {
  7846  				return io.ErrUnexpectedEOF
  7847  			}
  7848  			iNdEx += skippy
  7849  		}
  7850  	}
  7851  
  7852  	if iNdEx > l {
  7853  		return io.ErrUnexpectedEOF
  7854  	}
  7855  	return nil
  7856  }
  7857  func (m *HTTPIngressRuleValue) Unmarshal(dAtA []byte) error {
  7858  	l := len(dAtA)
  7859  	iNdEx := 0
  7860  	for iNdEx < l {
  7861  		preIndex := iNdEx
  7862  		var wire uint64
  7863  		for shift := uint(0); ; shift += 7 {
  7864  			if shift >= 64 {
  7865  				return ErrIntOverflowGenerated
  7866  			}
  7867  			if iNdEx >= l {
  7868  				return io.ErrUnexpectedEOF
  7869  			}
  7870  			b := dAtA[iNdEx]
  7871  			iNdEx++
  7872  			wire |= uint64(b&0x7F) << shift
  7873  			if b < 0x80 {
  7874  				break
  7875  			}
  7876  		}
  7877  		fieldNum := int32(wire >> 3)
  7878  		wireType := int(wire & 0x7)
  7879  		if wireType == 4 {
  7880  			return fmt.Errorf("proto: HTTPIngressRuleValue: wiretype end group for non-group")
  7881  		}
  7882  		if fieldNum <= 0 {
  7883  			return fmt.Errorf("proto: HTTPIngressRuleValue: illegal tag %d (wire type %d)", fieldNum, wire)
  7884  		}
  7885  		switch fieldNum {
  7886  		case 1:
  7887  			if wireType != 2 {
  7888  				return fmt.Errorf("proto: wrong wireType = %d for field Paths", wireType)
  7889  			}
  7890  			var msglen int
  7891  			for shift := uint(0); ; shift += 7 {
  7892  				if shift >= 64 {
  7893  					return ErrIntOverflowGenerated
  7894  				}
  7895  				if iNdEx >= l {
  7896  					return io.ErrUnexpectedEOF
  7897  				}
  7898  				b := dAtA[iNdEx]
  7899  				iNdEx++
  7900  				msglen |= int(b&0x7F) << shift
  7901  				if b < 0x80 {
  7902  					break
  7903  				}
  7904  			}
  7905  			if msglen < 0 {
  7906  				return ErrInvalidLengthGenerated
  7907  			}
  7908  			postIndex := iNdEx + msglen
  7909  			if postIndex < 0 {
  7910  				return ErrInvalidLengthGenerated
  7911  			}
  7912  			if postIndex > l {
  7913  				return io.ErrUnexpectedEOF
  7914  			}
  7915  			m.Paths = append(m.Paths, HTTPIngressPath{})
  7916  			if err := m.Paths[len(m.Paths)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  7917  				return err
  7918  			}
  7919  			iNdEx = postIndex
  7920  		default:
  7921  			iNdEx = preIndex
  7922  			skippy, err := skipGenerated(dAtA[iNdEx:])
  7923  			if err != nil {
  7924  				return err
  7925  			}
  7926  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  7927  				return ErrInvalidLengthGenerated
  7928  			}
  7929  			if (iNdEx + skippy) > l {
  7930  				return io.ErrUnexpectedEOF
  7931  			}
  7932  			iNdEx += skippy
  7933  		}
  7934  	}
  7935  
  7936  	if iNdEx > l {
  7937  		return io.ErrUnexpectedEOF
  7938  	}
  7939  	return nil
  7940  }
  7941  func (m *IPBlock) Unmarshal(dAtA []byte) error {
  7942  	l := len(dAtA)
  7943  	iNdEx := 0
  7944  	for iNdEx < l {
  7945  		preIndex := iNdEx
  7946  		var wire uint64
  7947  		for shift := uint(0); ; shift += 7 {
  7948  			if shift >= 64 {
  7949  				return ErrIntOverflowGenerated
  7950  			}
  7951  			if iNdEx >= l {
  7952  				return io.ErrUnexpectedEOF
  7953  			}
  7954  			b := dAtA[iNdEx]
  7955  			iNdEx++
  7956  			wire |= uint64(b&0x7F) << shift
  7957  			if b < 0x80 {
  7958  				break
  7959  			}
  7960  		}
  7961  		fieldNum := int32(wire >> 3)
  7962  		wireType := int(wire & 0x7)
  7963  		if wireType == 4 {
  7964  			return fmt.Errorf("proto: IPBlock: wiretype end group for non-group")
  7965  		}
  7966  		if fieldNum <= 0 {
  7967  			return fmt.Errorf("proto: IPBlock: illegal tag %d (wire type %d)", fieldNum, wire)
  7968  		}
  7969  		switch fieldNum {
  7970  		case 1:
  7971  			if wireType != 2 {
  7972  				return fmt.Errorf("proto: wrong wireType = %d for field CIDR", wireType)
  7973  			}
  7974  			var stringLen uint64
  7975  			for shift := uint(0); ; shift += 7 {
  7976  				if shift >= 64 {
  7977  					return ErrIntOverflowGenerated
  7978  				}
  7979  				if iNdEx >= l {
  7980  					return io.ErrUnexpectedEOF
  7981  				}
  7982  				b := dAtA[iNdEx]
  7983  				iNdEx++
  7984  				stringLen |= uint64(b&0x7F) << shift
  7985  				if b < 0x80 {
  7986  					break
  7987  				}
  7988  			}
  7989  			intStringLen := int(stringLen)
  7990  			if intStringLen < 0 {
  7991  				return ErrInvalidLengthGenerated
  7992  			}
  7993  			postIndex := iNdEx + intStringLen
  7994  			if postIndex < 0 {
  7995  				return ErrInvalidLengthGenerated
  7996  			}
  7997  			if postIndex > l {
  7998  				return io.ErrUnexpectedEOF
  7999  			}
  8000  			m.CIDR = string(dAtA[iNdEx:postIndex])
  8001  			iNdEx = postIndex
  8002  		case 2:
  8003  			if wireType != 2 {
  8004  				return fmt.Errorf("proto: wrong wireType = %d for field Except", wireType)
  8005  			}
  8006  			var stringLen uint64
  8007  			for shift := uint(0); ; shift += 7 {
  8008  				if shift >= 64 {
  8009  					return ErrIntOverflowGenerated
  8010  				}
  8011  				if iNdEx >= l {
  8012  					return io.ErrUnexpectedEOF
  8013  				}
  8014  				b := dAtA[iNdEx]
  8015  				iNdEx++
  8016  				stringLen |= uint64(b&0x7F) << shift
  8017  				if b < 0x80 {
  8018  					break
  8019  				}
  8020  			}
  8021  			intStringLen := int(stringLen)
  8022  			if intStringLen < 0 {
  8023  				return ErrInvalidLengthGenerated
  8024  			}
  8025  			postIndex := iNdEx + intStringLen
  8026  			if postIndex < 0 {
  8027  				return ErrInvalidLengthGenerated
  8028  			}
  8029  			if postIndex > l {
  8030  				return io.ErrUnexpectedEOF
  8031  			}
  8032  			m.Except = append(m.Except, string(dAtA[iNdEx:postIndex]))
  8033  			iNdEx = postIndex
  8034  		default:
  8035  			iNdEx = preIndex
  8036  			skippy, err := skipGenerated(dAtA[iNdEx:])
  8037  			if err != nil {
  8038  				return err
  8039  			}
  8040  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  8041  				return ErrInvalidLengthGenerated
  8042  			}
  8043  			if (iNdEx + skippy) > l {
  8044  				return io.ErrUnexpectedEOF
  8045  			}
  8046  			iNdEx += skippy
  8047  		}
  8048  	}
  8049  
  8050  	if iNdEx > l {
  8051  		return io.ErrUnexpectedEOF
  8052  	}
  8053  	return nil
  8054  }
  8055  func (m *Ingress) Unmarshal(dAtA []byte) error {
  8056  	l := len(dAtA)
  8057  	iNdEx := 0
  8058  	for iNdEx < l {
  8059  		preIndex := iNdEx
  8060  		var wire uint64
  8061  		for shift := uint(0); ; shift += 7 {
  8062  			if shift >= 64 {
  8063  				return ErrIntOverflowGenerated
  8064  			}
  8065  			if iNdEx >= l {
  8066  				return io.ErrUnexpectedEOF
  8067  			}
  8068  			b := dAtA[iNdEx]
  8069  			iNdEx++
  8070  			wire |= uint64(b&0x7F) << shift
  8071  			if b < 0x80 {
  8072  				break
  8073  			}
  8074  		}
  8075  		fieldNum := int32(wire >> 3)
  8076  		wireType := int(wire & 0x7)
  8077  		if wireType == 4 {
  8078  			return fmt.Errorf("proto: Ingress: wiretype end group for non-group")
  8079  		}
  8080  		if fieldNum <= 0 {
  8081  			return fmt.Errorf("proto: Ingress: illegal tag %d (wire type %d)", fieldNum, wire)
  8082  		}
  8083  		switch fieldNum {
  8084  		case 1:
  8085  			if wireType != 2 {
  8086  				return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
  8087  			}
  8088  			var msglen int
  8089  			for shift := uint(0); ; shift += 7 {
  8090  				if shift >= 64 {
  8091  					return ErrIntOverflowGenerated
  8092  				}
  8093  				if iNdEx >= l {
  8094  					return io.ErrUnexpectedEOF
  8095  				}
  8096  				b := dAtA[iNdEx]
  8097  				iNdEx++
  8098  				msglen |= int(b&0x7F) << shift
  8099  				if b < 0x80 {
  8100  					break
  8101  				}
  8102  			}
  8103  			if msglen < 0 {
  8104  				return ErrInvalidLengthGenerated
  8105  			}
  8106  			postIndex := iNdEx + msglen
  8107  			if postIndex < 0 {
  8108  				return ErrInvalidLengthGenerated
  8109  			}
  8110  			if postIndex > l {
  8111  				return io.ErrUnexpectedEOF
  8112  			}
  8113  			if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  8114  				return err
  8115  			}
  8116  			iNdEx = postIndex
  8117  		case 2:
  8118  			if wireType != 2 {
  8119  				return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
  8120  			}
  8121  			var msglen int
  8122  			for shift := uint(0); ; shift += 7 {
  8123  				if shift >= 64 {
  8124  					return ErrIntOverflowGenerated
  8125  				}
  8126  				if iNdEx >= l {
  8127  					return io.ErrUnexpectedEOF
  8128  				}
  8129  				b := dAtA[iNdEx]
  8130  				iNdEx++
  8131  				msglen |= int(b&0x7F) << shift
  8132  				if b < 0x80 {
  8133  					break
  8134  				}
  8135  			}
  8136  			if msglen < 0 {
  8137  				return ErrInvalidLengthGenerated
  8138  			}
  8139  			postIndex := iNdEx + msglen
  8140  			if postIndex < 0 {
  8141  				return ErrInvalidLengthGenerated
  8142  			}
  8143  			if postIndex > l {
  8144  				return io.ErrUnexpectedEOF
  8145  			}
  8146  			if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  8147  				return err
  8148  			}
  8149  			iNdEx = postIndex
  8150  		case 3:
  8151  			if wireType != 2 {
  8152  				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
  8153  			}
  8154  			var msglen int
  8155  			for shift := uint(0); ; shift += 7 {
  8156  				if shift >= 64 {
  8157  					return ErrIntOverflowGenerated
  8158  				}
  8159  				if iNdEx >= l {
  8160  					return io.ErrUnexpectedEOF
  8161  				}
  8162  				b := dAtA[iNdEx]
  8163  				iNdEx++
  8164  				msglen |= int(b&0x7F) << shift
  8165  				if b < 0x80 {
  8166  					break
  8167  				}
  8168  			}
  8169  			if msglen < 0 {
  8170  				return ErrInvalidLengthGenerated
  8171  			}
  8172  			postIndex := iNdEx + msglen
  8173  			if postIndex < 0 {
  8174  				return ErrInvalidLengthGenerated
  8175  			}
  8176  			if postIndex > l {
  8177  				return io.ErrUnexpectedEOF
  8178  			}
  8179  			if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  8180  				return err
  8181  			}
  8182  			iNdEx = postIndex
  8183  		default:
  8184  			iNdEx = preIndex
  8185  			skippy, err := skipGenerated(dAtA[iNdEx:])
  8186  			if err != nil {
  8187  				return err
  8188  			}
  8189  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  8190  				return ErrInvalidLengthGenerated
  8191  			}
  8192  			if (iNdEx + skippy) > l {
  8193  				return io.ErrUnexpectedEOF
  8194  			}
  8195  			iNdEx += skippy
  8196  		}
  8197  	}
  8198  
  8199  	if iNdEx > l {
  8200  		return io.ErrUnexpectedEOF
  8201  	}
  8202  	return nil
  8203  }
  8204  func (m *IngressBackend) Unmarshal(dAtA []byte) error {
  8205  	l := len(dAtA)
  8206  	iNdEx := 0
  8207  	for iNdEx < l {
  8208  		preIndex := iNdEx
  8209  		var wire uint64
  8210  		for shift := uint(0); ; shift += 7 {
  8211  			if shift >= 64 {
  8212  				return ErrIntOverflowGenerated
  8213  			}
  8214  			if iNdEx >= l {
  8215  				return io.ErrUnexpectedEOF
  8216  			}
  8217  			b := dAtA[iNdEx]
  8218  			iNdEx++
  8219  			wire |= uint64(b&0x7F) << shift
  8220  			if b < 0x80 {
  8221  				break
  8222  			}
  8223  		}
  8224  		fieldNum := int32(wire >> 3)
  8225  		wireType := int(wire & 0x7)
  8226  		if wireType == 4 {
  8227  			return fmt.Errorf("proto: IngressBackend: wiretype end group for non-group")
  8228  		}
  8229  		if fieldNum <= 0 {
  8230  			return fmt.Errorf("proto: IngressBackend: illegal tag %d (wire type %d)", fieldNum, wire)
  8231  		}
  8232  		switch fieldNum {
  8233  		case 1:
  8234  			if wireType != 2 {
  8235  				return fmt.Errorf("proto: wrong wireType = %d for field ServiceName", wireType)
  8236  			}
  8237  			var stringLen uint64
  8238  			for shift := uint(0); ; shift += 7 {
  8239  				if shift >= 64 {
  8240  					return ErrIntOverflowGenerated
  8241  				}
  8242  				if iNdEx >= l {
  8243  					return io.ErrUnexpectedEOF
  8244  				}
  8245  				b := dAtA[iNdEx]
  8246  				iNdEx++
  8247  				stringLen |= uint64(b&0x7F) << shift
  8248  				if b < 0x80 {
  8249  					break
  8250  				}
  8251  			}
  8252  			intStringLen := int(stringLen)
  8253  			if intStringLen < 0 {
  8254  				return ErrInvalidLengthGenerated
  8255  			}
  8256  			postIndex := iNdEx + intStringLen
  8257  			if postIndex < 0 {
  8258  				return ErrInvalidLengthGenerated
  8259  			}
  8260  			if postIndex > l {
  8261  				return io.ErrUnexpectedEOF
  8262  			}
  8263  			m.ServiceName = string(dAtA[iNdEx:postIndex])
  8264  			iNdEx = postIndex
  8265  		case 2:
  8266  			if wireType != 2 {
  8267  				return fmt.Errorf("proto: wrong wireType = %d for field ServicePort", wireType)
  8268  			}
  8269  			var msglen int
  8270  			for shift := uint(0); ; shift += 7 {
  8271  				if shift >= 64 {
  8272  					return ErrIntOverflowGenerated
  8273  				}
  8274  				if iNdEx >= l {
  8275  					return io.ErrUnexpectedEOF
  8276  				}
  8277  				b := dAtA[iNdEx]
  8278  				iNdEx++
  8279  				msglen |= int(b&0x7F) << shift
  8280  				if b < 0x80 {
  8281  					break
  8282  				}
  8283  			}
  8284  			if msglen < 0 {
  8285  				return ErrInvalidLengthGenerated
  8286  			}
  8287  			postIndex := iNdEx + msglen
  8288  			if postIndex < 0 {
  8289  				return ErrInvalidLengthGenerated
  8290  			}
  8291  			if postIndex > l {
  8292  				return io.ErrUnexpectedEOF
  8293  			}
  8294  			if err := m.ServicePort.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  8295  				return err
  8296  			}
  8297  			iNdEx = postIndex
  8298  		case 3:
  8299  			if wireType != 2 {
  8300  				return fmt.Errorf("proto: wrong wireType = %d for field Resource", wireType)
  8301  			}
  8302  			var msglen int
  8303  			for shift := uint(0); ; shift += 7 {
  8304  				if shift >= 64 {
  8305  					return ErrIntOverflowGenerated
  8306  				}
  8307  				if iNdEx >= l {
  8308  					return io.ErrUnexpectedEOF
  8309  				}
  8310  				b := dAtA[iNdEx]
  8311  				iNdEx++
  8312  				msglen |= int(b&0x7F) << shift
  8313  				if b < 0x80 {
  8314  					break
  8315  				}
  8316  			}
  8317  			if msglen < 0 {
  8318  				return ErrInvalidLengthGenerated
  8319  			}
  8320  			postIndex := iNdEx + msglen
  8321  			if postIndex < 0 {
  8322  				return ErrInvalidLengthGenerated
  8323  			}
  8324  			if postIndex > l {
  8325  				return io.ErrUnexpectedEOF
  8326  			}
  8327  			if m.Resource == nil {
  8328  				m.Resource = &v11.TypedLocalObjectReference{}
  8329  			}
  8330  			if err := m.Resource.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  8331  				return err
  8332  			}
  8333  			iNdEx = postIndex
  8334  		default:
  8335  			iNdEx = preIndex
  8336  			skippy, err := skipGenerated(dAtA[iNdEx:])
  8337  			if err != nil {
  8338  				return err
  8339  			}
  8340  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  8341  				return ErrInvalidLengthGenerated
  8342  			}
  8343  			if (iNdEx + skippy) > l {
  8344  				return io.ErrUnexpectedEOF
  8345  			}
  8346  			iNdEx += skippy
  8347  		}
  8348  	}
  8349  
  8350  	if iNdEx > l {
  8351  		return io.ErrUnexpectedEOF
  8352  	}
  8353  	return nil
  8354  }
  8355  func (m *IngressList) Unmarshal(dAtA []byte) error {
  8356  	l := len(dAtA)
  8357  	iNdEx := 0
  8358  	for iNdEx < l {
  8359  		preIndex := iNdEx
  8360  		var wire uint64
  8361  		for shift := uint(0); ; shift += 7 {
  8362  			if shift >= 64 {
  8363  				return ErrIntOverflowGenerated
  8364  			}
  8365  			if iNdEx >= l {
  8366  				return io.ErrUnexpectedEOF
  8367  			}
  8368  			b := dAtA[iNdEx]
  8369  			iNdEx++
  8370  			wire |= uint64(b&0x7F) << shift
  8371  			if b < 0x80 {
  8372  				break
  8373  			}
  8374  		}
  8375  		fieldNum := int32(wire >> 3)
  8376  		wireType := int(wire & 0x7)
  8377  		if wireType == 4 {
  8378  			return fmt.Errorf("proto: IngressList: wiretype end group for non-group")
  8379  		}
  8380  		if fieldNum <= 0 {
  8381  			return fmt.Errorf("proto: IngressList: illegal tag %d (wire type %d)", fieldNum, wire)
  8382  		}
  8383  		switch fieldNum {
  8384  		case 1:
  8385  			if wireType != 2 {
  8386  				return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
  8387  			}
  8388  			var msglen int
  8389  			for shift := uint(0); ; shift += 7 {
  8390  				if shift >= 64 {
  8391  					return ErrIntOverflowGenerated
  8392  				}
  8393  				if iNdEx >= l {
  8394  					return io.ErrUnexpectedEOF
  8395  				}
  8396  				b := dAtA[iNdEx]
  8397  				iNdEx++
  8398  				msglen |= int(b&0x7F) << shift
  8399  				if b < 0x80 {
  8400  					break
  8401  				}
  8402  			}
  8403  			if msglen < 0 {
  8404  				return ErrInvalidLengthGenerated
  8405  			}
  8406  			postIndex := iNdEx + msglen
  8407  			if postIndex < 0 {
  8408  				return ErrInvalidLengthGenerated
  8409  			}
  8410  			if postIndex > l {
  8411  				return io.ErrUnexpectedEOF
  8412  			}
  8413  			if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  8414  				return err
  8415  			}
  8416  			iNdEx = postIndex
  8417  		case 2:
  8418  			if wireType != 2 {
  8419  				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
  8420  			}
  8421  			var msglen int
  8422  			for shift := uint(0); ; shift += 7 {
  8423  				if shift >= 64 {
  8424  					return ErrIntOverflowGenerated
  8425  				}
  8426  				if iNdEx >= l {
  8427  					return io.ErrUnexpectedEOF
  8428  				}
  8429  				b := dAtA[iNdEx]
  8430  				iNdEx++
  8431  				msglen |= int(b&0x7F) << shift
  8432  				if b < 0x80 {
  8433  					break
  8434  				}
  8435  			}
  8436  			if msglen < 0 {
  8437  				return ErrInvalidLengthGenerated
  8438  			}
  8439  			postIndex := iNdEx + msglen
  8440  			if postIndex < 0 {
  8441  				return ErrInvalidLengthGenerated
  8442  			}
  8443  			if postIndex > l {
  8444  				return io.ErrUnexpectedEOF
  8445  			}
  8446  			m.Items = append(m.Items, Ingress{})
  8447  			if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  8448  				return err
  8449  			}
  8450  			iNdEx = postIndex
  8451  		default:
  8452  			iNdEx = preIndex
  8453  			skippy, err := skipGenerated(dAtA[iNdEx:])
  8454  			if err != nil {
  8455  				return err
  8456  			}
  8457  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  8458  				return ErrInvalidLengthGenerated
  8459  			}
  8460  			if (iNdEx + skippy) > l {
  8461  				return io.ErrUnexpectedEOF
  8462  			}
  8463  			iNdEx += skippy
  8464  		}
  8465  	}
  8466  
  8467  	if iNdEx > l {
  8468  		return io.ErrUnexpectedEOF
  8469  	}
  8470  	return nil
  8471  }
  8472  func (m *IngressLoadBalancerIngress) Unmarshal(dAtA []byte) error {
  8473  	l := len(dAtA)
  8474  	iNdEx := 0
  8475  	for iNdEx < l {
  8476  		preIndex := iNdEx
  8477  		var wire uint64
  8478  		for shift := uint(0); ; shift += 7 {
  8479  			if shift >= 64 {
  8480  				return ErrIntOverflowGenerated
  8481  			}
  8482  			if iNdEx >= l {
  8483  				return io.ErrUnexpectedEOF
  8484  			}
  8485  			b := dAtA[iNdEx]
  8486  			iNdEx++
  8487  			wire |= uint64(b&0x7F) << shift
  8488  			if b < 0x80 {
  8489  				break
  8490  			}
  8491  		}
  8492  		fieldNum := int32(wire >> 3)
  8493  		wireType := int(wire & 0x7)
  8494  		if wireType == 4 {
  8495  			return fmt.Errorf("proto: IngressLoadBalancerIngress: wiretype end group for non-group")
  8496  		}
  8497  		if fieldNum <= 0 {
  8498  			return fmt.Errorf("proto: IngressLoadBalancerIngress: illegal tag %d (wire type %d)", fieldNum, wire)
  8499  		}
  8500  		switch fieldNum {
  8501  		case 1:
  8502  			if wireType != 2 {
  8503  				return fmt.Errorf("proto: wrong wireType = %d for field IP", wireType)
  8504  			}
  8505  			var stringLen uint64
  8506  			for shift := uint(0); ; shift += 7 {
  8507  				if shift >= 64 {
  8508  					return ErrIntOverflowGenerated
  8509  				}
  8510  				if iNdEx >= l {
  8511  					return io.ErrUnexpectedEOF
  8512  				}
  8513  				b := dAtA[iNdEx]
  8514  				iNdEx++
  8515  				stringLen |= uint64(b&0x7F) << shift
  8516  				if b < 0x80 {
  8517  					break
  8518  				}
  8519  			}
  8520  			intStringLen := int(stringLen)
  8521  			if intStringLen < 0 {
  8522  				return ErrInvalidLengthGenerated
  8523  			}
  8524  			postIndex := iNdEx + intStringLen
  8525  			if postIndex < 0 {
  8526  				return ErrInvalidLengthGenerated
  8527  			}
  8528  			if postIndex > l {
  8529  				return io.ErrUnexpectedEOF
  8530  			}
  8531  			m.IP = string(dAtA[iNdEx:postIndex])
  8532  			iNdEx = postIndex
  8533  		case 2:
  8534  			if wireType != 2 {
  8535  				return fmt.Errorf("proto: wrong wireType = %d for field Hostname", wireType)
  8536  			}
  8537  			var stringLen uint64
  8538  			for shift := uint(0); ; shift += 7 {
  8539  				if shift >= 64 {
  8540  					return ErrIntOverflowGenerated
  8541  				}
  8542  				if iNdEx >= l {
  8543  					return io.ErrUnexpectedEOF
  8544  				}
  8545  				b := dAtA[iNdEx]
  8546  				iNdEx++
  8547  				stringLen |= uint64(b&0x7F) << shift
  8548  				if b < 0x80 {
  8549  					break
  8550  				}
  8551  			}
  8552  			intStringLen := int(stringLen)
  8553  			if intStringLen < 0 {
  8554  				return ErrInvalidLengthGenerated
  8555  			}
  8556  			postIndex := iNdEx + intStringLen
  8557  			if postIndex < 0 {
  8558  				return ErrInvalidLengthGenerated
  8559  			}
  8560  			if postIndex > l {
  8561  				return io.ErrUnexpectedEOF
  8562  			}
  8563  			m.Hostname = string(dAtA[iNdEx:postIndex])
  8564  			iNdEx = postIndex
  8565  		case 4:
  8566  			if wireType != 2 {
  8567  				return fmt.Errorf("proto: wrong wireType = %d for field Ports", wireType)
  8568  			}
  8569  			var msglen int
  8570  			for shift := uint(0); ; shift += 7 {
  8571  				if shift >= 64 {
  8572  					return ErrIntOverflowGenerated
  8573  				}
  8574  				if iNdEx >= l {
  8575  					return io.ErrUnexpectedEOF
  8576  				}
  8577  				b := dAtA[iNdEx]
  8578  				iNdEx++
  8579  				msglen |= int(b&0x7F) << shift
  8580  				if b < 0x80 {
  8581  					break
  8582  				}
  8583  			}
  8584  			if msglen < 0 {
  8585  				return ErrInvalidLengthGenerated
  8586  			}
  8587  			postIndex := iNdEx + msglen
  8588  			if postIndex < 0 {
  8589  				return ErrInvalidLengthGenerated
  8590  			}
  8591  			if postIndex > l {
  8592  				return io.ErrUnexpectedEOF
  8593  			}
  8594  			m.Ports = append(m.Ports, IngressPortStatus{})
  8595  			if err := m.Ports[len(m.Ports)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  8596  				return err
  8597  			}
  8598  			iNdEx = postIndex
  8599  		default:
  8600  			iNdEx = preIndex
  8601  			skippy, err := skipGenerated(dAtA[iNdEx:])
  8602  			if err != nil {
  8603  				return err
  8604  			}
  8605  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  8606  				return ErrInvalidLengthGenerated
  8607  			}
  8608  			if (iNdEx + skippy) > l {
  8609  				return io.ErrUnexpectedEOF
  8610  			}
  8611  			iNdEx += skippy
  8612  		}
  8613  	}
  8614  
  8615  	if iNdEx > l {
  8616  		return io.ErrUnexpectedEOF
  8617  	}
  8618  	return nil
  8619  }
  8620  func (m *IngressLoadBalancerStatus) Unmarshal(dAtA []byte) error {
  8621  	l := len(dAtA)
  8622  	iNdEx := 0
  8623  	for iNdEx < l {
  8624  		preIndex := iNdEx
  8625  		var wire uint64
  8626  		for shift := uint(0); ; shift += 7 {
  8627  			if shift >= 64 {
  8628  				return ErrIntOverflowGenerated
  8629  			}
  8630  			if iNdEx >= l {
  8631  				return io.ErrUnexpectedEOF
  8632  			}
  8633  			b := dAtA[iNdEx]
  8634  			iNdEx++
  8635  			wire |= uint64(b&0x7F) << shift
  8636  			if b < 0x80 {
  8637  				break
  8638  			}
  8639  		}
  8640  		fieldNum := int32(wire >> 3)
  8641  		wireType := int(wire & 0x7)
  8642  		if wireType == 4 {
  8643  			return fmt.Errorf("proto: IngressLoadBalancerStatus: wiretype end group for non-group")
  8644  		}
  8645  		if fieldNum <= 0 {
  8646  			return fmt.Errorf("proto: IngressLoadBalancerStatus: illegal tag %d (wire type %d)", fieldNum, wire)
  8647  		}
  8648  		switch fieldNum {
  8649  		case 1:
  8650  			if wireType != 2 {
  8651  				return fmt.Errorf("proto: wrong wireType = %d for field Ingress", wireType)
  8652  			}
  8653  			var msglen int
  8654  			for shift := uint(0); ; shift += 7 {
  8655  				if shift >= 64 {
  8656  					return ErrIntOverflowGenerated
  8657  				}
  8658  				if iNdEx >= l {
  8659  					return io.ErrUnexpectedEOF
  8660  				}
  8661  				b := dAtA[iNdEx]
  8662  				iNdEx++
  8663  				msglen |= int(b&0x7F) << shift
  8664  				if b < 0x80 {
  8665  					break
  8666  				}
  8667  			}
  8668  			if msglen < 0 {
  8669  				return ErrInvalidLengthGenerated
  8670  			}
  8671  			postIndex := iNdEx + msglen
  8672  			if postIndex < 0 {
  8673  				return ErrInvalidLengthGenerated
  8674  			}
  8675  			if postIndex > l {
  8676  				return io.ErrUnexpectedEOF
  8677  			}
  8678  			m.Ingress = append(m.Ingress, IngressLoadBalancerIngress{})
  8679  			if err := m.Ingress[len(m.Ingress)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  8680  				return err
  8681  			}
  8682  			iNdEx = postIndex
  8683  		default:
  8684  			iNdEx = preIndex
  8685  			skippy, err := skipGenerated(dAtA[iNdEx:])
  8686  			if err != nil {
  8687  				return err
  8688  			}
  8689  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  8690  				return ErrInvalidLengthGenerated
  8691  			}
  8692  			if (iNdEx + skippy) > l {
  8693  				return io.ErrUnexpectedEOF
  8694  			}
  8695  			iNdEx += skippy
  8696  		}
  8697  	}
  8698  
  8699  	if iNdEx > l {
  8700  		return io.ErrUnexpectedEOF
  8701  	}
  8702  	return nil
  8703  }
  8704  func (m *IngressPortStatus) Unmarshal(dAtA []byte) error {
  8705  	l := len(dAtA)
  8706  	iNdEx := 0
  8707  	for iNdEx < l {
  8708  		preIndex := iNdEx
  8709  		var wire uint64
  8710  		for shift := uint(0); ; shift += 7 {
  8711  			if shift >= 64 {
  8712  				return ErrIntOverflowGenerated
  8713  			}
  8714  			if iNdEx >= l {
  8715  				return io.ErrUnexpectedEOF
  8716  			}
  8717  			b := dAtA[iNdEx]
  8718  			iNdEx++
  8719  			wire |= uint64(b&0x7F) << shift
  8720  			if b < 0x80 {
  8721  				break
  8722  			}
  8723  		}
  8724  		fieldNum := int32(wire >> 3)
  8725  		wireType := int(wire & 0x7)
  8726  		if wireType == 4 {
  8727  			return fmt.Errorf("proto: IngressPortStatus: wiretype end group for non-group")
  8728  		}
  8729  		if fieldNum <= 0 {
  8730  			return fmt.Errorf("proto: IngressPortStatus: illegal tag %d (wire type %d)", fieldNum, wire)
  8731  		}
  8732  		switch fieldNum {
  8733  		case 1:
  8734  			if wireType != 0 {
  8735  				return fmt.Errorf("proto: wrong wireType = %d for field Port", wireType)
  8736  			}
  8737  			m.Port = 0
  8738  			for shift := uint(0); ; shift += 7 {
  8739  				if shift >= 64 {
  8740  					return ErrIntOverflowGenerated
  8741  				}
  8742  				if iNdEx >= l {
  8743  					return io.ErrUnexpectedEOF
  8744  				}
  8745  				b := dAtA[iNdEx]
  8746  				iNdEx++
  8747  				m.Port |= int32(b&0x7F) << shift
  8748  				if b < 0x80 {
  8749  					break
  8750  				}
  8751  			}
  8752  		case 2:
  8753  			if wireType != 2 {
  8754  				return fmt.Errorf("proto: wrong wireType = %d for field Protocol", wireType)
  8755  			}
  8756  			var stringLen uint64
  8757  			for shift := uint(0); ; shift += 7 {
  8758  				if shift >= 64 {
  8759  					return ErrIntOverflowGenerated
  8760  				}
  8761  				if iNdEx >= l {
  8762  					return io.ErrUnexpectedEOF
  8763  				}
  8764  				b := dAtA[iNdEx]
  8765  				iNdEx++
  8766  				stringLen |= uint64(b&0x7F) << shift
  8767  				if b < 0x80 {
  8768  					break
  8769  				}
  8770  			}
  8771  			intStringLen := int(stringLen)
  8772  			if intStringLen < 0 {
  8773  				return ErrInvalidLengthGenerated
  8774  			}
  8775  			postIndex := iNdEx + intStringLen
  8776  			if postIndex < 0 {
  8777  				return ErrInvalidLengthGenerated
  8778  			}
  8779  			if postIndex > l {
  8780  				return io.ErrUnexpectedEOF
  8781  			}
  8782  			m.Protocol = k8s_io_api_core_v1.Protocol(dAtA[iNdEx:postIndex])
  8783  			iNdEx = postIndex
  8784  		case 3:
  8785  			if wireType != 2 {
  8786  				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
  8787  			}
  8788  			var stringLen uint64
  8789  			for shift := uint(0); ; shift += 7 {
  8790  				if shift >= 64 {
  8791  					return ErrIntOverflowGenerated
  8792  				}
  8793  				if iNdEx >= l {
  8794  					return io.ErrUnexpectedEOF
  8795  				}
  8796  				b := dAtA[iNdEx]
  8797  				iNdEx++
  8798  				stringLen |= uint64(b&0x7F) << shift
  8799  				if b < 0x80 {
  8800  					break
  8801  				}
  8802  			}
  8803  			intStringLen := int(stringLen)
  8804  			if intStringLen < 0 {
  8805  				return ErrInvalidLengthGenerated
  8806  			}
  8807  			postIndex := iNdEx + intStringLen
  8808  			if postIndex < 0 {
  8809  				return ErrInvalidLengthGenerated
  8810  			}
  8811  			if postIndex > l {
  8812  				return io.ErrUnexpectedEOF
  8813  			}
  8814  			s := string(dAtA[iNdEx:postIndex])
  8815  			m.Error = &s
  8816  			iNdEx = postIndex
  8817  		default:
  8818  			iNdEx = preIndex
  8819  			skippy, err := skipGenerated(dAtA[iNdEx:])
  8820  			if err != nil {
  8821  				return err
  8822  			}
  8823  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  8824  				return ErrInvalidLengthGenerated
  8825  			}
  8826  			if (iNdEx + skippy) > l {
  8827  				return io.ErrUnexpectedEOF
  8828  			}
  8829  			iNdEx += skippy
  8830  		}
  8831  	}
  8832  
  8833  	if iNdEx > l {
  8834  		return io.ErrUnexpectedEOF
  8835  	}
  8836  	return nil
  8837  }
  8838  func (m *IngressRule) Unmarshal(dAtA []byte) error {
  8839  	l := len(dAtA)
  8840  	iNdEx := 0
  8841  	for iNdEx < l {
  8842  		preIndex := iNdEx
  8843  		var wire uint64
  8844  		for shift := uint(0); ; shift += 7 {
  8845  			if shift >= 64 {
  8846  				return ErrIntOverflowGenerated
  8847  			}
  8848  			if iNdEx >= l {
  8849  				return io.ErrUnexpectedEOF
  8850  			}
  8851  			b := dAtA[iNdEx]
  8852  			iNdEx++
  8853  			wire |= uint64(b&0x7F) << shift
  8854  			if b < 0x80 {
  8855  				break
  8856  			}
  8857  		}
  8858  		fieldNum := int32(wire >> 3)
  8859  		wireType := int(wire & 0x7)
  8860  		if wireType == 4 {
  8861  			return fmt.Errorf("proto: IngressRule: wiretype end group for non-group")
  8862  		}
  8863  		if fieldNum <= 0 {
  8864  			return fmt.Errorf("proto: IngressRule: illegal tag %d (wire type %d)", fieldNum, wire)
  8865  		}
  8866  		switch fieldNum {
  8867  		case 1:
  8868  			if wireType != 2 {
  8869  				return fmt.Errorf("proto: wrong wireType = %d for field Host", wireType)
  8870  			}
  8871  			var stringLen uint64
  8872  			for shift := uint(0); ; shift += 7 {
  8873  				if shift >= 64 {
  8874  					return ErrIntOverflowGenerated
  8875  				}
  8876  				if iNdEx >= l {
  8877  					return io.ErrUnexpectedEOF
  8878  				}
  8879  				b := dAtA[iNdEx]
  8880  				iNdEx++
  8881  				stringLen |= uint64(b&0x7F) << shift
  8882  				if b < 0x80 {
  8883  					break
  8884  				}
  8885  			}
  8886  			intStringLen := int(stringLen)
  8887  			if intStringLen < 0 {
  8888  				return ErrInvalidLengthGenerated
  8889  			}
  8890  			postIndex := iNdEx + intStringLen
  8891  			if postIndex < 0 {
  8892  				return ErrInvalidLengthGenerated
  8893  			}
  8894  			if postIndex > l {
  8895  				return io.ErrUnexpectedEOF
  8896  			}
  8897  			m.Host = string(dAtA[iNdEx:postIndex])
  8898  			iNdEx = postIndex
  8899  		case 2:
  8900  			if wireType != 2 {
  8901  				return fmt.Errorf("proto: wrong wireType = %d for field IngressRuleValue", wireType)
  8902  			}
  8903  			var msglen int
  8904  			for shift := uint(0); ; shift += 7 {
  8905  				if shift >= 64 {
  8906  					return ErrIntOverflowGenerated
  8907  				}
  8908  				if iNdEx >= l {
  8909  					return io.ErrUnexpectedEOF
  8910  				}
  8911  				b := dAtA[iNdEx]
  8912  				iNdEx++
  8913  				msglen |= int(b&0x7F) << shift
  8914  				if b < 0x80 {
  8915  					break
  8916  				}
  8917  			}
  8918  			if msglen < 0 {
  8919  				return ErrInvalidLengthGenerated
  8920  			}
  8921  			postIndex := iNdEx + msglen
  8922  			if postIndex < 0 {
  8923  				return ErrInvalidLengthGenerated
  8924  			}
  8925  			if postIndex > l {
  8926  				return io.ErrUnexpectedEOF
  8927  			}
  8928  			if err := m.IngressRuleValue.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  8929  				return err
  8930  			}
  8931  			iNdEx = postIndex
  8932  		default:
  8933  			iNdEx = preIndex
  8934  			skippy, err := skipGenerated(dAtA[iNdEx:])
  8935  			if err != nil {
  8936  				return err
  8937  			}
  8938  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  8939  				return ErrInvalidLengthGenerated
  8940  			}
  8941  			if (iNdEx + skippy) > l {
  8942  				return io.ErrUnexpectedEOF
  8943  			}
  8944  			iNdEx += skippy
  8945  		}
  8946  	}
  8947  
  8948  	if iNdEx > l {
  8949  		return io.ErrUnexpectedEOF
  8950  	}
  8951  	return nil
  8952  }
  8953  func (m *IngressRuleValue) Unmarshal(dAtA []byte) error {
  8954  	l := len(dAtA)
  8955  	iNdEx := 0
  8956  	for iNdEx < l {
  8957  		preIndex := iNdEx
  8958  		var wire uint64
  8959  		for shift := uint(0); ; shift += 7 {
  8960  			if shift >= 64 {
  8961  				return ErrIntOverflowGenerated
  8962  			}
  8963  			if iNdEx >= l {
  8964  				return io.ErrUnexpectedEOF
  8965  			}
  8966  			b := dAtA[iNdEx]
  8967  			iNdEx++
  8968  			wire |= uint64(b&0x7F) << shift
  8969  			if b < 0x80 {
  8970  				break
  8971  			}
  8972  		}
  8973  		fieldNum := int32(wire >> 3)
  8974  		wireType := int(wire & 0x7)
  8975  		if wireType == 4 {
  8976  			return fmt.Errorf("proto: IngressRuleValue: wiretype end group for non-group")
  8977  		}
  8978  		if fieldNum <= 0 {
  8979  			return fmt.Errorf("proto: IngressRuleValue: illegal tag %d (wire type %d)", fieldNum, wire)
  8980  		}
  8981  		switch fieldNum {
  8982  		case 1:
  8983  			if wireType != 2 {
  8984  				return fmt.Errorf("proto: wrong wireType = %d for field HTTP", wireType)
  8985  			}
  8986  			var msglen int
  8987  			for shift := uint(0); ; shift += 7 {
  8988  				if shift >= 64 {
  8989  					return ErrIntOverflowGenerated
  8990  				}
  8991  				if iNdEx >= l {
  8992  					return io.ErrUnexpectedEOF
  8993  				}
  8994  				b := dAtA[iNdEx]
  8995  				iNdEx++
  8996  				msglen |= int(b&0x7F) << shift
  8997  				if b < 0x80 {
  8998  					break
  8999  				}
  9000  			}
  9001  			if msglen < 0 {
  9002  				return ErrInvalidLengthGenerated
  9003  			}
  9004  			postIndex := iNdEx + msglen
  9005  			if postIndex < 0 {
  9006  				return ErrInvalidLengthGenerated
  9007  			}
  9008  			if postIndex > l {
  9009  				return io.ErrUnexpectedEOF
  9010  			}
  9011  			if m.HTTP == nil {
  9012  				m.HTTP = &HTTPIngressRuleValue{}
  9013  			}
  9014  			if err := m.HTTP.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  9015  				return err
  9016  			}
  9017  			iNdEx = postIndex
  9018  		default:
  9019  			iNdEx = preIndex
  9020  			skippy, err := skipGenerated(dAtA[iNdEx:])
  9021  			if err != nil {
  9022  				return err
  9023  			}
  9024  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  9025  				return ErrInvalidLengthGenerated
  9026  			}
  9027  			if (iNdEx + skippy) > l {
  9028  				return io.ErrUnexpectedEOF
  9029  			}
  9030  			iNdEx += skippy
  9031  		}
  9032  	}
  9033  
  9034  	if iNdEx > l {
  9035  		return io.ErrUnexpectedEOF
  9036  	}
  9037  	return nil
  9038  }
  9039  func (m *IngressSpec) Unmarshal(dAtA []byte) error {
  9040  	l := len(dAtA)
  9041  	iNdEx := 0
  9042  	for iNdEx < l {
  9043  		preIndex := iNdEx
  9044  		var wire uint64
  9045  		for shift := uint(0); ; shift += 7 {
  9046  			if shift >= 64 {
  9047  				return ErrIntOverflowGenerated
  9048  			}
  9049  			if iNdEx >= l {
  9050  				return io.ErrUnexpectedEOF
  9051  			}
  9052  			b := dAtA[iNdEx]
  9053  			iNdEx++
  9054  			wire |= uint64(b&0x7F) << shift
  9055  			if b < 0x80 {
  9056  				break
  9057  			}
  9058  		}
  9059  		fieldNum := int32(wire >> 3)
  9060  		wireType := int(wire & 0x7)
  9061  		if wireType == 4 {
  9062  			return fmt.Errorf("proto: IngressSpec: wiretype end group for non-group")
  9063  		}
  9064  		if fieldNum <= 0 {
  9065  			return fmt.Errorf("proto: IngressSpec: illegal tag %d (wire type %d)", fieldNum, wire)
  9066  		}
  9067  		switch fieldNum {
  9068  		case 1:
  9069  			if wireType != 2 {
  9070  				return fmt.Errorf("proto: wrong wireType = %d for field Backend", wireType)
  9071  			}
  9072  			var msglen int
  9073  			for shift := uint(0); ; shift += 7 {
  9074  				if shift >= 64 {
  9075  					return ErrIntOverflowGenerated
  9076  				}
  9077  				if iNdEx >= l {
  9078  					return io.ErrUnexpectedEOF
  9079  				}
  9080  				b := dAtA[iNdEx]
  9081  				iNdEx++
  9082  				msglen |= int(b&0x7F) << shift
  9083  				if b < 0x80 {
  9084  					break
  9085  				}
  9086  			}
  9087  			if msglen < 0 {
  9088  				return ErrInvalidLengthGenerated
  9089  			}
  9090  			postIndex := iNdEx + msglen
  9091  			if postIndex < 0 {
  9092  				return ErrInvalidLengthGenerated
  9093  			}
  9094  			if postIndex > l {
  9095  				return io.ErrUnexpectedEOF
  9096  			}
  9097  			if m.Backend == nil {
  9098  				m.Backend = &IngressBackend{}
  9099  			}
  9100  			if err := m.Backend.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  9101  				return err
  9102  			}
  9103  			iNdEx = postIndex
  9104  		case 2:
  9105  			if wireType != 2 {
  9106  				return fmt.Errorf("proto: wrong wireType = %d for field TLS", wireType)
  9107  			}
  9108  			var msglen int
  9109  			for shift := uint(0); ; shift += 7 {
  9110  				if shift >= 64 {
  9111  					return ErrIntOverflowGenerated
  9112  				}
  9113  				if iNdEx >= l {
  9114  					return io.ErrUnexpectedEOF
  9115  				}
  9116  				b := dAtA[iNdEx]
  9117  				iNdEx++
  9118  				msglen |= int(b&0x7F) << shift
  9119  				if b < 0x80 {
  9120  					break
  9121  				}
  9122  			}
  9123  			if msglen < 0 {
  9124  				return ErrInvalidLengthGenerated
  9125  			}
  9126  			postIndex := iNdEx + msglen
  9127  			if postIndex < 0 {
  9128  				return ErrInvalidLengthGenerated
  9129  			}
  9130  			if postIndex > l {
  9131  				return io.ErrUnexpectedEOF
  9132  			}
  9133  			m.TLS = append(m.TLS, IngressTLS{})
  9134  			if err := m.TLS[len(m.TLS)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  9135  				return err
  9136  			}
  9137  			iNdEx = postIndex
  9138  		case 3:
  9139  			if wireType != 2 {
  9140  				return fmt.Errorf("proto: wrong wireType = %d for field Rules", wireType)
  9141  			}
  9142  			var msglen int
  9143  			for shift := uint(0); ; shift += 7 {
  9144  				if shift >= 64 {
  9145  					return ErrIntOverflowGenerated
  9146  				}
  9147  				if iNdEx >= l {
  9148  					return io.ErrUnexpectedEOF
  9149  				}
  9150  				b := dAtA[iNdEx]
  9151  				iNdEx++
  9152  				msglen |= int(b&0x7F) << shift
  9153  				if b < 0x80 {
  9154  					break
  9155  				}
  9156  			}
  9157  			if msglen < 0 {
  9158  				return ErrInvalidLengthGenerated
  9159  			}
  9160  			postIndex := iNdEx + msglen
  9161  			if postIndex < 0 {
  9162  				return ErrInvalidLengthGenerated
  9163  			}
  9164  			if postIndex > l {
  9165  				return io.ErrUnexpectedEOF
  9166  			}
  9167  			m.Rules = append(m.Rules, IngressRule{})
  9168  			if err := m.Rules[len(m.Rules)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  9169  				return err
  9170  			}
  9171  			iNdEx = postIndex
  9172  		case 4:
  9173  			if wireType != 2 {
  9174  				return fmt.Errorf("proto: wrong wireType = %d for field IngressClassName", wireType)
  9175  			}
  9176  			var stringLen uint64
  9177  			for shift := uint(0); ; shift += 7 {
  9178  				if shift >= 64 {
  9179  					return ErrIntOverflowGenerated
  9180  				}
  9181  				if iNdEx >= l {
  9182  					return io.ErrUnexpectedEOF
  9183  				}
  9184  				b := dAtA[iNdEx]
  9185  				iNdEx++
  9186  				stringLen |= uint64(b&0x7F) << shift
  9187  				if b < 0x80 {
  9188  					break
  9189  				}
  9190  			}
  9191  			intStringLen := int(stringLen)
  9192  			if intStringLen < 0 {
  9193  				return ErrInvalidLengthGenerated
  9194  			}
  9195  			postIndex := iNdEx + intStringLen
  9196  			if postIndex < 0 {
  9197  				return ErrInvalidLengthGenerated
  9198  			}
  9199  			if postIndex > l {
  9200  				return io.ErrUnexpectedEOF
  9201  			}
  9202  			s := string(dAtA[iNdEx:postIndex])
  9203  			m.IngressClassName = &s
  9204  			iNdEx = postIndex
  9205  		default:
  9206  			iNdEx = preIndex
  9207  			skippy, err := skipGenerated(dAtA[iNdEx:])
  9208  			if err != nil {
  9209  				return err
  9210  			}
  9211  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  9212  				return ErrInvalidLengthGenerated
  9213  			}
  9214  			if (iNdEx + skippy) > l {
  9215  				return io.ErrUnexpectedEOF
  9216  			}
  9217  			iNdEx += skippy
  9218  		}
  9219  	}
  9220  
  9221  	if iNdEx > l {
  9222  		return io.ErrUnexpectedEOF
  9223  	}
  9224  	return nil
  9225  }
  9226  func (m *IngressStatus) Unmarshal(dAtA []byte) error {
  9227  	l := len(dAtA)
  9228  	iNdEx := 0
  9229  	for iNdEx < l {
  9230  		preIndex := iNdEx
  9231  		var wire uint64
  9232  		for shift := uint(0); ; shift += 7 {
  9233  			if shift >= 64 {
  9234  				return ErrIntOverflowGenerated
  9235  			}
  9236  			if iNdEx >= l {
  9237  				return io.ErrUnexpectedEOF
  9238  			}
  9239  			b := dAtA[iNdEx]
  9240  			iNdEx++
  9241  			wire |= uint64(b&0x7F) << shift
  9242  			if b < 0x80 {
  9243  				break
  9244  			}
  9245  		}
  9246  		fieldNum := int32(wire >> 3)
  9247  		wireType := int(wire & 0x7)
  9248  		if wireType == 4 {
  9249  			return fmt.Errorf("proto: IngressStatus: wiretype end group for non-group")
  9250  		}
  9251  		if fieldNum <= 0 {
  9252  			return fmt.Errorf("proto: IngressStatus: illegal tag %d (wire type %d)", fieldNum, wire)
  9253  		}
  9254  		switch fieldNum {
  9255  		case 1:
  9256  			if wireType != 2 {
  9257  				return fmt.Errorf("proto: wrong wireType = %d for field LoadBalancer", wireType)
  9258  			}
  9259  			var msglen int
  9260  			for shift := uint(0); ; shift += 7 {
  9261  				if shift >= 64 {
  9262  					return ErrIntOverflowGenerated
  9263  				}
  9264  				if iNdEx >= l {
  9265  					return io.ErrUnexpectedEOF
  9266  				}
  9267  				b := dAtA[iNdEx]
  9268  				iNdEx++
  9269  				msglen |= int(b&0x7F) << shift
  9270  				if b < 0x80 {
  9271  					break
  9272  				}
  9273  			}
  9274  			if msglen < 0 {
  9275  				return ErrInvalidLengthGenerated
  9276  			}
  9277  			postIndex := iNdEx + msglen
  9278  			if postIndex < 0 {
  9279  				return ErrInvalidLengthGenerated
  9280  			}
  9281  			if postIndex > l {
  9282  				return io.ErrUnexpectedEOF
  9283  			}
  9284  			if err := m.LoadBalancer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  9285  				return err
  9286  			}
  9287  			iNdEx = postIndex
  9288  		default:
  9289  			iNdEx = preIndex
  9290  			skippy, err := skipGenerated(dAtA[iNdEx:])
  9291  			if err != nil {
  9292  				return err
  9293  			}
  9294  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  9295  				return ErrInvalidLengthGenerated
  9296  			}
  9297  			if (iNdEx + skippy) > l {
  9298  				return io.ErrUnexpectedEOF
  9299  			}
  9300  			iNdEx += skippy
  9301  		}
  9302  	}
  9303  
  9304  	if iNdEx > l {
  9305  		return io.ErrUnexpectedEOF
  9306  	}
  9307  	return nil
  9308  }
  9309  func (m *IngressTLS) Unmarshal(dAtA []byte) error {
  9310  	l := len(dAtA)
  9311  	iNdEx := 0
  9312  	for iNdEx < l {
  9313  		preIndex := iNdEx
  9314  		var wire uint64
  9315  		for shift := uint(0); ; shift += 7 {
  9316  			if shift >= 64 {
  9317  				return ErrIntOverflowGenerated
  9318  			}
  9319  			if iNdEx >= l {
  9320  				return io.ErrUnexpectedEOF
  9321  			}
  9322  			b := dAtA[iNdEx]
  9323  			iNdEx++
  9324  			wire |= uint64(b&0x7F) << shift
  9325  			if b < 0x80 {
  9326  				break
  9327  			}
  9328  		}
  9329  		fieldNum := int32(wire >> 3)
  9330  		wireType := int(wire & 0x7)
  9331  		if wireType == 4 {
  9332  			return fmt.Errorf("proto: IngressTLS: wiretype end group for non-group")
  9333  		}
  9334  		if fieldNum <= 0 {
  9335  			return fmt.Errorf("proto: IngressTLS: illegal tag %d (wire type %d)", fieldNum, wire)
  9336  		}
  9337  		switch fieldNum {
  9338  		case 1:
  9339  			if wireType != 2 {
  9340  				return fmt.Errorf("proto: wrong wireType = %d for field Hosts", wireType)
  9341  			}
  9342  			var stringLen uint64
  9343  			for shift := uint(0); ; shift += 7 {
  9344  				if shift >= 64 {
  9345  					return ErrIntOverflowGenerated
  9346  				}
  9347  				if iNdEx >= l {
  9348  					return io.ErrUnexpectedEOF
  9349  				}
  9350  				b := dAtA[iNdEx]
  9351  				iNdEx++
  9352  				stringLen |= uint64(b&0x7F) << shift
  9353  				if b < 0x80 {
  9354  					break
  9355  				}
  9356  			}
  9357  			intStringLen := int(stringLen)
  9358  			if intStringLen < 0 {
  9359  				return ErrInvalidLengthGenerated
  9360  			}
  9361  			postIndex := iNdEx + intStringLen
  9362  			if postIndex < 0 {
  9363  				return ErrInvalidLengthGenerated
  9364  			}
  9365  			if postIndex > l {
  9366  				return io.ErrUnexpectedEOF
  9367  			}
  9368  			m.Hosts = append(m.Hosts, string(dAtA[iNdEx:postIndex]))
  9369  			iNdEx = postIndex
  9370  		case 2:
  9371  			if wireType != 2 {
  9372  				return fmt.Errorf("proto: wrong wireType = %d for field SecretName", wireType)
  9373  			}
  9374  			var stringLen uint64
  9375  			for shift := uint(0); ; shift += 7 {
  9376  				if shift >= 64 {
  9377  					return ErrIntOverflowGenerated
  9378  				}
  9379  				if iNdEx >= l {
  9380  					return io.ErrUnexpectedEOF
  9381  				}
  9382  				b := dAtA[iNdEx]
  9383  				iNdEx++
  9384  				stringLen |= uint64(b&0x7F) << shift
  9385  				if b < 0x80 {
  9386  					break
  9387  				}
  9388  			}
  9389  			intStringLen := int(stringLen)
  9390  			if intStringLen < 0 {
  9391  				return ErrInvalidLengthGenerated
  9392  			}
  9393  			postIndex := iNdEx + intStringLen
  9394  			if postIndex < 0 {
  9395  				return ErrInvalidLengthGenerated
  9396  			}
  9397  			if postIndex > l {
  9398  				return io.ErrUnexpectedEOF
  9399  			}
  9400  			m.SecretName = string(dAtA[iNdEx:postIndex])
  9401  			iNdEx = postIndex
  9402  		default:
  9403  			iNdEx = preIndex
  9404  			skippy, err := skipGenerated(dAtA[iNdEx:])
  9405  			if err != nil {
  9406  				return err
  9407  			}
  9408  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  9409  				return ErrInvalidLengthGenerated
  9410  			}
  9411  			if (iNdEx + skippy) > l {
  9412  				return io.ErrUnexpectedEOF
  9413  			}
  9414  			iNdEx += skippy
  9415  		}
  9416  	}
  9417  
  9418  	if iNdEx > l {
  9419  		return io.ErrUnexpectedEOF
  9420  	}
  9421  	return nil
  9422  }
  9423  func (m *NetworkPolicy) Unmarshal(dAtA []byte) error {
  9424  	l := len(dAtA)
  9425  	iNdEx := 0
  9426  	for iNdEx < l {
  9427  		preIndex := iNdEx
  9428  		var wire uint64
  9429  		for shift := uint(0); ; shift += 7 {
  9430  			if shift >= 64 {
  9431  				return ErrIntOverflowGenerated
  9432  			}
  9433  			if iNdEx >= l {
  9434  				return io.ErrUnexpectedEOF
  9435  			}
  9436  			b := dAtA[iNdEx]
  9437  			iNdEx++
  9438  			wire |= uint64(b&0x7F) << shift
  9439  			if b < 0x80 {
  9440  				break
  9441  			}
  9442  		}
  9443  		fieldNum := int32(wire >> 3)
  9444  		wireType := int(wire & 0x7)
  9445  		if wireType == 4 {
  9446  			return fmt.Errorf("proto: NetworkPolicy: wiretype end group for non-group")
  9447  		}
  9448  		if fieldNum <= 0 {
  9449  			return fmt.Errorf("proto: NetworkPolicy: illegal tag %d (wire type %d)", fieldNum, wire)
  9450  		}
  9451  		switch fieldNum {
  9452  		case 1:
  9453  			if wireType != 2 {
  9454  				return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
  9455  			}
  9456  			var msglen int
  9457  			for shift := uint(0); ; shift += 7 {
  9458  				if shift >= 64 {
  9459  					return ErrIntOverflowGenerated
  9460  				}
  9461  				if iNdEx >= l {
  9462  					return io.ErrUnexpectedEOF
  9463  				}
  9464  				b := dAtA[iNdEx]
  9465  				iNdEx++
  9466  				msglen |= int(b&0x7F) << shift
  9467  				if b < 0x80 {
  9468  					break
  9469  				}
  9470  			}
  9471  			if msglen < 0 {
  9472  				return ErrInvalidLengthGenerated
  9473  			}
  9474  			postIndex := iNdEx + msglen
  9475  			if postIndex < 0 {
  9476  				return ErrInvalidLengthGenerated
  9477  			}
  9478  			if postIndex > l {
  9479  				return io.ErrUnexpectedEOF
  9480  			}
  9481  			if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  9482  				return err
  9483  			}
  9484  			iNdEx = postIndex
  9485  		case 2:
  9486  			if wireType != 2 {
  9487  				return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
  9488  			}
  9489  			var msglen int
  9490  			for shift := uint(0); ; shift += 7 {
  9491  				if shift >= 64 {
  9492  					return ErrIntOverflowGenerated
  9493  				}
  9494  				if iNdEx >= l {
  9495  					return io.ErrUnexpectedEOF
  9496  				}
  9497  				b := dAtA[iNdEx]
  9498  				iNdEx++
  9499  				msglen |= int(b&0x7F) << shift
  9500  				if b < 0x80 {
  9501  					break
  9502  				}
  9503  			}
  9504  			if msglen < 0 {
  9505  				return ErrInvalidLengthGenerated
  9506  			}
  9507  			postIndex := iNdEx + msglen
  9508  			if postIndex < 0 {
  9509  				return ErrInvalidLengthGenerated
  9510  			}
  9511  			if postIndex > l {
  9512  				return io.ErrUnexpectedEOF
  9513  			}
  9514  			if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  9515  				return err
  9516  			}
  9517  			iNdEx = postIndex
  9518  		default:
  9519  			iNdEx = preIndex
  9520  			skippy, err := skipGenerated(dAtA[iNdEx:])
  9521  			if err != nil {
  9522  				return err
  9523  			}
  9524  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  9525  				return ErrInvalidLengthGenerated
  9526  			}
  9527  			if (iNdEx + skippy) > l {
  9528  				return io.ErrUnexpectedEOF
  9529  			}
  9530  			iNdEx += skippy
  9531  		}
  9532  	}
  9533  
  9534  	if iNdEx > l {
  9535  		return io.ErrUnexpectedEOF
  9536  	}
  9537  	return nil
  9538  }
  9539  func (m *NetworkPolicyEgressRule) Unmarshal(dAtA []byte) error {
  9540  	l := len(dAtA)
  9541  	iNdEx := 0
  9542  	for iNdEx < l {
  9543  		preIndex := iNdEx
  9544  		var wire uint64
  9545  		for shift := uint(0); ; shift += 7 {
  9546  			if shift >= 64 {
  9547  				return ErrIntOverflowGenerated
  9548  			}
  9549  			if iNdEx >= l {
  9550  				return io.ErrUnexpectedEOF
  9551  			}
  9552  			b := dAtA[iNdEx]
  9553  			iNdEx++
  9554  			wire |= uint64(b&0x7F) << shift
  9555  			if b < 0x80 {
  9556  				break
  9557  			}
  9558  		}
  9559  		fieldNum := int32(wire >> 3)
  9560  		wireType := int(wire & 0x7)
  9561  		if wireType == 4 {
  9562  			return fmt.Errorf("proto: NetworkPolicyEgressRule: wiretype end group for non-group")
  9563  		}
  9564  		if fieldNum <= 0 {
  9565  			return fmt.Errorf("proto: NetworkPolicyEgressRule: illegal tag %d (wire type %d)", fieldNum, wire)
  9566  		}
  9567  		switch fieldNum {
  9568  		case 1:
  9569  			if wireType != 2 {
  9570  				return fmt.Errorf("proto: wrong wireType = %d for field Ports", wireType)
  9571  			}
  9572  			var msglen int
  9573  			for shift := uint(0); ; shift += 7 {
  9574  				if shift >= 64 {
  9575  					return ErrIntOverflowGenerated
  9576  				}
  9577  				if iNdEx >= l {
  9578  					return io.ErrUnexpectedEOF
  9579  				}
  9580  				b := dAtA[iNdEx]
  9581  				iNdEx++
  9582  				msglen |= int(b&0x7F) << shift
  9583  				if b < 0x80 {
  9584  					break
  9585  				}
  9586  			}
  9587  			if msglen < 0 {
  9588  				return ErrInvalidLengthGenerated
  9589  			}
  9590  			postIndex := iNdEx + msglen
  9591  			if postIndex < 0 {
  9592  				return ErrInvalidLengthGenerated
  9593  			}
  9594  			if postIndex > l {
  9595  				return io.ErrUnexpectedEOF
  9596  			}
  9597  			m.Ports = append(m.Ports, NetworkPolicyPort{})
  9598  			if err := m.Ports[len(m.Ports)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  9599  				return err
  9600  			}
  9601  			iNdEx = postIndex
  9602  		case 2:
  9603  			if wireType != 2 {
  9604  				return fmt.Errorf("proto: wrong wireType = %d for field To", wireType)
  9605  			}
  9606  			var msglen int
  9607  			for shift := uint(0); ; shift += 7 {
  9608  				if shift >= 64 {
  9609  					return ErrIntOverflowGenerated
  9610  				}
  9611  				if iNdEx >= l {
  9612  					return io.ErrUnexpectedEOF
  9613  				}
  9614  				b := dAtA[iNdEx]
  9615  				iNdEx++
  9616  				msglen |= int(b&0x7F) << shift
  9617  				if b < 0x80 {
  9618  					break
  9619  				}
  9620  			}
  9621  			if msglen < 0 {
  9622  				return ErrInvalidLengthGenerated
  9623  			}
  9624  			postIndex := iNdEx + msglen
  9625  			if postIndex < 0 {
  9626  				return ErrInvalidLengthGenerated
  9627  			}
  9628  			if postIndex > l {
  9629  				return io.ErrUnexpectedEOF
  9630  			}
  9631  			m.To = append(m.To, NetworkPolicyPeer{})
  9632  			if err := m.To[len(m.To)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  9633  				return err
  9634  			}
  9635  			iNdEx = postIndex
  9636  		default:
  9637  			iNdEx = preIndex
  9638  			skippy, err := skipGenerated(dAtA[iNdEx:])
  9639  			if err != nil {
  9640  				return err
  9641  			}
  9642  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  9643  				return ErrInvalidLengthGenerated
  9644  			}
  9645  			if (iNdEx + skippy) > l {
  9646  				return io.ErrUnexpectedEOF
  9647  			}
  9648  			iNdEx += skippy
  9649  		}
  9650  	}
  9651  
  9652  	if iNdEx > l {
  9653  		return io.ErrUnexpectedEOF
  9654  	}
  9655  	return nil
  9656  }
  9657  func (m *NetworkPolicyIngressRule) Unmarshal(dAtA []byte) error {
  9658  	l := len(dAtA)
  9659  	iNdEx := 0
  9660  	for iNdEx < l {
  9661  		preIndex := iNdEx
  9662  		var wire uint64
  9663  		for shift := uint(0); ; shift += 7 {
  9664  			if shift >= 64 {
  9665  				return ErrIntOverflowGenerated
  9666  			}
  9667  			if iNdEx >= l {
  9668  				return io.ErrUnexpectedEOF
  9669  			}
  9670  			b := dAtA[iNdEx]
  9671  			iNdEx++
  9672  			wire |= uint64(b&0x7F) << shift
  9673  			if b < 0x80 {
  9674  				break
  9675  			}
  9676  		}
  9677  		fieldNum := int32(wire >> 3)
  9678  		wireType := int(wire & 0x7)
  9679  		if wireType == 4 {
  9680  			return fmt.Errorf("proto: NetworkPolicyIngressRule: wiretype end group for non-group")
  9681  		}
  9682  		if fieldNum <= 0 {
  9683  			return fmt.Errorf("proto: NetworkPolicyIngressRule: illegal tag %d (wire type %d)", fieldNum, wire)
  9684  		}
  9685  		switch fieldNum {
  9686  		case 1:
  9687  			if wireType != 2 {
  9688  				return fmt.Errorf("proto: wrong wireType = %d for field Ports", wireType)
  9689  			}
  9690  			var msglen int
  9691  			for shift := uint(0); ; shift += 7 {
  9692  				if shift >= 64 {
  9693  					return ErrIntOverflowGenerated
  9694  				}
  9695  				if iNdEx >= l {
  9696  					return io.ErrUnexpectedEOF
  9697  				}
  9698  				b := dAtA[iNdEx]
  9699  				iNdEx++
  9700  				msglen |= int(b&0x7F) << shift
  9701  				if b < 0x80 {
  9702  					break
  9703  				}
  9704  			}
  9705  			if msglen < 0 {
  9706  				return ErrInvalidLengthGenerated
  9707  			}
  9708  			postIndex := iNdEx + msglen
  9709  			if postIndex < 0 {
  9710  				return ErrInvalidLengthGenerated
  9711  			}
  9712  			if postIndex > l {
  9713  				return io.ErrUnexpectedEOF
  9714  			}
  9715  			m.Ports = append(m.Ports, NetworkPolicyPort{})
  9716  			if err := m.Ports[len(m.Ports)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  9717  				return err
  9718  			}
  9719  			iNdEx = postIndex
  9720  		case 2:
  9721  			if wireType != 2 {
  9722  				return fmt.Errorf("proto: wrong wireType = %d for field From", wireType)
  9723  			}
  9724  			var msglen int
  9725  			for shift := uint(0); ; shift += 7 {
  9726  				if shift >= 64 {
  9727  					return ErrIntOverflowGenerated
  9728  				}
  9729  				if iNdEx >= l {
  9730  					return io.ErrUnexpectedEOF
  9731  				}
  9732  				b := dAtA[iNdEx]
  9733  				iNdEx++
  9734  				msglen |= int(b&0x7F) << shift
  9735  				if b < 0x80 {
  9736  					break
  9737  				}
  9738  			}
  9739  			if msglen < 0 {
  9740  				return ErrInvalidLengthGenerated
  9741  			}
  9742  			postIndex := iNdEx + msglen
  9743  			if postIndex < 0 {
  9744  				return ErrInvalidLengthGenerated
  9745  			}
  9746  			if postIndex > l {
  9747  				return io.ErrUnexpectedEOF
  9748  			}
  9749  			m.From = append(m.From, NetworkPolicyPeer{})
  9750  			if err := m.From[len(m.From)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  9751  				return err
  9752  			}
  9753  			iNdEx = postIndex
  9754  		default:
  9755  			iNdEx = preIndex
  9756  			skippy, err := skipGenerated(dAtA[iNdEx:])
  9757  			if err != nil {
  9758  				return err
  9759  			}
  9760  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  9761  				return ErrInvalidLengthGenerated
  9762  			}
  9763  			if (iNdEx + skippy) > l {
  9764  				return io.ErrUnexpectedEOF
  9765  			}
  9766  			iNdEx += skippy
  9767  		}
  9768  	}
  9769  
  9770  	if iNdEx > l {
  9771  		return io.ErrUnexpectedEOF
  9772  	}
  9773  	return nil
  9774  }
  9775  func (m *NetworkPolicyList) Unmarshal(dAtA []byte) error {
  9776  	l := len(dAtA)
  9777  	iNdEx := 0
  9778  	for iNdEx < l {
  9779  		preIndex := iNdEx
  9780  		var wire uint64
  9781  		for shift := uint(0); ; shift += 7 {
  9782  			if shift >= 64 {
  9783  				return ErrIntOverflowGenerated
  9784  			}
  9785  			if iNdEx >= l {
  9786  				return io.ErrUnexpectedEOF
  9787  			}
  9788  			b := dAtA[iNdEx]
  9789  			iNdEx++
  9790  			wire |= uint64(b&0x7F) << shift
  9791  			if b < 0x80 {
  9792  				break
  9793  			}
  9794  		}
  9795  		fieldNum := int32(wire >> 3)
  9796  		wireType := int(wire & 0x7)
  9797  		if wireType == 4 {
  9798  			return fmt.Errorf("proto: NetworkPolicyList: wiretype end group for non-group")
  9799  		}
  9800  		if fieldNum <= 0 {
  9801  			return fmt.Errorf("proto: NetworkPolicyList: illegal tag %d (wire type %d)", fieldNum, wire)
  9802  		}
  9803  		switch fieldNum {
  9804  		case 1:
  9805  			if wireType != 2 {
  9806  				return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
  9807  			}
  9808  			var msglen int
  9809  			for shift := uint(0); ; shift += 7 {
  9810  				if shift >= 64 {
  9811  					return ErrIntOverflowGenerated
  9812  				}
  9813  				if iNdEx >= l {
  9814  					return io.ErrUnexpectedEOF
  9815  				}
  9816  				b := dAtA[iNdEx]
  9817  				iNdEx++
  9818  				msglen |= int(b&0x7F) << shift
  9819  				if b < 0x80 {
  9820  					break
  9821  				}
  9822  			}
  9823  			if msglen < 0 {
  9824  				return ErrInvalidLengthGenerated
  9825  			}
  9826  			postIndex := iNdEx + msglen
  9827  			if postIndex < 0 {
  9828  				return ErrInvalidLengthGenerated
  9829  			}
  9830  			if postIndex > l {
  9831  				return io.ErrUnexpectedEOF
  9832  			}
  9833  			if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  9834  				return err
  9835  			}
  9836  			iNdEx = postIndex
  9837  		case 2:
  9838  			if wireType != 2 {
  9839  				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
  9840  			}
  9841  			var msglen int
  9842  			for shift := uint(0); ; shift += 7 {
  9843  				if shift >= 64 {
  9844  					return ErrIntOverflowGenerated
  9845  				}
  9846  				if iNdEx >= l {
  9847  					return io.ErrUnexpectedEOF
  9848  				}
  9849  				b := dAtA[iNdEx]
  9850  				iNdEx++
  9851  				msglen |= int(b&0x7F) << shift
  9852  				if b < 0x80 {
  9853  					break
  9854  				}
  9855  			}
  9856  			if msglen < 0 {
  9857  				return ErrInvalidLengthGenerated
  9858  			}
  9859  			postIndex := iNdEx + msglen
  9860  			if postIndex < 0 {
  9861  				return ErrInvalidLengthGenerated
  9862  			}
  9863  			if postIndex > l {
  9864  				return io.ErrUnexpectedEOF
  9865  			}
  9866  			m.Items = append(m.Items, NetworkPolicy{})
  9867  			if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  9868  				return err
  9869  			}
  9870  			iNdEx = postIndex
  9871  		default:
  9872  			iNdEx = preIndex
  9873  			skippy, err := skipGenerated(dAtA[iNdEx:])
  9874  			if err != nil {
  9875  				return err
  9876  			}
  9877  			if (skippy < 0) || (iNdEx+skippy) < 0 {
  9878  				return ErrInvalidLengthGenerated
  9879  			}
  9880  			if (iNdEx + skippy) > l {
  9881  				return io.ErrUnexpectedEOF
  9882  			}
  9883  			iNdEx += skippy
  9884  		}
  9885  	}
  9886  
  9887  	if iNdEx > l {
  9888  		return io.ErrUnexpectedEOF
  9889  	}
  9890  	return nil
  9891  }
  9892  func (m *NetworkPolicyPeer) Unmarshal(dAtA []byte) error {
  9893  	l := len(dAtA)
  9894  	iNdEx := 0
  9895  	for iNdEx < l {
  9896  		preIndex := iNdEx
  9897  		var wire uint64
  9898  		for shift := uint(0); ; shift += 7 {
  9899  			if shift >= 64 {
  9900  				return ErrIntOverflowGenerated
  9901  			}
  9902  			if iNdEx >= l {
  9903  				return io.ErrUnexpectedEOF
  9904  			}
  9905  			b := dAtA[iNdEx]
  9906  			iNdEx++
  9907  			wire |= uint64(b&0x7F) << shift
  9908  			if b < 0x80 {
  9909  				break
  9910  			}
  9911  		}
  9912  		fieldNum := int32(wire >> 3)
  9913  		wireType := int(wire & 0x7)
  9914  		if wireType == 4 {
  9915  			return fmt.Errorf("proto: NetworkPolicyPeer: wiretype end group for non-group")
  9916  		}
  9917  		if fieldNum <= 0 {
  9918  			return fmt.Errorf("proto: NetworkPolicyPeer: illegal tag %d (wire type %d)", fieldNum, wire)
  9919  		}
  9920  		switch fieldNum {
  9921  		case 1:
  9922  			if wireType != 2 {
  9923  				return fmt.Errorf("proto: wrong wireType = %d for field PodSelector", wireType)
  9924  			}
  9925  			var msglen int
  9926  			for shift := uint(0); ; shift += 7 {
  9927  				if shift >= 64 {
  9928  					return ErrIntOverflowGenerated
  9929  				}
  9930  				if iNdEx >= l {
  9931  					return io.ErrUnexpectedEOF
  9932  				}
  9933  				b := dAtA[iNdEx]
  9934  				iNdEx++
  9935  				msglen |= int(b&0x7F) << shift
  9936  				if b < 0x80 {
  9937  					break
  9938  				}
  9939  			}
  9940  			if msglen < 0 {
  9941  				return ErrInvalidLengthGenerated
  9942  			}
  9943  			postIndex := iNdEx + msglen
  9944  			if postIndex < 0 {
  9945  				return ErrInvalidLengthGenerated
  9946  			}
  9947  			if postIndex > l {
  9948  				return io.ErrUnexpectedEOF
  9949  			}
  9950  			if m.PodSelector == nil {
  9951  				m.PodSelector = &v1.LabelSelector{}
  9952  			}
  9953  			if err := m.PodSelector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  9954  				return err
  9955  			}
  9956  			iNdEx = postIndex
  9957  		case 2:
  9958  			if wireType != 2 {
  9959  				return fmt.Errorf("proto: wrong wireType = %d for field NamespaceSelector", wireType)
  9960  			}
  9961  			var msglen int
  9962  			for shift := uint(0); ; shift += 7 {
  9963  				if shift >= 64 {
  9964  					return ErrIntOverflowGenerated
  9965  				}
  9966  				if iNdEx >= l {
  9967  					return io.ErrUnexpectedEOF
  9968  				}
  9969  				b := dAtA[iNdEx]
  9970  				iNdEx++
  9971  				msglen |= int(b&0x7F) << shift
  9972  				if b < 0x80 {
  9973  					break
  9974  				}
  9975  			}
  9976  			if msglen < 0 {
  9977  				return ErrInvalidLengthGenerated
  9978  			}
  9979  			postIndex := iNdEx + msglen
  9980  			if postIndex < 0 {
  9981  				return ErrInvalidLengthGenerated
  9982  			}
  9983  			if postIndex > l {
  9984  				return io.ErrUnexpectedEOF
  9985  			}
  9986  			if m.NamespaceSelector == nil {
  9987  				m.NamespaceSelector = &v1.LabelSelector{}
  9988  			}
  9989  			if err := m.NamespaceSelector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  9990  				return err
  9991  			}
  9992  			iNdEx = postIndex
  9993  		case 3:
  9994  			if wireType != 2 {
  9995  				return fmt.Errorf("proto: wrong wireType = %d for field IPBlock", wireType)
  9996  			}
  9997  			var msglen int
  9998  			for shift := uint(0); ; shift += 7 {
  9999  				if shift >= 64 {
 10000  					return ErrIntOverflowGenerated
 10001  				}
 10002  				if iNdEx >= l {
 10003  					return io.ErrUnexpectedEOF
 10004  				}
 10005  				b := dAtA[iNdEx]
 10006  				iNdEx++
 10007  				msglen |= int(b&0x7F) << shift
 10008  				if b < 0x80 {
 10009  					break
 10010  				}
 10011  			}
 10012  			if msglen < 0 {
 10013  				return ErrInvalidLengthGenerated
 10014  			}
 10015  			postIndex := iNdEx + msglen
 10016  			if postIndex < 0 {
 10017  				return ErrInvalidLengthGenerated
 10018  			}
 10019  			if postIndex > l {
 10020  				return io.ErrUnexpectedEOF
 10021  			}
 10022  			if m.IPBlock == nil {
 10023  				m.IPBlock = &IPBlock{}
 10024  			}
 10025  			if err := m.IPBlock.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 10026  				return err
 10027  			}
 10028  			iNdEx = postIndex
 10029  		default:
 10030  			iNdEx = preIndex
 10031  			skippy, err := skipGenerated(dAtA[iNdEx:])
 10032  			if err != nil {
 10033  				return err
 10034  			}
 10035  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 10036  				return ErrInvalidLengthGenerated
 10037  			}
 10038  			if (iNdEx + skippy) > l {
 10039  				return io.ErrUnexpectedEOF
 10040  			}
 10041  			iNdEx += skippy
 10042  		}
 10043  	}
 10044  
 10045  	if iNdEx > l {
 10046  		return io.ErrUnexpectedEOF
 10047  	}
 10048  	return nil
 10049  }
 10050  func (m *NetworkPolicyPort) Unmarshal(dAtA []byte) error {
 10051  	l := len(dAtA)
 10052  	iNdEx := 0
 10053  	for iNdEx < l {
 10054  		preIndex := iNdEx
 10055  		var wire uint64
 10056  		for shift := uint(0); ; shift += 7 {
 10057  			if shift >= 64 {
 10058  				return ErrIntOverflowGenerated
 10059  			}
 10060  			if iNdEx >= l {
 10061  				return io.ErrUnexpectedEOF
 10062  			}
 10063  			b := dAtA[iNdEx]
 10064  			iNdEx++
 10065  			wire |= uint64(b&0x7F) << shift
 10066  			if b < 0x80 {
 10067  				break
 10068  			}
 10069  		}
 10070  		fieldNum := int32(wire >> 3)
 10071  		wireType := int(wire & 0x7)
 10072  		if wireType == 4 {
 10073  			return fmt.Errorf("proto: NetworkPolicyPort: wiretype end group for non-group")
 10074  		}
 10075  		if fieldNum <= 0 {
 10076  			return fmt.Errorf("proto: NetworkPolicyPort: illegal tag %d (wire type %d)", fieldNum, wire)
 10077  		}
 10078  		switch fieldNum {
 10079  		case 1:
 10080  			if wireType != 2 {
 10081  				return fmt.Errorf("proto: wrong wireType = %d for field Protocol", wireType)
 10082  			}
 10083  			var stringLen uint64
 10084  			for shift := uint(0); ; shift += 7 {
 10085  				if shift >= 64 {
 10086  					return ErrIntOverflowGenerated
 10087  				}
 10088  				if iNdEx >= l {
 10089  					return io.ErrUnexpectedEOF
 10090  				}
 10091  				b := dAtA[iNdEx]
 10092  				iNdEx++
 10093  				stringLen |= uint64(b&0x7F) << shift
 10094  				if b < 0x80 {
 10095  					break
 10096  				}
 10097  			}
 10098  			intStringLen := int(stringLen)
 10099  			if intStringLen < 0 {
 10100  				return ErrInvalidLengthGenerated
 10101  			}
 10102  			postIndex := iNdEx + intStringLen
 10103  			if postIndex < 0 {
 10104  				return ErrInvalidLengthGenerated
 10105  			}
 10106  			if postIndex > l {
 10107  				return io.ErrUnexpectedEOF
 10108  			}
 10109  			s := k8s_io_api_core_v1.Protocol(dAtA[iNdEx:postIndex])
 10110  			m.Protocol = &s
 10111  			iNdEx = postIndex
 10112  		case 2:
 10113  			if wireType != 2 {
 10114  				return fmt.Errorf("proto: wrong wireType = %d for field Port", wireType)
 10115  			}
 10116  			var msglen int
 10117  			for shift := uint(0); ; shift += 7 {
 10118  				if shift >= 64 {
 10119  					return ErrIntOverflowGenerated
 10120  				}
 10121  				if iNdEx >= l {
 10122  					return io.ErrUnexpectedEOF
 10123  				}
 10124  				b := dAtA[iNdEx]
 10125  				iNdEx++
 10126  				msglen |= int(b&0x7F) << shift
 10127  				if b < 0x80 {
 10128  					break
 10129  				}
 10130  			}
 10131  			if msglen < 0 {
 10132  				return ErrInvalidLengthGenerated
 10133  			}
 10134  			postIndex := iNdEx + msglen
 10135  			if postIndex < 0 {
 10136  				return ErrInvalidLengthGenerated
 10137  			}
 10138  			if postIndex > l {
 10139  				return io.ErrUnexpectedEOF
 10140  			}
 10141  			if m.Port == nil {
 10142  				m.Port = &intstr.IntOrString{}
 10143  			}
 10144  			if err := m.Port.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 10145  				return err
 10146  			}
 10147  			iNdEx = postIndex
 10148  		case 3:
 10149  			if wireType != 0 {
 10150  				return fmt.Errorf("proto: wrong wireType = %d for field EndPort", wireType)
 10151  			}
 10152  			var v int32
 10153  			for shift := uint(0); ; shift += 7 {
 10154  				if shift >= 64 {
 10155  					return ErrIntOverflowGenerated
 10156  				}
 10157  				if iNdEx >= l {
 10158  					return io.ErrUnexpectedEOF
 10159  				}
 10160  				b := dAtA[iNdEx]
 10161  				iNdEx++
 10162  				v |= int32(b&0x7F) << shift
 10163  				if b < 0x80 {
 10164  					break
 10165  				}
 10166  			}
 10167  			m.EndPort = &v
 10168  		default:
 10169  			iNdEx = preIndex
 10170  			skippy, err := skipGenerated(dAtA[iNdEx:])
 10171  			if err != nil {
 10172  				return err
 10173  			}
 10174  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 10175  				return ErrInvalidLengthGenerated
 10176  			}
 10177  			if (iNdEx + skippy) > l {
 10178  				return io.ErrUnexpectedEOF
 10179  			}
 10180  			iNdEx += skippy
 10181  		}
 10182  	}
 10183  
 10184  	if iNdEx > l {
 10185  		return io.ErrUnexpectedEOF
 10186  	}
 10187  	return nil
 10188  }
 10189  func (m *NetworkPolicySpec) Unmarshal(dAtA []byte) error {
 10190  	l := len(dAtA)
 10191  	iNdEx := 0
 10192  	for iNdEx < l {
 10193  		preIndex := iNdEx
 10194  		var wire uint64
 10195  		for shift := uint(0); ; shift += 7 {
 10196  			if shift >= 64 {
 10197  				return ErrIntOverflowGenerated
 10198  			}
 10199  			if iNdEx >= l {
 10200  				return io.ErrUnexpectedEOF
 10201  			}
 10202  			b := dAtA[iNdEx]
 10203  			iNdEx++
 10204  			wire |= uint64(b&0x7F) << shift
 10205  			if b < 0x80 {
 10206  				break
 10207  			}
 10208  		}
 10209  		fieldNum := int32(wire >> 3)
 10210  		wireType := int(wire & 0x7)
 10211  		if wireType == 4 {
 10212  			return fmt.Errorf("proto: NetworkPolicySpec: wiretype end group for non-group")
 10213  		}
 10214  		if fieldNum <= 0 {
 10215  			return fmt.Errorf("proto: NetworkPolicySpec: illegal tag %d (wire type %d)", fieldNum, wire)
 10216  		}
 10217  		switch fieldNum {
 10218  		case 1:
 10219  			if wireType != 2 {
 10220  				return fmt.Errorf("proto: wrong wireType = %d for field PodSelector", wireType)
 10221  			}
 10222  			var msglen int
 10223  			for shift := uint(0); ; shift += 7 {
 10224  				if shift >= 64 {
 10225  					return ErrIntOverflowGenerated
 10226  				}
 10227  				if iNdEx >= l {
 10228  					return io.ErrUnexpectedEOF
 10229  				}
 10230  				b := dAtA[iNdEx]
 10231  				iNdEx++
 10232  				msglen |= int(b&0x7F) << shift
 10233  				if b < 0x80 {
 10234  					break
 10235  				}
 10236  			}
 10237  			if msglen < 0 {
 10238  				return ErrInvalidLengthGenerated
 10239  			}
 10240  			postIndex := iNdEx + msglen
 10241  			if postIndex < 0 {
 10242  				return ErrInvalidLengthGenerated
 10243  			}
 10244  			if postIndex > l {
 10245  				return io.ErrUnexpectedEOF
 10246  			}
 10247  			if err := m.PodSelector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 10248  				return err
 10249  			}
 10250  			iNdEx = postIndex
 10251  		case 2:
 10252  			if wireType != 2 {
 10253  				return fmt.Errorf("proto: wrong wireType = %d for field Ingress", wireType)
 10254  			}
 10255  			var msglen int
 10256  			for shift := uint(0); ; shift += 7 {
 10257  				if shift >= 64 {
 10258  					return ErrIntOverflowGenerated
 10259  				}
 10260  				if iNdEx >= l {
 10261  					return io.ErrUnexpectedEOF
 10262  				}
 10263  				b := dAtA[iNdEx]
 10264  				iNdEx++
 10265  				msglen |= int(b&0x7F) << shift
 10266  				if b < 0x80 {
 10267  					break
 10268  				}
 10269  			}
 10270  			if msglen < 0 {
 10271  				return ErrInvalidLengthGenerated
 10272  			}
 10273  			postIndex := iNdEx + msglen
 10274  			if postIndex < 0 {
 10275  				return ErrInvalidLengthGenerated
 10276  			}
 10277  			if postIndex > l {
 10278  				return io.ErrUnexpectedEOF
 10279  			}
 10280  			m.Ingress = append(m.Ingress, NetworkPolicyIngressRule{})
 10281  			if err := m.Ingress[len(m.Ingress)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 10282  				return err
 10283  			}
 10284  			iNdEx = postIndex
 10285  		case 3:
 10286  			if wireType != 2 {
 10287  				return fmt.Errorf("proto: wrong wireType = %d for field Egress", wireType)
 10288  			}
 10289  			var msglen int
 10290  			for shift := uint(0); ; shift += 7 {
 10291  				if shift >= 64 {
 10292  					return ErrIntOverflowGenerated
 10293  				}
 10294  				if iNdEx >= l {
 10295  					return io.ErrUnexpectedEOF
 10296  				}
 10297  				b := dAtA[iNdEx]
 10298  				iNdEx++
 10299  				msglen |= int(b&0x7F) << shift
 10300  				if b < 0x80 {
 10301  					break
 10302  				}
 10303  			}
 10304  			if msglen < 0 {
 10305  				return ErrInvalidLengthGenerated
 10306  			}
 10307  			postIndex := iNdEx + msglen
 10308  			if postIndex < 0 {
 10309  				return ErrInvalidLengthGenerated
 10310  			}
 10311  			if postIndex > l {
 10312  				return io.ErrUnexpectedEOF
 10313  			}
 10314  			m.Egress = append(m.Egress, NetworkPolicyEgressRule{})
 10315  			if err := m.Egress[len(m.Egress)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 10316  				return err
 10317  			}
 10318  			iNdEx = postIndex
 10319  		case 4:
 10320  			if wireType != 2 {
 10321  				return fmt.Errorf("proto: wrong wireType = %d for field PolicyTypes", wireType)
 10322  			}
 10323  			var stringLen uint64
 10324  			for shift := uint(0); ; shift += 7 {
 10325  				if shift >= 64 {
 10326  					return ErrIntOverflowGenerated
 10327  				}
 10328  				if iNdEx >= l {
 10329  					return io.ErrUnexpectedEOF
 10330  				}
 10331  				b := dAtA[iNdEx]
 10332  				iNdEx++
 10333  				stringLen |= uint64(b&0x7F) << shift
 10334  				if b < 0x80 {
 10335  					break
 10336  				}
 10337  			}
 10338  			intStringLen := int(stringLen)
 10339  			if intStringLen < 0 {
 10340  				return ErrInvalidLengthGenerated
 10341  			}
 10342  			postIndex := iNdEx + intStringLen
 10343  			if postIndex < 0 {
 10344  				return ErrInvalidLengthGenerated
 10345  			}
 10346  			if postIndex > l {
 10347  				return io.ErrUnexpectedEOF
 10348  			}
 10349  			m.PolicyTypes = append(m.PolicyTypes, PolicyType(dAtA[iNdEx:postIndex]))
 10350  			iNdEx = postIndex
 10351  		default:
 10352  			iNdEx = preIndex
 10353  			skippy, err := skipGenerated(dAtA[iNdEx:])
 10354  			if err != nil {
 10355  				return err
 10356  			}
 10357  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 10358  				return ErrInvalidLengthGenerated
 10359  			}
 10360  			if (iNdEx + skippy) > l {
 10361  				return io.ErrUnexpectedEOF
 10362  			}
 10363  			iNdEx += skippy
 10364  		}
 10365  	}
 10366  
 10367  	if iNdEx > l {
 10368  		return io.ErrUnexpectedEOF
 10369  	}
 10370  	return nil
 10371  }
 10372  func (m *ReplicaSet) Unmarshal(dAtA []byte) error {
 10373  	l := len(dAtA)
 10374  	iNdEx := 0
 10375  	for iNdEx < l {
 10376  		preIndex := iNdEx
 10377  		var wire uint64
 10378  		for shift := uint(0); ; shift += 7 {
 10379  			if shift >= 64 {
 10380  				return ErrIntOverflowGenerated
 10381  			}
 10382  			if iNdEx >= l {
 10383  				return io.ErrUnexpectedEOF
 10384  			}
 10385  			b := dAtA[iNdEx]
 10386  			iNdEx++
 10387  			wire |= uint64(b&0x7F) << shift
 10388  			if b < 0x80 {
 10389  				break
 10390  			}
 10391  		}
 10392  		fieldNum := int32(wire >> 3)
 10393  		wireType := int(wire & 0x7)
 10394  		if wireType == 4 {
 10395  			return fmt.Errorf("proto: ReplicaSet: wiretype end group for non-group")
 10396  		}
 10397  		if fieldNum <= 0 {
 10398  			return fmt.Errorf("proto: ReplicaSet: illegal tag %d (wire type %d)", fieldNum, wire)
 10399  		}
 10400  		switch fieldNum {
 10401  		case 1:
 10402  			if wireType != 2 {
 10403  				return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
 10404  			}
 10405  			var msglen int
 10406  			for shift := uint(0); ; shift += 7 {
 10407  				if shift >= 64 {
 10408  					return ErrIntOverflowGenerated
 10409  				}
 10410  				if iNdEx >= l {
 10411  					return io.ErrUnexpectedEOF
 10412  				}
 10413  				b := dAtA[iNdEx]
 10414  				iNdEx++
 10415  				msglen |= int(b&0x7F) << shift
 10416  				if b < 0x80 {
 10417  					break
 10418  				}
 10419  			}
 10420  			if msglen < 0 {
 10421  				return ErrInvalidLengthGenerated
 10422  			}
 10423  			postIndex := iNdEx + msglen
 10424  			if postIndex < 0 {
 10425  				return ErrInvalidLengthGenerated
 10426  			}
 10427  			if postIndex > l {
 10428  				return io.ErrUnexpectedEOF
 10429  			}
 10430  			if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 10431  				return err
 10432  			}
 10433  			iNdEx = postIndex
 10434  		case 2:
 10435  			if wireType != 2 {
 10436  				return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
 10437  			}
 10438  			var msglen int
 10439  			for shift := uint(0); ; shift += 7 {
 10440  				if shift >= 64 {
 10441  					return ErrIntOverflowGenerated
 10442  				}
 10443  				if iNdEx >= l {
 10444  					return io.ErrUnexpectedEOF
 10445  				}
 10446  				b := dAtA[iNdEx]
 10447  				iNdEx++
 10448  				msglen |= int(b&0x7F) << shift
 10449  				if b < 0x80 {
 10450  					break
 10451  				}
 10452  			}
 10453  			if msglen < 0 {
 10454  				return ErrInvalidLengthGenerated
 10455  			}
 10456  			postIndex := iNdEx + msglen
 10457  			if postIndex < 0 {
 10458  				return ErrInvalidLengthGenerated
 10459  			}
 10460  			if postIndex > l {
 10461  				return io.ErrUnexpectedEOF
 10462  			}
 10463  			if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 10464  				return err
 10465  			}
 10466  			iNdEx = postIndex
 10467  		case 3:
 10468  			if wireType != 2 {
 10469  				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
 10470  			}
 10471  			var msglen int
 10472  			for shift := uint(0); ; shift += 7 {
 10473  				if shift >= 64 {
 10474  					return ErrIntOverflowGenerated
 10475  				}
 10476  				if iNdEx >= l {
 10477  					return io.ErrUnexpectedEOF
 10478  				}
 10479  				b := dAtA[iNdEx]
 10480  				iNdEx++
 10481  				msglen |= int(b&0x7F) << shift
 10482  				if b < 0x80 {
 10483  					break
 10484  				}
 10485  			}
 10486  			if msglen < 0 {
 10487  				return ErrInvalidLengthGenerated
 10488  			}
 10489  			postIndex := iNdEx + msglen
 10490  			if postIndex < 0 {
 10491  				return ErrInvalidLengthGenerated
 10492  			}
 10493  			if postIndex > l {
 10494  				return io.ErrUnexpectedEOF
 10495  			}
 10496  			if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 10497  				return err
 10498  			}
 10499  			iNdEx = postIndex
 10500  		default:
 10501  			iNdEx = preIndex
 10502  			skippy, err := skipGenerated(dAtA[iNdEx:])
 10503  			if err != nil {
 10504  				return err
 10505  			}
 10506  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 10507  				return ErrInvalidLengthGenerated
 10508  			}
 10509  			if (iNdEx + skippy) > l {
 10510  				return io.ErrUnexpectedEOF
 10511  			}
 10512  			iNdEx += skippy
 10513  		}
 10514  	}
 10515  
 10516  	if iNdEx > l {
 10517  		return io.ErrUnexpectedEOF
 10518  	}
 10519  	return nil
 10520  }
 10521  func (m *ReplicaSetCondition) Unmarshal(dAtA []byte) error {
 10522  	l := len(dAtA)
 10523  	iNdEx := 0
 10524  	for iNdEx < l {
 10525  		preIndex := iNdEx
 10526  		var wire uint64
 10527  		for shift := uint(0); ; shift += 7 {
 10528  			if shift >= 64 {
 10529  				return ErrIntOverflowGenerated
 10530  			}
 10531  			if iNdEx >= l {
 10532  				return io.ErrUnexpectedEOF
 10533  			}
 10534  			b := dAtA[iNdEx]
 10535  			iNdEx++
 10536  			wire |= uint64(b&0x7F) << shift
 10537  			if b < 0x80 {
 10538  				break
 10539  			}
 10540  		}
 10541  		fieldNum := int32(wire >> 3)
 10542  		wireType := int(wire & 0x7)
 10543  		if wireType == 4 {
 10544  			return fmt.Errorf("proto: ReplicaSetCondition: wiretype end group for non-group")
 10545  		}
 10546  		if fieldNum <= 0 {
 10547  			return fmt.Errorf("proto: ReplicaSetCondition: illegal tag %d (wire type %d)", fieldNum, wire)
 10548  		}
 10549  		switch fieldNum {
 10550  		case 1:
 10551  			if wireType != 2 {
 10552  				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
 10553  			}
 10554  			var stringLen uint64
 10555  			for shift := uint(0); ; shift += 7 {
 10556  				if shift >= 64 {
 10557  					return ErrIntOverflowGenerated
 10558  				}
 10559  				if iNdEx >= l {
 10560  					return io.ErrUnexpectedEOF
 10561  				}
 10562  				b := dAtA[iNdEx]
 10563  				iNdEx++
 10564  				stringLen |= uint64(b&0x7F) << shift
 10565  				if b < 0x80 {
 10566  					break
 10567  				}
 10568  			}
 10569  			intStringLen := int(stringLen)
 10570  			if intStringLen < 0 {
 10571  				return ErrInvalidLengthGenerated
 10572  			}
 10573  			postIndex := iNdEx + intStringLen
 10574  			if postIndex < 0 {
 10575  				return ErrInvalidLengthGenerated
 10576  			}
 10577  			if postIndex > l {
 10578  				return io.ErrUnexpectedEOF
 10579  			}
 10580  			m.Type = ReplicaSetConditionType(dAtA[iNdEx:postIndex])
 10581  			iNdEx = postIndex
 10582  		case 2:
 10583  			if wireType != 2 {
 10584  				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
 10585  			}
 10586  			var stringLen uint64
 10587  			for shift := uint(0); ; shift += 7 {
 10588  				if shift >= 64 {
 10589  					return ErrIntOverflowGenerated
 10590  				}
 10591  				if iNdEx >= l {
 10592  					return io.ErrUnexpectedEOF
 10593  				}
 10594  				b := dAtA[iNdEx]
 10595  				iNdEx++
 10596  				stringLen |= uint64(b&0x7F) << shift
 10597  				if b < 0x80 {
 10598  					break
 10599  				}
 10600  			}
 10601  			intStringLen := int(stringLen)
 10602  			if intStringLen < 0 {
 10603  				return ErrInvalidLengthGenerated
 10604  			}
 10605  			postIndex := iNdEx + intStringLen
 10606  			if postIndex < 0 {
 10607  				return ErrInvalidLengthGenerated
 10608  			}
 10609  			if postIndex > l {
 10610  				return io.ErrUnexpectedEOF
 10611  			}
 10612  			m.Status = k8s_io_api_core_v1.ConditionStatus(dAtA[iNdEx:postIndex])
 10613  			iNdEx = postIndex
 10614  		case 3:
 10615  			if wireType != 2 {
 10616  				return fmt.Errorf("proto: wrong wireType = %d for field LastTransitionTime", wireType)
 10617  			}
 10618  			var msglen int
 10619  			for shift := uint(0); ; shift += 7 {
 10620  				if shift >= 64 {
 10621  					return ErrIntOverflowGenerated
 10622  				}
 10623  				if iNdEx >= l {
 10624  					return io.ErrUnexpectedEOF
 10625  				}
 10626  				b := dAtA[iNdEx]
 10627  				iNdEx++
 10628  				msglen |= int(b&0x7F) << shift
 10629  				if b < 0x80 {
 10630  					break
 10631  				}
 10632  			}
 10633  			if msglen < 0 {
 10634  				return ErrInvalidLengthGenerated
 10635  			}
 10636  			postIndex := iNdEx + msglen
 10637  			if postIndex < 0 {
 10638  				return ErrInvalidLengthGenerated
 10639  			}
 10640  			if postIndex > l {
 10641  				return io.ErrUnexpectedEOF
 10642  			}
 10643  			if err := m.LastTransitionTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 10644  				return err
 10645  			}
 10646  			iNdEx = postIndex
 10647  		case 4:
 10648  			if wireType != 2 {
 10649  				return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
 10650  			}
 10651  			var stringLen uint64
 10652  			for shift := uint(0); ; shift += 7 {
 10653  				if shift >= 64 {
 10654  					return ErrIntOverflowGenerated
 10655  				}
 10656  				if iNdEx >= l {
 10657  					return io.ErrUnexpectedEOF
 10658  				}
 10659  				b := dAtA[iNdEx]
 10660  				iNdEx++
 10661  				stringLen |= uint64(b&0x7F) << shift
 10662  				if b < 0x80 {
 10663  					break
 10664  				}
 10665  			}
 10666  			intStringLen := int(stringLen)
 10667  			if intStringLen < 0 {
 10668  				return ErrInvalidLengthGenerated
 10669  			}
 10670  			postIndex := iNdEx + intStringLen
 10671  			if postIndex < 0 {
 10672  				return ErrInvalidLengthGenerated
 10673  			}
 10674  			if postIndex > l {
 10675  				return io.ErrUnexpectedEOF
 10676  			}
 10677  			m.Reason = string(dAtA[iNdEx:postIndex])
 10678  			iNdEx = postIndex
 10679  		case 5:
 10680  			if wireType != 2 {
 10681  				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
 10682  			}
 10683  			var stringLen uint64
 10684  			for shift := uint(0); ; shift += 7 {
 10685  				if shift >= 64 {
 10686  					return ErrIntOverflowGenerated
 10687  				}
 10688  				if iNdEx >= l {
 10689  					return io.ErrUnexpectedEOF
 10690  				}
 10691  				b := dAtA[iNdEx]
 10692  				iNdEx++
 10693  				stringLen |= uint64(b&0x7F) << shift
 10694  				if b < 0x80 {
 10695  					break
 10696  				}
 10697  			}
 10698  			intStringLen := int(stringLen)
 10699  			if intStringLen < 0 {
 10700  				return ErrInvalidLengthGenerated
 10701  			}
 10702  			postIndex := iNdEx + intStringLen
 10703  			if postIndex < 0 {
 10704  				return ErrInvalidLengthGenerated
 10705  			}
 10706  			if postIndex > l {
 10707  				return io.ErrUnexpectedEOF
 10708  			}
 10709  			m.Message = string(dAtA[iNdEx:postIndex])
 10710  			iNdEx = postIndex
 10711  		default:
 10712  			iNdEx = preIndex
 10713  			skippy, err := skipGenerated(dAtA[iNdEx:])
 10714  			if err != nil {
 10715  				return err
 10716  			}
 10717  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 10718  				return ErrInvalidLengthGenerated
 10719  			}
 10720  			if (iNdEx + skippy) > l {
 10721  				return io.ErrUnexpectedEOF
 10722  			}
 10723  			iNdEx += skippy
 10724  		}
 10725  	}
 10726  
 10727  	if iNdEx > l {
 10728  		return io.ErrUnexpectedEOF
 10729  	}
 10730  	return nil
 10731  }
 10732  func (m *ReplicaSetList) Unmarshal(dAtA []byte) error {
 10733  	l := len(dAtA)
 10734  	iNdEx := 0
 10735  	for iNdEx < l {
 10736  		preIndex := iNdEx
 10737  		var wire uint64
 10738  		for shift := uint(0); ; shift += 7 {
 10739  			if shift >= 64 {
 10740  				return ErrIntOverflowGenerated
 10741  			}
 10742  			if iNdEx >= l {
 10743  				return io.ErrUnexpectedEOF
 10744  			}
 10745  			b := dAtA[iNdEx]
 10746  			iNdEx++
 10747  			wire |= uint64(b&0x7F) << shift
 10748  			if b < 0x80 {
 10749  				break
 10750  			}
 10751  		}
 10752  		fieldNum := int32(wire >> 3)
 10753  		wireType := int(wire & 0x7)
 10754  		if wireType == 4 {
 10755  			return fmt.Errorf("proto: ReplicaSetList: wiretype end group for non-group")
 10756  		}
 10757  		if fieldNum <= 0 {
 10758  			return fmt.Errorf("proto: ReplicaSetList: illegal tag %d (wire type %d)", fieldNum, wire)
 10759  		}
 10760  		switch fieldNum {
 10761  		case 1:
 10762  			if wireType != 2 {
 10763  				return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
 10764  			}
 10765  			var msglen int
 10766  			for shift := uint(0); ; shift += 7 {
 10767  				if shift >= 64 {
 10768  					return ErrIntOverflowGenerated
 10769  				}
 10770  				if iNdEx >= l {
 10771  					return io.ErrUnexpectedEOF
 10772  				}
 10773  				b := dAtA[iNdEx]
 10774  				iNdEx++
 10775  				msglen |= int(b&0x7F) << shift
 10776  				if b < 0x80 {
 10777  					break
 10778  				}
 10779  			}
 10780  			if msglen < 0 {
 10781  				return ErrInvalidLengthGenerated
 10782  			}
 10783  			postIndex := iNdEx + msglen
 10784  			if postIndex < 0 {
 10785  				return ErrInvalidLengthGenerated
 10786  			}
 10787  			if postIndex > l {
 10788  				return io.ErrUnexpectedEOF
 10789  			}
 10790  			if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 10791  				return err
 10792  			}
 10793  			iNdEx = postIndex
 10794  		case 2:
 10795  			if wireType != 2 {
 10796  				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
 10797  			}
 10798  			var msglen int
 10799  			for shift := uint(0); ; shift += 7 {
 10800  				if shift >= 64 {
 10801  					return ErrIntOverflowGenerated
 10802  				}
 10803  				if iNdEx >= l {
 10804  					return io.ErrUnexpectedEOF
 10805  				}
 10806  				b := dAtA[iNdEx]
 10807  				iNdEx++
 10808  				msglen |= int(b&0x7F) << shift
 10809  				if b < 0x80 {
 10810  					break
 10811  				}
 10812  			}
 10813  			if msglen < 0 {
 10814  				return ErrInvalidLengthGenerated
 10815  			}
 10816  			postIndex := iNdEx + msglen
 10817  			if postIndex < 0 {
 10818  				return ErrInvalidLengthGenerated
 10819  			}
 10820  			if postIndex > l {
 10821  				return io.ErrUnexpectedEOF
 10822  			}
 10823  			m.Items = append(m.Items, ReplicaSet{})
 10824  			if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 10825  				return err
 10826  			}
 10827  			iNdEx = postIndex
 10828  		default:
 10829  			iNdEx = preIndex
 10830  			skippy, err := skipGenerated(dAtA[iNdEx:])
 10831  			if err != nil {
 10832  				return err
 10833  			}
 10834  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 10835  				return ErrInvalidLengthGenerated
 10836  			}
 10837  			if (iNdEx + skippy) > l {
 10838  				return io.ErrUnexpectedEOF
 10839  			}
 10840  			iNdEx += skippy
 10841  		}
 10842  	}
 10843  
 10844  	if iNdEx > l {
 10845  		return io.ErrUnexpectedEOF
 10846  	}
 10847  	return nil
 10848  }
 10849  func (m *ReplicaSetSpec) Unmarshal(dAtA []byte) error {
 10850  	l := len(dAtA)
 10851  	iNdEx := 0
 10852  	for iNdEx < l {
 10853  		preIndex := iNdEx
 10854  		var wire uint64
 10855  		for shift := uint(0); ; shift += 7 {
 10856  			if shift >= 64 {
 10857  				return ErrIntOverflowGenerated
 10858  			}
 10859  			if iNdEx >= l {
 10860  				return io.ErrUnexpectedEOF
 10861  			}
 10862  			b := dAtA[iNdEx]
 10863  			iNdEx++
 10864  			wire |= uint64(b&0x7F) << shift
 10865  			if b < 0x80 {
 10866  				break
 10867  			}
 10868  		}
 10869  		fieldNum := int32(wire >> 3)
 10870  		wireType := int(wire & 0x7)
 10871  		if wireType == 4 {
 10872  			return fmt.Errorf("proto: ReplicaSetSpec: wiretype end group for non-group")
 10873  		}
 10874  		if fieldNum <= 0 {
 10875  			return fmt.Errorf("proto: ReplicaSetSpec: illegal tag %d (wire type %d)", fieldNum, wire)
 10876  		}
 10877  		switch fieldNum {
 10878  		case 1:
 10879  			if wireType != 0 {
 10880  				return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
 10881  			}
 10882  			var v int32
 10883  			for shift := uint(0); ; shift += 7 {
 10884  				if shift >= 64 {
 10885  					return ErrIntOverflowGenerated
 10886  				}
 10887  				if iNdEx >= l {
 10888  					return io.ErrUnexpectedEOF
 10889  				}
 10890  				b := dAtA[iNdEx]
 10891  				iNdEx++
 10892  				v |= int32(b&0x7F) << shift
 10893  				if b < 0x80 {
 10894  					break
 10895  				}
 10896  			}
 10897  			m.Replicas = &v
 10898  		case 2:
 10899  			if wireType != 2 {
 10900  				return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType)
 10901  			}
 10902  			var msglen int
 10903  			for shift := uint(0); ; shift += 7 {
 10904  				if shift >= 64 {
 10905  					return ErrIntOverflowGenerated
 10906  				}
 10907  				if iNdEx >= l {
 10908  					return io.ErrUnexpectedEOF
 10909  				}
 10910  				b := dAtA[iNdEx]
 10911  				iNdEx++
 10912  				msglen |= int(b&0x7F) << shift
 10913  				if b < 0x80 {
 10914  					break
 10915  				}
 10916  			}
 10917  			if msglen < 0 {
 10918  				return ErrInvalidLengthGenerated
 10919  			}
 10920  			postIndex := iNdEx + msglen
 10921  			if postIndex < 0 {
 10922  				return ErrInvalidLengthGenerated
 10923  			}
 10924  			if postIndex > l {
 10925  				return io.ErrUnexpectedEOF
 10926  			}
 10927  			if m.Selector == nil {
 10928  				m.Selector = &v1.LabelSelector{}
 10929  			}
 10930  			if err := m.Selector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 10931  				return err
 10932  			}
 10933  			iNdEx = postIndex
 10934  		case 3:
 10935  			if wireType != 2 {
 10936  				return fmt.Errorf("proto: wrong wireType = %d for field Template", wireType)
 10937  			}
 10938  			var msglen int
 10939  			for shift := uint(0); ; shift += 7 {
 10940  				if shift >= 64 {
 10941  					return ErrIntOverflowGenerated
 10942  				}
 10943  				if iNdEx >= l {
 10944  					return io.ErrUnexpectedEOF
 10945  				}
 10946  				b := dAtA[iNdEx]
 10947  				iNdEx++
 10948  				msglen |= int(b&0x7F) << shift
 10949  				if b < 0x80 {
 10950  					break
 10951  				}
 10952  			}
 10953  			if msglen < 0 {
 10954  				return ErrInvalidLengthGenerated
 10955  			}
 10956  			postIndex := iNdEx + msglen
 10957  			if postIndex < 0 {
 10958  				return ErrInvalidLengthGenerated
 10959  			}
 10960  			if postIndex > l {
 10961  				return io.ErrUnexpectedEOF
 10962  			}
 10963  			if err := m.Template.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 10964  				return err
 10965  			}
 10966  			iNdEx = postIndex
 10967  		case 4:
 10968  			if wireType != 0 {
 10969  				return fmt.Errorf("proto: wrong wireType = %d for field MinReadySeconds", wireType)
 10970  			}
 10971  			m.MinReadySeconds = 0
 10972  			for shift := uint(0); ; shift += 7 {
 10973  				if shift >= 64 {
 10974  					return ErrIntOverflowGenerated
 10975  				}
 10976  				if iNdEx >= l {
 10977  					return io.ErrUnexpectedEOF
 10978  				}
 10979  				b := dAtA[iNdEx]
 10980  				iNdEx++
 10981  				m.MinReadySeconds |= int32(b&0x7F) << shift
 10982  				if b < 0x80 {
 10983  					break
 10984  				}
 10985  			}
 10986  		default:
 10987  			iNdEx = preIndex
 10988  			skippy, err := skipGenerated(dAtA[iNdEx:])
 10989  			if err != nil {
 10990  				return err
 10991  			}
 10992  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 10993  				return ErrInvalidLengthGenerated
 10994  			}
 10995  			if (iNdEx + skippy) > l {
 10996  				return io.ErrUnexpectedEOF
 10997  			}
 10998  			iNdEx += skippy
 10999  		}
 11000  	}
 11001  
 11002  	if iNdEx > l {
 11003  		return io.ErrUnexpectedEOF
 11004  	}
 11005  	return nil
 11006  }
 11007  func (m *ReplicaSetStatus) Unmarshal(dAtA []byte) error {
 11008  	l := len(dAtA)
 11009  	iNdEx := 0
 11010  	for iNdEx < l {
 11011  		preIndex := iNdEx
 11012  		var wire uint64
 11013  		for shift := uint(0); ; shift += 7 {
 11014  			if shift >= 64 {
 11015  				return ErrIntOverflowGenerated
 11016  			}
 11017  			if iNdEx >= l {
 11018  				return io.ErrUnexpectedEOF
 11019  			}
 11020  			b := dAtA[iNdEx]
 11021  			iNdEx++
 11022  			wire |= uint64(b&0x7F) << shift
 11023  			if b < 0x80 {
 11024  				break
 11025  			}
 11026  		}
 11027  		fieldNum := int32(wire >> 3)
 11028  		wireType := int(wire & 0x7)
 11029  		if wireType == 4 {
 11030  			return fmt.Errorf("proto: ReplicaSetStatus: wiretype end group for non-group")
 11031  		}
 11032  		if fieldNum <= 0 {
 11033  			return fmt.Errorf("proto: ReplicaSetStatus: illegal tag %d (wire type %d)", fieldNum, wire)
 11034  		}
 11035  		switch fieldNum {
 11036  		case 1:
 11037  			if wireType != 0 {
 11038  				return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
 11039  			}
 11040  			m.Replicas = 0
 11041  			for shift := uint(0); ; shift += 7 {
 11042  				if shift >= 64 {
 11043  					return ErrIntOverflowGenerated
 11044  				}
 11045  				if iNdEx >= l {
 11046  					return io.ErrUnexpectedEOF
 11047  				}
 11048  				b := dAtA[iNdEx]
 11049  				iNdEx++
 11050  				m.Replicas |= int32(b&0x7F) << shift
 11051  				if b < 0x80 {
 11052  					break
 11053  				}
 11054  			}
 11055  		case 2:
 11056  			if wireType != 0 {
 11057  				return fmt.Errorf("proto: wrong wireType = %d for field FullyLabeledReplicas", wireType)
 11058  			}
 11059  			m.FullyLabeledReplicas = 0
 11060  			for shift := uint(0); ; shift += 7 {
 11061  				if shift >= 64 {
 11062  					return ErrIntOverflowGenerated
 11063  				}
 11064  				if iNdEx >= l {
 11065  					return io.ErrUnexpectedEOF
 11066  				}
 11067  				b := dAtA[iNdEx]
 11068  				iNdEx++
 11069  				m.FullyLabeledReplicas |= int32(b&0x7F) << shift
 11070  				if b < 0x80 {
 11071  					break
 11072  				}
 11073  			}
 11074  		case 3:
 11075  			if wireType != 0 {
 11076  				return fmt.Errorf("proto: wrong wireType = %d for field ObservedGeneration", wireType)
 11077  			}
 11078  			m.ObservedGeneration = 0
 11079  			for shift := uint(0); ; shift += 7 {
 11080  				if shift >= 64 {
 11081  					return ErrIntOverflowGenerated
 11082  				}
 11083  				if iNdEx >= l {
 11084  					return io.ErrUnexpectedEOF
 11085  				}
 11086  				b := dAtA[iNdEx]
 11087  				iNdEx++
 11088  				m.ObservedGeneration |= int64(b&0x7F) << shift
 11089  				if b < 0x80 {
 11090  					break
 11091  				}
 11092  			}
 11093  		case 4:
 11094  			if wireType != 0 {
 11095  				return fmt.Errorf("proto: wrong wireType = %d for field ReadyReplicas", wireType)
 11096  			}
 11097  			m.ReadyReplicas = 0
 11098  			for shift := uint(0); ; shift += 7 {
 11099  				if shift >= 64 {
 11100  					return ErrIntOverflowGenerated
 11101  				}
 11102  				if iNdEx >= l {
 11103  					return io.ErrUnexpectedEOF
 11104  				}
 11105  				b := dAtA[iNdEx]
 11106  				iNdEx++
 11107  				m.ReadyReplicas |= int32(b&0x7F) << shift
 11108  				if b < 0x80 {
 11109  					break
 11110  				}
 11111  			}
 11112  		case 5:
 11113  			if wireType != 0 {
 11114  				return fmt.Errorf("proto: wrong wireType = %d for field AvailableReplicas", wireType)
 11115  			}
 11116  			m.AvailableReplicas = 0
 11117  			for shift := uint(0); ; shift += 7 {
 11118  				if shift >= 64 {
 11119  					return ErrIntOverflowGenerated
 11120  				}
 11121  				if iNdEx >= l {
 11122  					return io.ErrUnexpectedEOF
 11123  				}
 11124  				b := dAtA[iNdEx]
 11125  				iNdEx++
 11126  				m.AvailableReplicas |= int32(b&0x7F) << shift
 11127  				if b < 0x80 {
 11128  					break
 11129  				}
 11130  			}
 11131  		case 6:
 11132  			if wireType != 2 {
 11133  				return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType)
 11134  			}
 11135  			var msglen int
 11136  			for shift := uint(0); ; shift += 7 {
 11137  				if shift >= 64 {
 11138  					return ErrIntOverflowGenerated
 11139  				}
 11140  				if iNdEx >= l {
 11141  					return io.ErrUnexpectedEOF
 11142  				}
 11143  				b := dAtA[iNdEx]
 11144  				iNdEx++
 11145  				msglen |= int(b&0x7F) << shift
 11146  				if b < 0x80 {
 11147  					break
 11148  				}
 11149  			}
 11150  			if msglen < 0 {
 11151  				return ErrInvalidLengthGenerated
 11152  			}
 11153  			postIndex := iNdEx + msglen
 11154  			if postIndex < 0 {
 11155  				return ErrInvalidLengthGenerated
 11156  			}
 11157  			if postIndex > l {
 11158  				return io.ErrUnexpectedEOF
 11159  			}
 11160  			m.Conditions = append(m.Conditions, ReplicaSetCondition{})
 11161  			if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 11162  				return err
 11163  			}
 11164  			iNdEx = postIndex
 11165  		default:
 11166  			iNdEx = preIndex
 11167  			skippy, err := skipGenerated(dAtA[iNdEx:])
 11168  			if err != nil {
 11169  				return err
 11170  			}
 11171  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 11172  				return ErrInvalidLengthGenerated
 11173  			}
 11174  			if (iNdEx + skippy) > l {
 11175  				return io.ErrUnexpectedEOF
 11176  			}
 11177  			iNdEx += skippy
 11178  		}
 11179  	}
 11180  
 11181  	if iNdEx > l {
 11182  		return io.ErrUnexpectedEOF
 11183  	}
 11184  	return nil
 11185  }
 11186  func (m *RollbackConfig) Unmarshal(dAtA []byte) error {
 11187  	l := len(dAtA)
 11188  	iNdEx := 0
 11189  	for iNdEx < l {
 11190  		preIndex := iNdEx
 11191  		var wire uint64
 11192  		for shift := uint(0); ; shift += 7 {
 11193  			if shift >= 64 {
 11194  				return ErrIntOverflowGenerated
 11195  			}
 11196  			if iNdEx >= l {
 11197  				return io.ErrUnexpectedEOF
 11198  			}
 11199  			b := dAtA[iNdEx]
 11200  			iNdEx++
 11201  			wire |= uint64(b&0x7F) << shift
 11202  			if b < 0x80 {
 11203  				break
 11204  			}
 11205  		}
 11206  		fieldNum := int32(wire >> 3)
 11207  		wireType := int(wire & 0x7)
 11208  		if wireType == 4 {
 11209  			return fmt.Errorf("proto: RollbackConfig: wiretype end group for non-group")
 11210  		}
 11211  		if fieldNum <= 0 {
 11212  			return fmt.Errorf("proto: RollbackConfig: illegal tag %d (wire type %d)", fieldNum, wire)
 11213  		}
 11214  		switch fieldNum {
 11215  		case 1:
 11216  			if wireType != 0 {
 11217  				return fmt.Errorf("proto: wrong wireType = %d for field Revision", wireType)
 11218  			}
 11219  			m.Revision = 0
 11220  			for shift := uint(0); ; shift += 7 {
 11221  				if shift >= 64 {
 11222  					return ErrIntOverflowGenerated
 11223  				}
 11224  				if iNdEx >= l {
 11225  					return io.ErrUnexpectedEOF
 11226  				}
 11227  				b := dAtA[iNdEx]
 11228  				iNdEx++
 11229  				m.Revision |= int64(b&0x7F) << shift
 11230  				if b < 0x80 {
 11231  					break
 11232  				}
 11233  			}
 11234  		default:
 11235  			iNdEx = preIndex
 11236  			skippy, err := skipGenerated(dAtA[iNdEx:])
 11237  			if err != nil {
 11238  				return err
 11239  			}
 11240  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 11241  				return ErrInvalidLengthGenerated
 11242  			}
 11243  			if (iNdEx + skippy) > l {
 11244  				return io.ErrUnexpectedEOF
 11245  			}
 11246  			iNdEx += skippy
 11247  		}
 11248  	}
 11249  
 11250  	if iNdEx > l {
 11251  		return io.ErrUnexpectedEOF
 11252  	}
 11253  	return nil
 11254  }
 11255  func (m *RollingUpdateDaemonSet) Unmarshal(dAtA []byte) error {
 11256  	l := len(dAtA)
 11257  	iNdEx := 0
 11258  	for iNdEx < l {
 11259  		preIndex := iNdEx
 11260  		var wire uint64
 11261  		for shift := uint(0); ; shift += 7 {
 11262  			if shift >= 64 {
 11263  				return ErrIntOverflowGenerated
 11264  			}
 11265  			if iNdEx >= l {
 11266  				return io.ErrUnexpectedEOF
 11267  			}
 11268  			b := dAtA[iNdEx]
 11269  			iNdEx++
 11270  			wire |= uint64(b&0x7F) << shift
 11271  			if b < 0x80 {
 11272  				break
 11273  			}
 11274  		}
 11275  		fieldNum := int32(wire >> 3)
 11276  		wireType := int(wire & 0x7)
 11277  		if wireType == 4 {
 11278  			return fmt.Errorf("proto: RollingUpdateDaemonSet: wiretype end group for non-group")
 11279  		}
 11280  		if fieldNum <= 0 {
 11281  			return fmt.Errorf("proto: RollingUpdateDaemonSet: illegal tag %d (wire type %d)", fieldNum, wire)
 11282  		}
 11283  		switch fieldNum {
 11284  		case 1:
 11285  			if wireType != 2 {
 11286  				return fmt.Errorf("proto: wrong wireType = %d for field MaxUnavailable", wireType)
 11287  			}
 11288  			var msglen int
 11289  			for shift := uint(0); ; shift += 7 {
 11290  				if shift >= 64 {
 11291  					return ErrIntOverflowGenerated
 11292  				}
 11293  				if iNdEx >= l {
 11294  					return io.ErrUnexpectedEOF
 11295  				}
 11296  				b := dAtA[iNdEx]
 11297  				iNdEx++
 11298  				msglen |= int(b&0x7F) << shift
 11299  				if b < 0x80 {
 11300  					break
 11301  				}
 11302  			}
 11303  			if msglen < 0 {
 11304  				return ErrInvalidLengthGenerated
 11305  			}
 11306  			postIndex := iNdEx + msglen
 11307  			if postIndex < 0 {
 11308  				return ErrInvalidLengthGenerated
 11309  			}
 11310  			if postIndex > l {
 11311  				return io.ErrUnexpectedEOF
 11312  			}
 11313  			if m.MaxUnavailable == nil {
 11314  				m.MaxUnavailable = &intstr.IntOrString{}
 11315  			}
 11316  			if err := m.MaxUnavailable.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 11317  				return err
 11318  			}
 11319  			iNdEx = postIndex
 11320  		case 2:
 11321  			if wireType != 2 {
 11322  				return fmt.Errorf("proto: wrong wireType = %d for field MaxSurge", wireType)
 11323  			}
 11324  			var msglen int
 11325  			for shift := uint(0); ; shift += 7 {
 11326  				if shift >= 64 {
 11327  					return ErrIntOverflowGenerated
 11328  				}
 11329  				if iNdEx >= l {
 11330  					return io.ErrUnexpectedEOF
 11331  				}
 11332  				b := dAtA[iNdEx]
 11333  				iNdEx++
 11334  				msglen |= int(b&0x7F) << shift
 11335  				if b < 0x80 {
 11336  					break
 11337  				}
 11338  			}
 11339  			if msglen < 0 {
 11340  				return ErrInvalidLengthGenerated
 11341  			}
 11342  			postIndex := iNdEx + msglen
 11343  			if postIndex < 0 {
 11344  				return ErrInvalidLengthGenerated
 11345  			}
 11346  			if postIndex > l {
 11347  				return io.ErrUnexpectedEOF
 11348  			}
 11349  			if m.MaxSurge == nil {
 11350  				m.MaxSurge = &intstr.IntOrString{}
 11351  			}
 11352  			if err := m.MaxSurge.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 11353  				return err
 11354  			}
 11355  			iNdEx = postIndex
 11356  		default:
 11357  			iNdEx = preIndex
 11358  			skippy, err := skipGenerated(dAtA[iNdEx:])
 11359  			if err != nil {
 11360  				return err
 11361  			}
 11362  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 11363  				return ErrInvalidLengthGenerated
 11364  			}
 11365  			if (iNdEx + skippy) > l {
 11366  				return io.ErrUnexpectedEOF
 11367  			}
 11368  			iNdEx += skippy
 11369  		}
 11370  	}
 11371  
 11372  	if iNdEx > l {
 11373  		return io.ErrUnexpectedEOF
 11374  	}
 11375  	return nil
 11376  }
 11377  func (m *RollingUpdateDeployment) Unmarshal(dAtA []byte) error {
 11378  	l := len(dAtA)
 11379  	iNdEx := 0
 11380  	for iNdEx < l {
 11381  		preIndex := iNdEx
 11382  		var wire uint64
 11383  		for shift := uint(0); ; shift += 7 {
 11384  			if shift >= 64 {
 11385  				return ErrIntOverflowGenerated
 11386  			}
 11387  			if iNdEx >= l {
 11388  				return io.ErrUnexpectedEOF
 11389  			}
 11390  			b := dAtA[iNdEx]
 11391  			iNdEx++
 11392  			wire |= uint64(b&0x7F) << shift
 11393  			if b < 0x80 {
 11394  				break
 11395  			}
 11396  		}
 11397  		fieldNum := int32(wire >> 3)
 11398  		wireType := int(wire & 0x7)
 11399  		if wireType == 4 {
 11400  			return fmt.Errorf("proto: RollingUpdateDeployment: wiretype end group for non-group")
 11401  		}
 11402  		if fieldNum <= 0 {
 11403  			return fmt.Errorf("proto: RollingUpdateDeployment: illegal tag %d (wire type %d)", fieldNum, wire)
 11404  		}
 11405  		switch fieldNum {
 11406  		case 1:
 11407  			if wireType != 2 {
 11408  				return fmt.Errorf("proto: wrong wireType = %d for field MaxUnavailable", wireType)
 11409  			}
 11410  			var msglen int
 11411  			for shift := uint(0); ; shift += 7 {
 11412  				if shift >= 64 {
 11413  					return ErrIntOverflowGenerated
 11414  				}
 11415  				if iNdEx >= l {
 11416  					return io.ErrUnexpectedEOF
 11417  				}
 11418  				b := dAtA[iNdEx]
 11419  				iNdEx++
 11420  				msglen |= int(b&0x7F) << shift
 11421  				if b < 0x80 {
 11422  					break
 11423  				}
 11424  			}
 11425  			if msglen < 0 {
 11426  				return ErrInvalidLengthGenerated
 11427  			}
 11428  			postIndex := iNdEx + msglen
 11429  			if postIndex < 0 {
 11430  				return ErrInvalidLengthGenerated
 11431  			}
 11432  			if postIndex > l {
 11433  				return io.ErrUnexpectedEOF
 11434  			}
 11435  			if m.MaxUnavailable == nil {
 11436  				m.MaxUnavailable = &intstr.IntOrString{}
 11437  			}
 11438  			if err := m.MaxUnavailable.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 11439  				return err
 11440  			}
 11441  			iNdEx = postIndex
 11442  		case 2:
 11443  			if wireType != 2 {
 11444  				return fmt.Errorf("proto: wrong wireType = %d for field MaxSurge", wireType)
 11445  			}
 11446  			var msglen int
 11447  			for shift := uint(0); ; shift += 7 {
 11448  				if shift >= 64 {
 11449  					return ErrIntOverflowGenerated
 11450  				}
 11451  				if iNdEx >= l {
 11452  					return io.ErrUnexpectedEOF
 11453  				}
 11454  				b := dAtA[iNdEx]
 11455  				iNdEx++
 11456  				msglen |= int(b&0x7F) << shift
 11457  				if b < 0x80 {
 11458  					break
 11459  				}
 11460  			}
 11461  			if msglen < 0 {
 11462  				return ErrInvalidLengthGenerated
 11463  			}
 11464  			postIndex := iNdEx + msglen
 11465  			if postIndex < 0 {
 11466  				return ErrInvalidLengthGenerated
 11467  			}
 11468  			if postIndex > l {
 11469  				return io.ErrUnexpectedEOF
 11470  			}
 11471  			if m.MaxSurge == nil {
 11472  				m.MaxSurge = &intstr.IntOrString{}
 11473  			}
 11474  			if err := m.MaxSurge.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 11475  				return err
 11476  			}
 11477  			iNdEx = postIndex
 11478  		default:
 11479  			iNdEx = preIndex
 11480  			skippy, err := skipGenerated(dAtA[iNdEx:])
 11481  			if err != nil {
 11482  				return err
 11483  			}
 11484  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 11485  				return ErrInvalidLengthGenerated
 11486  			}
 11487  			if (iNdEx + skippy) > l {
 11488  				return io.ErrUnexpectedEOF
 11489  			}
 11490  			iNdEx += skippy
 11491  		}
 11492  	}
 11493  
 11494  	if iNdEx > l {
 11495  		return io.ErrUnexpectedEOF
 11496  	}
 11497  	return nil
 11498  }
 11499  func (m *Scale) Unmarshal(dAtA []byte) error {
 11500  	l := len(dAtA)
 11501  	iNdEx := 0
 11502  	for iNdEx < l {
 11503  		preIndex := iNdEx
 11504  		var wire uint64
 11505  		for shift := uint(0); ; shift += 7 {
 11506  			if shift >= 64 {
 11507  				return ErrIntOverflowGenerated
 11508  			}
 11509  			if iNdEx >= l {
 11510  				return io.ErrUnexpectedEOF
 11511  			}
 11512  			b := dAtA[iNdEx]
 11513  			iNdEx++
 11514  			wire |= uint64(b&0x7F) << shift
 11515  			if b < 0x80 {
 11516  				break
 11517  			}
 11518  		}
 11519  		fieldNum := int32(wire >> 3)
 11520  		wireType := int(wire & 0x7)
 11521  		if wireType == 4 {
 11522  			return fmt.Errorf("proto: Scale: wiretype end group for non-group")
 11523  		}
 11524  		if fieldNum <= 0 {
 11525  			return fmt.Errorf("proto: Scale: illegal tag %d (wire type %d)", fieldNum, wire)
 11526  		}
 11527  		switch fieldNum {
 11528  		case 1:
 11529  			if wireType != 2 {
 11530  				return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
 11531  			}
 11532  			var msglen int
 11533  			for shift := uint(0); ; shift += 7 {
 11534  				if shift >= 64 {
 11535  					return ErrIntOverflowGenerated
 11536  				}
 11537  				if iNdEx >= l {
 11538  					return io.ErrUnexpectedEOF
 11539  				}
 11540  				b := dAtA[iNdEx]
 11541  				iNdEx++
 11542  				msglen |= int(b&0x7F) << shift
 11543  				if b < 0x80 {
 11544  					break
 11545  				}
 11546  			}
 11547  			if msglen < 0 {
 11548  				return ErrInvalidLengthGenerated
 11549  			}
 11550  			postIndex := iNdEx + msglen
 11551  			if postIndex < 0 {
 11552  				return ErrInvalidLengthGenerated
 11553  			}
 11554  			if postIndex > l {
 11555  				return io.ErrUnexpectedEOF
 11556  			}
 11557  			if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 11558  				return err
 11559  			}
 11560  			iNdEx = postIndex
 11561  		case 2:
 11562  			if wireType != 2 {
 11563  				return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
 11564  			}
 11565  			var msglen int
 11566  			for shift := uint(0); ; shift += 7 {
 11567  				if shift >= 64 {
 11568  					return ErrIntOverflowGenerated
 11569  				}
 11570  				if iNdEx >= l {
 11571  					return io.ErrUnexpectedEOF
 11572  				}
 11573  				b := dAtA[iNdEx]
 11574  				iNdEx++
 11575  				msglen |= int(b&0x7F) << shift
 11576  				if b < 0x80 {
 11577  					break
 11578  				}
 11579  			}
 11580  			if msglen < 0 {
 11581  				return ErrInvalidLengthGenerated
 11582  			}
 11583  			postIndex := iNdEx + msglen
 11584  			if postIndex < 0 {
 11585  				return ErrInvalidLengthGenerated
 11586  			}
 11587  			if postIndex > l {
 11588  				return io.ErrUnexpectedEOF
 11589  			}
 11590  			if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 11591  				return err
 11592  			}
 11593  			iNdEx = postIndex
 11594  		case 3:
 11595  			if wireType != 2 {
 11596  				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
 11597  			}
 11598  			var msglen int
 11599  			for shift := uint(0); ; shift += 7 {
 11600  				if shift >= 64 {
 11601  					return ErrIntOverflowGenerated
 11602  				}
 11603  				if iNdEx >= l {
 11604  					return io.ErrUnexpectedEOF
 11605  				}
 11606  				b := dAtA[iNdEx]
 11607  				iNdEx++
 11608  				msglen |= int(b&0x7F) << shift
 11609  				if b < 0x80 {
 11610  					break
 11611  				}
 11612  			}
 11613  			if msglen < 0 {
 11614  				return ErrInvalidLengthGenerated
 11615  			}
 11616  			postIndex := iNdEx + msglen
 11617  			if postIndex < 0 {
 11618  				return ErrInvalidLengthGenerated
 11619  			}
 11620  			if postIndex > l {
 11621  				return io.ErrUnexpectedEOF
 11622  			}
 11623  			if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 11624  				return err
 11625  			}
 11626  			iNdEx = postIndex
 11627  		default:
 11628  			iNdEx = preIndex
 11629  			skippy, err := skipGenerated(dAtA[iNdEx:])
 11630  			if err != nil {
 11631  				return err
 11632  			}
 11633  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 11634  				return ErrInvalidLengthGenerated
 11635  			}
 11636  			if (iNdEx + skippy) > l {
 11637  				return io.ErrUnexpectedEOF
 11638  			}
 11639  			iNdEx += skippy
 11640  		}
 11641  	}
 11642  
 11643  	if iNdEx > l {
 11644  		return io.ErrUnexpectedEOF
 11645  	}
 11646  	return nil
 11647  }
 11648  func (m *ScaleSpec) Unmarshal(dAtA []byte) error {
 11649  	l := len(dAtA)
 11650  	iNdEx := 0
 11651  	for iNdEx < l {
 11652  		preIndex := iNdEx
 11653  		var wire uint64
 11654  		for shift := uint(0); ; shift += 7 {
 11655  			if shift >= 64 {
 11656  				return ErrIntOverflowGenerated
 11657  			}
 11658  			if iNdEx >= l {
 11659  				return io.ErrUnexpectedEOF
 11660  			}
 11661  			b := dAtA[iNdEx]
 11662  			iNdEx++
 11663  			wire |= uint64(b&0x7F) << shift
 11664  			if b < 0x80 {
 11665  				break
 11666  			}
 11667  		}
 11668  		fieldNum := int32(wire >> 3)
 11669  		wireType := int(wire & 0x7)
 11670  		if wireType == 4 {
 11671  			return fmt.Errorf("proto: ScaleSpec: wiretype end group for non-group")
 11672  		}
 11673  		if fieldNum <= 0 {
 11674  			return fmt.Errorf("proto: ScaleSpec: illegal tag %d (wire type %d)", fieldNum, wire)
 11675  		}
 11676  		switch fieldNum {
 11677  		case 1:
 11678  			if wireType != 0 {
 11679  				return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
 11680  			}
 11681  			m.Replicas = 0
 11682  			for shift := uint(0); ; shift += 7 {
 11683  				if shift >= 64 {
 11684  					return ErrIntOverflowGenerated
 11685  				}
 11686  				if iNdEx >= l {
 11687  					return io.ErrUnexpectedEOF
 11688  				}
 11689  				b := dAtA[iNdEx]
 11690  				iNdEx++
 11691  				m.Replicas |= int32(b&0x7F) << shift
 11692  				if b < 0x80 {
 11693  					break
 11694  				}
 11695  			}
 11696  		default:
 11697  			iNdEx = preIndex
 11698  			skippy, err := skipGenerated(dAtA[iNdEx:])
 11699  			if err != nil {
 11700  				return err
 11701  			}
 11702  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 11703  				return ErrInvalidLengthGenerated
 11704  			}
 11705  			if (iNdEx + skippy) > l {
 11706  				return io.ErrUnexpectedEOF
 11707  			}
 11708  			iNdEx += skippy
 11709  		}
 11710  	}
 11711  
 11712  	if iNdEx > l {
 11713  		return io.ErrUnexpectedEOF
 11714  	}
 11715  	return nil
 11716  }
 11717  func (m *ScaleStatus) Unmarshal(dAtA []byte) error {
 11718  	l := len(dAtA)
 11719  	iNdEx := 0
 11720  	for iNdEx < l {
 11721  		preIndex := iNdEx
 11722  		var wire uint64
 11723  		for shift := uint(0); ; shift += 7 {
 11724  			if shift >= 64 {
 11725  				return ErrIntOverflowGenerated
 11726  			}
 11727  			if iNdEx >= l {
 11728  				return io.ErrUnexpectedEOF
 11729  			}
 11730  			b := dAtA[iNdEx]
 11731  			iNdEx++
 11732  			wire |= uint64(b&0x7F) << shift
 11733  			if b < 0x80 {
 11734  				break
 11735  			}
 11736  		}
 11737  		fieldNum := int32(wire >> 3)
 11738  		wireType := int(wire & 0x7)
 11739  		if wireType == 4 {
 11740  			return fmt.Errorf("proto: ScaleStatus: wiretype end group for non-group")
 11741  		}
 11742  		if fieldNum <= 0 {
 11743  			return fmt.Errorf("proto: ScaleStatus: illegal tag %d (wire type %d)", fieldNum, wire)
 11744  		}
 11745  		switch fieldNum {
 11746  		case 1:
 11747  			if wireType != 0 {
 11748  				return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
 11749  			}
 11750  			m.Replicas = 0
 11751  			for shift := uint(0); ; shift += 7 {
 11752  				if shift >= 64 {
 11753  					return ErrIntOverflowGenerated
 11754  				}
 11755  				if iNdEx >= l {
 11756  					return io.ErrUnexpectedEOF
 11757  				}
 11758  				b := dAtA[iNdEx]
 11759  				iNdEx++
 11760  				m.Replicas |= int32(b&0x7F) << shift
 11761  				if b < 0x80 {
 11762  					break
 11763  				}
 11764  			}
 11765  		case 2:
 11766  			if wireType != 2 {
 11767  				return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType)
 11768  			}
 11769  			var msglen int
 11770  			for shift := uint(0); ; shift += 7 {
 11771  				if shift >= 64 {
 11772  					return ErrIntOverflowGenerated
 11773  				}
 11774  				if iNdEx >= l {
 11775  					return io.ErrUnexpectedEOF
 11776  				}
 11777  				b := dAtA[iNdEx]
 11778  				iNdEx++
 11779  				msglen |= int(b&0x7F) << shift
 11780  				if b < 0x80 {
 11781  					break
 11782  				}
 11783  			}
 11784  			if msglen < 0 {
 11785  				return ErrInvalidLengthGenerated
 11786  			}
 11787  			postIndex := iNdEx + msglen
 11788  			if postIndex < 0 {
 11789  				return ErrInvalidLengthGenerated
 11790  			}
 11791  			if postIndex > l {
 11792  				return io.ErrUnexpectedEOF
 11793  			}
 11794  			if m.Selector == nil {
 11795  				m.Selector = make(map[string]string)
 11796  			}
 11797  			var mapkey string
 11798  			var mapvalue string
 11799  			for iNdEx < postIndex {
 11800  				entryPreIndex := iNdEx
 11801  				var wire uint64
 11802  				for shift := uint(0); ; shift += 7 {
 11803  					if shift >= 64 {
 11804  						return ErrIntOverflowGenerated
 11805  					}
 11806  					if iNdEx >= l {
 11807  						return io.ErrUnexpectedEOF
 11808  					}
 11809  					b := dAtA[iNdEx]
 11810  					iNdEx++
 11811  					wire |= uint64(b&0x7F) << shift
 11812  					if b < 0x80 {
 11813  						break
 11814  					}
 11815  				}
 11816  				fieldNum := int32(wire >> 3)
 11817  				if fieldNum == 1 {
 11818  					var stringLenmapkey uint64
 11819  					for shift := uint(0); ; shift += 7 {
 11820  						if shift >= 64 {
 11821  							return ErrIntOverflowGenerated
 11822  						}
 11823  						if iNdEx >= l {
 11824  							return io.ErrUnexpectedEOF
 11825  						}
 11826  						b := dAtA[iNdEx]
 11827  						iNdEx++
 11828  						stringLenmapkey |= uint64(b&0x7F) << shift
 11829  						if b < 0x80 {
 11830  							break
 11831  						}
 11832  					}
 11833  					intStringLenmapkey := int(stringLenmapkey)
 11834  					if intStringLenmapkey < 0 {
 11835  						return ErrInvalidLengthGenerated
 11836  					}
 11837  					postStringIndexmapkey := iNdEx + intStringLenmapkey
 11838  					if postStringIndexmapkey < 0 {
 11839  						return ErrInvalidLengthGenerated
 11840  					}
 11841  					if postStringIndexmapkey > l {
 11842  						return io.ErrUnexpectedEOF
 11843  					}
 11844  					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
 11845  					iNdEx = postStringIndexmapkey
 11846  				} else if fieldNum == 2 {
 11847  					var stringLenmapvalue uint64
 11848  					for shift := uint(0); ; shift += 7 {
 11849  						if shift >= 64 {
 11850  							return ErrIntOverflowGenerated
 11851  						}
 11852  						if iNdEx >= l {
 11853  							return io.ErrUnexpectedEOF
 11854  						}
 11855  						b := dAtA[iNdEx]
 11856  						iNdEx++
 11857  						stringLenmapvalue |= uint64(b&0x7F) << shift
 11858  						if b < 0x80 {
 11859  							break
 11860  						}
 11861  					}
 11862  					intStringLenmapvalue := int(stringLenmapvalue)
 11863  					if intStringLenmapvalue < 0 {
 11864  						return ErrInvalidLengthGenerated
 11865  					}
 11866  					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
 11867  					if postStringIndexmapvalue < 0 {
 11868  						return ErrInvalidLengthGenerated
 11869  					}
 11870  					if postStringIndexmapvalue > l {
 11871  						return io.ErrUnexpectedEOF
 11872  					}
 11873  					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
 11874  					iNdEx = postStringIndexmapvalue
 11875  				} else {
 11876  					iNdEx = entryPreIndex
 11877  					skippy, err := skipGenerated(dAtA[iNdEx:])
 11878  					if err != nil {
 11879  						return err
 11880  					}
 11881  					if (skippy < 0) || (iNdEx+skippy) < 0 {
 11882  						return ErrInvalidLengthGenerated
 11883  					}
 11884  					if (iNdEx + skippy) > postIndex {
 11885  						return io.ErrUnexpectedEOF
 11886  					}
 11887  					iNdEx += skippy
 11888  				}
 11889  			}
 11890  			m.Selector[mapkey] = mapvalue
 11891  			iNdEx = postIndex
 11892  		case 3:
 11893  			if wireType != 2 {
 11894  				return fmt.Errorf("proto: wrong wireType = %d for field TargetSelector", wireType)
 11895  			}
 11896  			var stringLen uint64
 11897  			for shift := uint(0); ; shift += 7 {
 11898  				if shift >= 64 {
 11899  					return ErrIntOverflowGenerated
 11900  				}
 11901  				if iNdEx >= l {
 11902  					return io.ErrUnexpectedEOF
 11903  				}
 11904  				b := dAtA[iNdEx]
 11905  				iNdEx++
 11906  				stringLen |= uint64(b&0x7F) << shift
 11907  				if b < 0x80 {
 11908  					break
 11909  				}
 11910  			}
 11911  			intStringLen := int(stringLen)
 11912  			if intStringLen < 0 {
 11913  				return ErrInvalidLengthGenerated
 11914  			}
 11915  			postIndex := iNdEx + intStringLen
 11916  			if postIndex < 0 {
 11917  				return ErrInvalidLengthGenerated
 11918  			}
 11919  			if postIndex > l {
 11920  				return io.ErrUnexpectedEOF
 11921  			}
 11922  			m.TargetSelector = string(dAtA[iNdEx:postIndex])
 11923  			iNdEx = postIndex
 11924  		default:
 11925  			iNdEx = preIndex
 11926  			skippy, err := skipGenerated(dAtA[iNdEx:])
 11927  			if err != nil {
 11928  				return err
 11929  			}
 11930  			if (skippy < 0) || (iNdEx+skippy) < 0 {
 11931  				return ErrInvalidLengthGenerated
 11932  			}
 11933  			if (iNdEx + skippy) > l {
 11934  				return io.ErrUnexpectedEOF
 11935  			}
 11936  			iNdEx += skippy
 11937  		}
 11938  	}
 11939  
 11940  	if iNdEx > l {
 11941  		return io.ErrUnexpectedEOF
 11942  	}
 11943  	return nil
 11944  }
 11945  func skipGenerated(dAtA []byte) (n int, err error) {
 11946  	l := len(dAtA)
 11947  	iNdEx := 0
 11948  	depth := 0
 11949  	for iNdEx < l {
 11950  		var wire uint64
 11951  		for shift := uint(0); ; shift += 7 {
 11952  			if shift >= 64 {
 11953  				return 0, ErrIntOverflowGenerated
 11954  			}
 11955  			if iNdEx >= l {
 11956  				return 0, io.ErrUnexpectedEOF
 11957  			}
 11958  			b := dAtA[iNdEx]
 11959  			iNdEx++
 11960  			wire |= (uint64(b) & 0x7F) << shift
 11961  			if b < 0x80 {
 11962  				break
 11963  			}
 11964  		}
 11965  		wireType := int(wire & 0x7)
 11966  		switch wireType {
 11967  		case 0:
 11968  			for shift := uint(0); ; shift += 7 {
 11969  				if shift >= 64 {
 11970  					return 0, ErrIntOverflowGenerated
 11971  				}
 11972  				if iNdEx >= l {
 11973  					return 0, io.ErrUnexpectedEOF
 11974  				}
 11975  				iNdEx++
 11976  				if dAtA[iNdEx-1] < 0x80 {
 11977  					break
 11978  				}
 11979  			}
 11980  		case 1:
 11981  			iNdEx += 8
 11982  		case 2:
 11983  			var length int
 11984  			for shift := uint(0); ; shift += 7 {
 11985  				if shift >= 64 {
 11986  					return 0, ErrIntOverflowGenerated
 11987  				}
 11988  				if iNdEx >= l {
 11989  					return 0, io.ErrUnexpectedEOF
 11990  				}
 11991  				b := dAtA[iNdEx]
 11992  				iNdEx++
 11993  				length |= (int(b) & 0x7F) << shift
 11994  				if b < 0x80 {
 11995  					break
 11996  				}
 11997  			}
 11998  			if length < 0 {
 11999  				return 0, ErrInvalidLengthGenerated
 12000  			}
 12001  			iNdEx += length
 12002  		case 3:
 12003  			depth++
 12004  		case 4:
 12005  			if depth == 0 {
 12006  				return 0, ErrUnexpectedEndOfGroupGenerated
 12007  			}
 12008  			depth--
 12009  		case 5:
 12010  			iNdEx += 4
 12011  		default:
 12012  			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
 12013  		}
 12014  		if iNdEx < 0 {
 12015  			return 0, ErrInvalidLengthGenerated
 12016  		}
 12017  		if depth == 0 {
 12018  			return iNdEx, nil
 12019  		}
 12020  	}
 12021  	return 0, io.ErrUnexpectedEOF
 12022  }
 12023  
 12024  var (
 12025  	ErrInvalidLengthGenerated        = fmt.Errorf("proto: negative length found during unmarshaling")
 12026  	ErrIntOverflowGenerated          = fmt.Errorf("proto: integer overflow")
 12027  	ErrUnexpectedEndOfGroupGenerated = fmt.Errorf("proto: unexpected end of group")
 12028  )
 12029  

View as plain text