cmd/bpa-operator/vendor/k8s.io/api/autoscaling/v1/generated.pb.go

   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/kubernetes/vendor/k8s.io/api/autoscaling/v1/generated.proto
  19
  20 /*
  21         Package v1 is a generated protocol buffer package.
  22
  23         It is generated from these files:
  24                 k8s.io/kubernetes/vendor/k8s.io/api/autoscaling/v1/generated.proto
  25
  26         It has these top-level messages:
  27                 CrossVersionObjectReference
  28                 ExternalMetricSource
  29                 ExternalMetricStatus
  30                 HorizontalPodAutoscaler
  31                 HorizontalPodAutoscalerCondition
  32                 HorizontalPodAutoscalerList
  33                 HorizontalPodAutoscalerSpec
  34                 HorizontalPodAutoscalerStatus
  35                 MetricSpec
  36                 MetricStatus
  37                 ObjectMetricSource
  38                 ObjectMetricStatus
  39                 PodsMetricSource
  40                 PodsMetricStatus
  41                 ResourceMetricSource
  42                 ResourceMetricStatus
  43                 Scale
  44                 ScaleSpec
  45                 ScaleStatus
  46 */
  47 package v1
  48
  49 import proto "github.com/gogo/protobuf/proto"
  50 import fmt "fmt"
  51 import math "math"
  52
  53 import k8s_io_apimachinery_pkg_api_resource "k8s.io/apimachinery/pkg/api/resource"
  54 import k8s_io_apimachinery_pkg_apis_meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
  55
  56 import k8s_io_api_core_v1 "k8s.io/api/core/v1"
  57
  58 import strings "strings"
  59 import reflect "reflect"
  60
  61 import io "io"
  62
  63 // Reference imports to suppress errors if they are not otherwise used.
  64 var _ = proto.Marshal
  65 var _ = fmt.Errorf
  66 var _ = math.Inf
  67
  68 // This is a compile-time assertion to ensure that this generated file
  69 // is compatible with the proto package it is being compiled against.
  70 // A compilation error at this line likely means your copy of the
  71 // proto package needs to be updated.
  72 const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
  73
  74 func (m *CrossVersionObjectReference) Reset()      { *m = CrossVersionObjectReference{} }
  75 func (*CrossVersionObjectReference) ProtoMessage() {}
  76 func (*CrossVersionObjectReference) Descriptor() ([]byte, []int) {
  77         return fileDescriptorGenerated, []int{0}
  78 }
  79
  80 func (m *ExternalMetricSource) Reset()                    { *m = ExternalMetricSource{} }
  81 func (*ExternalMetricSource) ProtoMessage()               {}
  82 func (*ExternalMetricSource) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{1} }
  83
  84 func (m *ExternalMetricStatus) Reset()                    { *m = ExternalMetricStatus{} }
  85 func (*ExternalMetricStatus) ProtoMessage()               {}
  86 func (*ExternalMetricStatus) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{2} }
  87
  88 func (m *HorizontalPodAutoscaler) Reset()                    { *m = HorizontalPodAutoscaler{} }
  89 func (*HorizontalPodAutoscaler) ProtoMessage()               {}
  90 func (*HorizontalPodAutoscaler) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{3} }
  91
  92 func (m *HorizontalPodAutoscalerCondition) Reset()      { *m = HorizontalPodAutoscalerCondition{} }
  93 func (*HorizontalPodAutoscalerCondition) ProtoMessage() {}
  94 func (*HorizontalPodAutoscalerCondition) Descriptor() ([]byte, []int) {
  95         return fileDescriptorGenerated, []int{4}
  96 }
  97
  98 func (m *HorizontalPodAutoscalerList) Reset()      { *m = HorizontalPodAutoscalerList{} }
  99 func (*HorizontalPodAutoscalerList) ProtoMessage() {}
 100 func (*HorizontalPodAutoscalerList) Descriptor() ([]byte, []int) {
 101         return fileDescriptorGenerated, []int{5}
 102 }
 103
 104 func (m *HorizontalPodAutoscalerSpec) Reset()      { *m = HorizontalPodAutoscalerSpec{} }
 105 func (*HorizontalPodAutoscalerSpec) ProtoMessage() {}
 106 func (*HorizontalPodAutoscalerSpec) Descriptor() ([]byte, []int) {
 107         return fileDescriptorGenerated, []int{6}
 108 }
 109
 110 func (m *HorizontalPodAutoscalerStatus) Reset()      { *m = HorizontalPodAutoscalerStatus{} }
 111 func (*HorizontalPodAutoscalerStatus) ProtoMessage() {}
 112 func (*HorizontalPodAutoscalerStatus) Descriptor() ([]byte, []int) {
 113         return fileDescriptorGenerated, []int{7}
 114 }
 115
 116 func (m *MetricSpec) Reset()                    { *m = MetricSpec{} }
 117 func (*MetricSpec) ProtoMessage()               {}
 118 func (*MetricSpec) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{8} }
 119
 120 func (m *MetricStatus) Reset()                    { *m = MetricStatus{} }
 121 func (*MetricStatus) ProtoMessage()               {}
 122 func (*MetricStatus) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{9} }
 123
 124 func (m *ObjectMetricSource) Reset()                    { *m = ObjectMetricSource{} }
 125 func (*ObjectMetricSource) ProtoMessage()               {}
 126 func (*ObjectMetricSource) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{10} }
 127
 128 func (m *ObjectMetricStatus) Reset()                    { *m = ObjectMetricStatus{} }
 129 func (*ObjectMetricStatus) ProtoMessage()               {}
 130 func (*ObjectMetricStatus) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{11} }
 131
 132 func (m *PodsMetricSource) Reset()                    { *m = PodsMetricSource{} }
 133 func (*PodsMetricSource) ProtoMessage()               {}
 134 func (*PodsMetricSource) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{12} }
 135
 136 func (m *PodsMetricStatus) Reset()                    { *m = PodsMetricStatus{} }
 137 func (*PodsMetricStatus) ProtoMessage()               {}
 138 func (*PodsMetricStatus) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{13} }
 139
 140 func (m *ResourceMetricSource) Reset()                    { *m = ResourceMetricSource{} }
 141 func (*ResourceMetricSource) ProtoMessage()               {}
 142 func (*ResourceMetricSource) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{14} }
 143
 144 func (m *ResourceMetricStatus) Reset()                    { *m = ResourceMetricStatus{} }
 145 func (*ResourceMetricStatus) ProtoMessage()               {}
 146 func (*ResourceMetricStatus) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{15} }
 147
 148 func (m *Scale) Reset()                    { *m = Scale{} }
 149 func (*Scale) ProtoMessage()               {}
 150 func (*Scale) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{16} }
 151
 152 func (m *ScaleSpec) Reset()                    { *m = ScaleSpec{} }
 153 func (*ScaleSpec) ProtoMessage()               {}
 154 func (*ScaleSpec) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{17} }
 155
 156 func (m *ScaleStatus) Reset()                    { *m = ScaleStatus{} }
 157 func (*ScaleStatus) ProtoMessage()               {}
 158 func (*ScaleStatus) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{18} }
 159
 160 func init() {
 161         proto.RegisterType((*CrossVersionObjectReference)(nil), "k8s.io.api.autoscaling.v1.CrossVersionObjectReference")
 162         proto.RegisterType((*ExternalMetricSource)(nil), "k8s.io.api.autoscaling.v1.ExternalMetricSource")
 163         proto.RegisterType((*ExternalMetricStatus)(nil), "k8s.io.api.autoscaling.v1.ExternalMetricStatus")
 164         proto.RegisterType((*HorizontalPodAutoscaler)(nil), "k8s.io.api.autoscaling.v1.HorizontalPodAutoscaler")
 165         proto.RegisterType((*HorizontalPodAutoscalerCondition)(nil), "k8s.io.api.autoscaling.v1.HorizontalPodAutoscalerCondition")
 166         proto.RegisterType((*HorizontalPodAutoscalerList)(nil), "k8s.io.api.autoscaling.v1.HorizontalPodAutoscalerList")
 167         proto.RegisterType((*HorizontalPodAutoscalerSpec)(nil), "k8s.io.api.autoscaling.v1.HorizontalPodAutoscalerSpec")
 168         proto.RegisterType((*HorizontalPodAutoscalerStatus)(nil), "k8s.io.api.autoscaling.v1.HorizontalPodAutoscalerStatus")
 169         proto.RegisterType((*MetricSpec)(nil), "k8s.io.api.autoscaling.v1.MetricSpec")
 170         proto.RegisterType((*MetricStatus)(nil), "k8s.io.api.autoscaling.v1.MetricStatus")
 171         proto.RegisterType((*ObjectMetricSource)(nil), "k8s.io.api.autoscaling.v1.ObjectMetricSource")
 172         proto.RegisterType((*ObjectMetricStatus)(nil), "k8s.io.api.autoscaling.v1.ObjectMetricStatus")
 173         proto.RegisterType((*PodsMetricSource)(nil), "k8s.io.api.autoscaling.v1.PodsMetricSource")
 174         proto.RegisterType((*PodsMetricStatus)(nil), "k8s.io.api.autoscaling.v1.PodsMetricStatus")
 175         proto.RegisterType((*ResourceMetricSource)(nil), "k8s.io.api.autoscaling.v1.ResourceMetricSource")
 176         proto.RegisterType((*ResourceMetricStatus)(nil), "k8s.io.api.autoscaling.v1.ResourceMetricStatus")
 177         proto.RegisterType((*Scale)(nil), "k8s.io.api.autoscaling.v1.Scale")
 178         proto.RegisterType((*ScaleSpec)(nil), "k8s.io.api.autoscaling.v1.ScaleSpec")
 179         proto.RegisterType((*ScaleStatus)(nil), "k8s.io.api.autoscaling.v1.ScaleStatus")
 180 }
 181 func (m *CrossVersionObjectReference) Marshal() (dAtA []byte, err error) {
 182         size := m.Size()
 183         dAtA = make([]byte, size)
 184         n, err := m.MarshalTo(dAtA)
 185         if err != nil {
 186                 return nil, err
 187         }
 188         return dAtA[:n], nil
 189 }
 190
 191 func (m *CrossVersionObjectReference) MarshalTo(dAtA []byte) (int, error) {
 192         var i int
 193         _ = i
 194         var l int
 195         _ = l
 196         dAtA[i] = 0xa
 197         i++
 198         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Kind)))
 199         i += copy(dAtA[i:], m.Kind)
 200         dAtA[i] = 0x12
 201         i++
 202         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
 203         i += copy(dAtA[i:], m.Name)
 204         dAtA[i] = 0x1a
 205         i++
 206         i = encodeVarintGenerated(dAtA, i, uint64(len(m.APIVersion)))
 207         i += copy(dAtA[i:], m.APIVersion)
 208         return i, nil
 209 }
 210
 211 func (m *ExternalMetricSource) Marshal() (dAtA []byte, err error) {
 212         size := m.Size()
 213         dAtA = make([]byte, size)
 214         n, err := m.MarshalTo(dAtA)
 215         if err != nil {
 216                 return nil, err
 217         }
 218         return dAtA[:n], nil
 219 }
 220
 221 func (m *ExternalMetricSource) MarshalTo(dAtA []byte) (int, error) {
 222         var i int
 223         _ = i
 224         var l int
 225         _ = l
 226         dAtA[i] = 0xa
 227         i++
 228         i = encodeVarintGenerated(dAtA, i, uint64(len(m.MetricName)))
 229         i += copy(dAtA[i:], m.MetricName)
 230         if m.MetricSelector != nil {
 231                 dAtA[i] = 0x12
 232                 i++
 233                 i = encodeVarintGenerated(dAtA, i, uint64(m.MetricSelector.Size()))
 234                 n1, err := m.MetricSelector.MarshalTo(dAtA[i:])
 235                 if err != nil {
 236                         return 0, err
 237                 }
 238                 i += n1
 239         }
 240         if m.TargetValue != nil {
 241                 dAtA[i] = 0x1a
 242                 i++
 243                 i = encodeVarintGenerated(dAtA, i, uint64(m.TargetValue.Size()))
 244                 n2, err := m.TargetValue.MarshalTo(dAtA[i:])
 245                 if err != nil {
 246                         return 0, err
 247                 }
 248                 i += n2
 249         }
 250         if m.TargetAverageValue != nil {
 251                 dAtA[i] = 0x22
 252                 i++
 253                 i = encodeVarintGenerated(dAtA, i, uint64(m.TargetAverageValue.Size()))
 254                 n3, err := m.TargetAverageValue.MarshalTo(dAtA[i:])
 255                 if err != nil {
 256                         return 0, err
 257                 }
 258                 i += n3
 259         }
 260         return i, nil
 261 }
 262
 263 func (m *ExternalMetricStatus) Marshal() (dAtA []byte, err error) {
 264         size := m.Size()
 265         dAtA = make([]byte, size)
 266         n, err := m.MarshalTo(dAtA)
 267         if err != nil {
 268                 return nil, err
 269         }
 270         return dAtA[:n], nil
 271 }
 272
 273 func (m *ExternalMetricStatus) MarshalTo(dAtA []byte) (int, error) {
 274         var i int
 275         _ = i
 276         var l int
 277         _ = l
 278         dAtA[i] = 0xa
 279         i++
 280         i = encodeVarintGenerated(dAtA, i, uint64(len(m.MetricName)))
 281         i += copy(dAtA[i:], m.MetricName)
 282         if m.MetricSelector != nil {
 283                 dAtA[i] = 0x12
 284                 i++
 285                 i = encodeVarintGenerated(dAtA, i, uint64(m.MetricSelector.Size()))
 286                 n4, err := m.MetricSelector.MarshalTo(dAtA[i:])
 287                 if err != nil {
 288                         return 0, err
 289                 }
 290                 i += n4
 291         }
 292         dAtA[i] = 0x1a
 293         i++
 294         i = encodeVarintGenerated(dAtA, i, uint64(m.CurrentValue.Size()))
 295         n5, err := m.CurrentValue.MarshalTo(dAtA[i:])
 296         if err != nil {
 297                 return 0, err
 298         }
 299         i += n5
 300         if m.CurrentAverageValue != nil {
 301                 dAtA[i] = 0x22
 302                 i++
 303                 i = encodeVarintGenerated(dAtA, i, uint64(m.CurrentAverageValue.Size()))
 304                 n6, err := m.CurrentAverageValue.MarshalTo(dAtA[i:])
 305                 if err != nil {
 306                         return 0, err
 307                 }
 308                 i += n6
 309         }
 310         return i, nil
 311 }
 312
 313 func (m *HorizontalPodAutoscaler) Marshal() (dAtA []byte, err error) {
 314         size := m.Size()
 315         dAtA = make([]byte, size)
 316         n, err := m.MarshalTo(dAtA)
 317         if err != nil {
 318                 return nil, err
 319         }
 320         return dAtA[:n], nil
 321 }
 322
 323 func (m *HorizontalPodAutoscaler) MarshalTo(dAtA []byte) (int, error) {
 324         var i int
 325         _ = i
 326         var l int
 327         _ = l
 328         dAtA[i] = 0xa
 329         i++
 330         i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size()))
 331         n7, err := m.ObjectMeta.MarshalTo(dAtA[i:])
 332         if err != nil {
 333                 return 0, err
 334         }
 335         i += n7
 336         dAtA[i] = 0x12
 337         i++
 338         i = encodeVarintGenerated(dAtA, i, uint64(m.Spec.Size()))
 339         n8, err := m.Spec.MarshalTo(dAtA[i:])
 340         if err != nil {
 341                 return 0, err
 342         }
 343         i += n8
 344         dAtA[i] = 0x1a
 345         i++
 346         i = encodeVarintGenerated(dAtA, i, uint64(m.Status.Size()))
 347         n9, err := m.Status.MarshalTo(dAtA[i:])
 348         if err != nil {
 349                 return 0, err
 350         }
 351         i += n9
 352         return i, nil
 353 }
 354
 355 func (m *HorizontalPodAutoscalerCondition) Marshal() (dAtA []byte, err error) {
 356         size := m.Size()
 357         dAtA = make([]byte, size)
 358         n, err := m.MarshalTo(dAtA)
 359         if err != nil {
 360                 return nil, err
 361         }
 362         return dAtA[:n], nil
 363 }
 364
 365 func (m *HorizontalPodAutoscalerCondition) MarshalTo(dAtA []byte) (int, error) {
 366         var i int
 367         _ = i
 368         var l int
 369         _ = l
 370         dAtA[i] = 0xa
 371         i++
 372         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
 373         i += copy(dAtA[i:], m.Type)
 374         dAtA[i] = 0x12
 375         i++
 376         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Status)))
 377         i += copy(dAtA[i:], m.Status)
 378         dAtA[i] = 0x1a
 379         i++
 380         i = encodeVarintGenerated(dAtA, i, uint64(m.LastTransitionTime.Size()))
 381         n10, err := m.LastTransitionTime.MarshalTo(dAtA[i:])
 382         if err != nil {
 383                 return 0, err
 384         }
 385         i += n10
 386         dAtA[i] = 0x22
 387         i++
 388         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Reason)))
 389         i += copy(dAtA[i:], m.Reason)
 390         dAtA[i] = 0x2a
 391         i++
 392         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message)))
 393         i += copy(dAtA[i:], m.Message)
 394         return i, nil
 395 }
 396
 397 func (m *HorizontalPodAutoscalerList) Marshal() (dAtA []byte, err error) {
 398         size := m.Size()
 399         dAtA = make([]byte, size)
 400         n, err := m.MarshalTo(dAtA)
 401         if err != nil {
 402                 return nil, err
 403         }
 404         return dAtA[:n], nil
 405 }
 406
 407 func (m *HorizontalPodAutoscalerList) MarshalTo(dAtA []byte) (int, error) {
 408         var i int
 409         _ = i
 410         var l int
 411         _ = l
 412         dAtA[i] = 0xa
 413         i++
 414         i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size()))
 415         n11, err := m.ListMeta.MarshalTo(dAtA[i:])
 416         if err != nil {
 417                 return 0, err
 418         }
 419         i += n11
 420         if len(m.Items) > 0 {
 421                 for _, msg := range m.Items {
 422                         dAtA[i] = 0x12
 423                         i++
 424                         i = encodeVarintGenerated(dAtA, i, uint64(msg.Size()))
 425                         n, err := msg.MarshalTo(dAtA[i:])
 426                         if err != nil {
 427                                 return 0, err
 428                         }
 429                         i += n
 430                 }
 431         }
 432         return i, nil
 433 }
 434
 435 func (m *HorizontalPodAutoscalerSpec) Marshal() (dAtA []byte, err error) {
 436         size := m.Size()
 437         dAtA = make([]byte, size)
 438         n, err := m.MarshalTo(dAtA)
 439         if err != nil {
 440                 return nil, err
 441         }
 442         return dAtA[:n], nil
 443 }
 444
 445 func (m *HorizontalPodAutoscalerSpec) MarshalTo(dAtA []byte) (int, error) {
 446         var i int
 447         _ = i
 448         var l int
 449         _ = l
 450         dAtA[i] = 0xa
 451         i++
 452         i = encodeVarintGenerated(dAtA, i, uint64(m.ScaleTargetRef.Size()))
 453         n12, err := m.ScaleTargetRef.MarshalTo(dAtA[i:])
 454         if err != nil {
 455                 return 0, err
 456         }
 457         i += n12
 458         if m.MinReplicas != nil {
 459                 dAtA[i] = 0x10
 460                 i++
 461                 i = encodeVarintGenerated(dAtA, i, uint64(*m.MinReplicas))
 462         }
 463         dAtA[i] = 0x18
 464         i++
 465         i = encodeVarintGenerated(dAtA, i, uint64(m.MaxReplicas))
 466         if m.TargetCPUUtilizationPercentage != nil {
 467                 dAtA[i] = 0x20
 468                 i++
 469                 i = encodeVarintGenerated(dAtA, i, uint64(*m.TargetCPUUtilizationPercentage))
 470         }
 471         return i, nil
 472 }
 473
 474 func (m *HorizontalPodAutoscalerStatus) Marshal() (dAtA []byte, err error) {
 475         size := m.Size()
 476         dAtA = make([]byte, size)
 477         n, err := m.MarshalTo(dAtA)
 478         if err != nil {
 479                 return nil, err
 480         }
 481         return dAtA[:n], nil
 482 }
 483
 484 func (m *HorizontalPodAutoscalerStatus) MarshalTo(dAtA []byte) (int, error) {
 485         var i int
 486         _ = i
 487         var l int
 488         _ = l
 489         if m.ObservedGeneration != nil {
 490                 dAtA[i] = 0x8
 491                 i++
 492                 i = encodeVarintGenerated(dAtA, i, uint64(*m.ObservedGeneration))
 493         }
 494         if m.LastScaleTime != nil {
 495                 dAtA[i] = 0x12
 496                 i++
 497                 i = encodeVarintGenerated(dAtA, i, uint64(m.LastScaleTime.Size()))
 498                 n13, err := m.LastScaleTime.MarshalTo(dAtA[i:])
 499                 if err != nil {
 500                         return 0, err
 501                 }
 502                 i += n13
 503         }
 504         dAtA[i] = 0x18
 505         i++
 506         i = encodeVarintGenerated(dAtA, i, uint64(m.CurrentReplicas))
 507         dAtA[i] = 0x20
 508         i++
 509         i = encodeVarintGenerated(dAtA, i, uint64(m.DesiredReplicas))
 510         if m.CurrentCPUUtilizationPercentage != nil {
 511                 dAtA[i] = 0x28
 512                 i++
 513                 i = encodeVarintGenerated(dAtA, i, uint64(*m.CurrentCPUUtilizationPercentage))
 514         }
 515         return i, nil
 516 }
 517
 518 func (m *MetricSpec) Marshal() (dAtA []byte, err error) {
 519         size := m.Size()
 520         dAtA = make([]byte, size)
 521         n, err := m.MarshalTo(dAtA)
 522         if err != nil {
 523                 return nil, err
 524         }
 525         return dAtA[:n], nil
 526 }
 527
 528 func (m *MetricSpec) MarshalTo(dAtA []byte) (int, error) {
 529         var i int
 530         _ = i
 531         var l int
 532         _ = l
 533         dAtA[i] = 0xa
 534         i++
 535         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
 536         i += copy(dAtA[i:], m.Type)
 537         if m.Object != nil {
 538                 dAtA[i] = 0x12
 539                 i++
 540                 i = encodeVarintGenerated(dAtA, i, uint64(m.Object.Size()))
 541                 n14, err := m.Object.MarshalTo(dAtA[i:])
 542                 if err != nil {
 543                         return 0, err
 544                 }
 545                 i += n14
 546         }
 547         if m.Pods != nil {
 548                 dAtA[i] = 0x1a
 549                 i++
 550                 i = encodeVarintGenerated(dAtA, i, uint64(m.Pods.Size()))
 551                 n15, err := m.Pods.MarshalTo(dAtA[i:])
 552                 if err != nil {
 553                         return 0, err
 554                 }
 555                 i += n15
 556         }
 557         if m.Resource != nil {
 558                 dAtA[i] = 0x22
 559                 i++
 560                 i = encodeVarintGenerated(dAtA, i, uint64(m.Resource.Size()))
 561                 n16, err := m.Resource.MarshalTo(dAtA[i:])
 562                 if err != nil {
 563                         return 0, err
 564                 }
 565                 i += n16
 566         }
 567         if m.External != nil {
 568                 dAtA[i] = 0x2a
 569                 i++
 570                 i = encodeVarintGenerated(dAtA, i, uint64(m.External.Size()))
 571                 n17, err := m.External.MarshalTo(dAtA[i:])
 572                 if err != nil {
 573                         return 0, err
 574                 }
 575                 i += n17
 576         }
 577         return i, nil
 578 }
 579
 580 func (m *MetricStatus) Marshal() (dAtA []byte, err error) {
 581         size := m.Size()
 582         dAtA = make([]byte, size)
 583         n, err := m.MarshalTo(dAtA)
 584         if err != nil {
 585                 return nil, err
 586         }
 587         return dAtA[:n], nil
 588 }
 589
 590 func (m *MetricStatus) MarshalTo(dAtA []byte) (int, error) {
 591         var i int
 592         _ = i
 593         var l int
 594         _ = l
 595         dAtA[i] = 0xa
 596         i++
 597         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
 598         i += copy(dAtA[i:], m.Type)
 599         if m.Object != nil {
 600                 dAtA[i] = 0x12
 601                 i++
 602                 i = encodeVarintGenerated(dAtA, i, uint64(m.Object.Size()))
 603                 n18, err := m.Object.MarshalTo(dAtA[i:])
 604                 if err != nil {
 605                         return 0, err
 606                 }
 607                 i += n18
 608         }
 609         if m.Pods != nil {
 610                 dAtA[i] = 0x1a
 611                 i++
 612                 i = encodeVarintGenerated(dAtA, i, uint64(m.Pods.Size()))
 613                 n19, err := m.Pods.MarshalTo(dAtA[i:])
 614                 if err != nil {
 615                         return 0, err
 616                 }
 617                 i += n19
 618         }
 619         if m.Resource != nil {
 620                 dAtA[i] = 0x22
 621                 i++
 622                 i = encodeVarintGenerated(dAtA, i, uint64(m.Resource.Size()))
 623                 n20, err := m.Resource.MarshalTo(dAtA[i:])
 624                 if err != nil {
 625                         return 0, err
 626                 }
 627                 i += n20
 628         }
 629         if m.External != nil {
 630                 dAtA[i] = 0x2a
 631                 i++
 632                 i = encodeVarintGenerated(dAtA, i, uint64(m.External.Size()))
 633                 n21, err := m.External.MarshalTo(dAtA[i:])
 634                 if err != nil {
 635                         return 0, err
 636                 }
 637                 i += n21
 638         }
 639         return i, nil
 640 }
 641
 642 func (m *ObjectMetricSource) Marshal() (dAtA []byte, err error) {
 643         size := m.Size()
 644         dAtA = make([]byte, size)
 645         n, err := m.MarshalTo(dAtA)
 646         if err != nil {
 647                 return nil, err
 648         }
 649         return dAtA[:n], nil
 650 }
 651
 652 func (m *ObjectMetricSource) MarshalTo(dAtA []byte) (int, error) {
 653         var i int
 654         _ = i
 655         var l int
 656         _ = l
 657         dAtA[i] = 0xa
 658         i++
 659         i = encodeVarintGenerated(dAtA, i, uint64(m.Target.Size()))
 660         n22, err := m.Target.MarshalTo(dAtA[i:])
 661         if err != nil {
 662                 return 0, err
 663         }
 664         i += n22
 665         dAtA[i] = 0x12
 666         i++
 667         i = encodeVarintGenerated(dAtA, i, uint64(len(m.MetricName)))
 668         i += copy(dAtA[i:], m.MetricName)
 669         dAtA[i] = 0x1a
 670         i++
 671         i = encodeVarintGenerated(dAtA, i, uint64(m.TargetValue.Size()))
 672         n23, err := m.TargetValue.MarshalTo(dAtA[i:])
 673         if err != nil {
 674                 return 0, err
 675         }
 676         i += n23
 677         if m.Selector != nil {
 678                 dAtA[i] = 0x22
 679                 i++
 680                 i = encodeVarintGenerated(dAtA, i, uint64(m.Selector.Size()))
 681                 n24, err := m.Selector.MarshalTo(dAtA[i:])
 682                 if err != nil {
 683                         return 0, err
 684                 }
 685                 i += n24
 686         }
 687         if m.AverageValue != nil {
 688                 dAtA[i] = 0x2a
 689                 i++
 690                 i = encodeVarintGenerated(dAtA, i, uint64(m.AverageValue.Size()))
 691                 n25, err := m.AverageValue.MarshalTo(dAtA[i:])
 692                 if err != nil {
 693                         return 0, err
 694                 }
 695                 i += n25
 696         }
 697         return i, nil
 698 }
 699
 700 func (m *ObjectMetricStatus) Marshal() (dAtA []byte, err error) {
 701         size := m.Size()
 702         dAtA = make([]byte, size)
 703         n, err := m.MarshalTo(dAtA)
 704         if err != nil {
 705                 return nil, err
 706         }
 707         return dAtA[:n], nil
 708 }
 709
 710 func (m *ObjectMetricStatus) MarshalTo(dAtA []byte) (int, error) {
 711         var i int
 712         _ = i
 713         var l int
 714         _ = l
 715         dAtA[i] = 0xa
 716         i++
 717         i = encodeVarintGenerated(dAtA, i, uint64(m.Target.Size()))
 718         n26, err := m.Target.MarshalTo(dAtA[i:])
 719         if err != nil {
 720                 return 0, err
 721         }
 722         i += n26
 723         dAtA[i] = 0x12
 724         i++
 725         i = encodeVarintGenerated(dAtA, i, uint64(len(m.MetricName)))
 726         i += copy(dAtA[i:], m.MetricName)
 727         dAtA[i] = 0x1a
 728         i++
 729         i = encodeVarintGenerated(dAtA, i, uint64(m.CurrentValue.Size()))
 730         n27, err := m.CurrentValue.MarshalTo(dAtA[i:])
 731         if err != nil {
 732                 return 0, err
 733         }
 734         i += n27
 735         if m.Selector != nil {
 736                 dAtA[i] = 0x22
 737                 i++
 738                 i = encodeVarintGenerated(dAtA, i, uint64(m.Selector.Size()))
 739                 n28, err := m.Selector.MarshalTo(dAtA[i:])
 740                 if err != nil {
 741                         return 0, err
 742                 }
 743                 i += n28
 744         }
 745         if m.AverageValue != nil {
 746                 dAtA[i] = 0x2a
 747                 i++
 748                 i = encodeVarintGenerated(dAtA, i, uint64(m.AverageValue.Size()))
 749                 n29, err := m.AverageValue.MarshalTo(dAtA[i:])
 750                 if err != nil {
 751                         return 0, err
 752                 }
 753                 i += n29
 754         }
 755         return i, nil
 756 }
 757
 758 func (m *PodsMetricSource) Marshal() (dAtA []byte, err error) {
 759         size := m.Size()
 760         dAtA = make([]byte, size)
 761         n, err := m.MarshalTo(dAtA)
 762         if err != nil {
 763                 return nil, err
 764         }
 765         return dAtA[:n], nil
 766 }
 767
 768 func (m *PodsMetricSource) MarshalTo(dAtA []byte) (int, error) {
 769         var i int
 770         _ = i
 771         var l int
 772         _ = l
 773         dAtA[i] = 0xa
 774         i++
 775         i = encodeVarintGenerated(dAtA, i, uint64(len(m.MetricName)))
 776         i += copy(dAtA[i:], m.MetricName)
 777         dAtA[i] = 0x12
 778         i++
 779         i = encodeVarintGenerated(dAtA, i, uint64(m.TargetAverageValue.Size()))
 780         n30, err := m.TargetAverageValue.MarshalTo(dAtA[i:])
 781         if err != nil {
 782                 return 0, err
 783         }
 784         i += n30
 785         if m.Selector != nil {
 786                 dAtA[i] = 0x1a
 787                 i++
 788                 i = encodeVarintGenerated(dAtA, i, uint64(m.Selector.Size()))
 789                 n31, err := m.Selector.MarshalTo(dAtA[i:])
 790                 if err != nil {
 791                         return 0, err
 792                 }
 793                 i += n31
 794         }
 795         return i, nil
 796 }
 797
 798 func (m *PodsMetricStatus) Marshal() (dAtA []byte, err error) {
 799         size := m.Size()
 800         dAtA = make([]byte, size)
 801         n, err := m.MarshalTo(dAtA)
 802         if err != nil {
 803                 return nil, err
 804         }
 805         return dAtA[:n], nil
 806 }
 807
 808 func (m *PodsMetricStatus) MarshalTo(dAtA []byte) (int, error) {
 809         var i int
 810         _ = i
 811         var l int
 812         _ = l
 813         dAtA[i] = 0xa
 814         i++
 815         i = encodeVarintGenerated(dAtA, i, uint64(len(m.MetricName)))
 816         i += copy(dAtA[i:], m.MetricName)
 817         dAtA[i] = 0x12
 818         i++
 819         i = encodeVarintGenerated(dAtA, i, uint64(m.CurrentAverageValue.Size()))
 820         n32, err := m.CurrentAverageValue.MarshalTo(dAtA[i:])
 821         if err != nil {
 822                 return 0, err
 823         }
 824         i += n32
 825         if m.Selector != nil {
 826                 dAtA[i] = 0x1a
 827                 i++
 828                 i = encodeVarintGenerated(dAtA, i, uint64(m.Selector.Size()))
 829                 n33, err := m.Selector.MarshalTo(dAtA[i:])
 830                 if err != nil {
 831                         return 0, err
 832                 }
 833                 i += n33
 834         }
 835         return i, nil
 836 }
 837
 838 func (m *ResourceMetricSource) Marshal() (dAtA []byte, err error) {
 839         size := m.Size()
 840         dAtA = make([]byte, size)
 841         n, err := m.MarshalTo(dAtA)
 842         if err != nil {
 843                 return nil, err
 844         }
 845         return dAtA[:n], nil
 846 }
 847
 848 func (m *ResourceMetricSource) MarshalTo(dAtA []byte) (int, error) {
 849         var i int
 850         _ = i
 851         var l int
 852         _ = l
 853         dAtA[i] = 0xa
 854         i++
 855         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
 856         i += copy(dAtA[i:], m.Name)
 857         if m.TargetAverageUtilization != nil {
 858                 dAtA[i] = 0x10
 859                 i++
 860                 i = encodeVarintGenerated(dAtA, i, uint64(*m.TargetAverageUtilization))
 861         }
 862         if m.TargetAverageValue != nil {
 863                 dAtA[i] = 0x1a
 864                 i++
 865                 i = encodeVarintGenerated(dAtA, i, uint64(m.TargetAverageValue.Size()))
 866                 n34, err := m.TargetAverageValue.MarshalTo(dAtA[i:])
 867                 if err != nil {
 868                         return 0, err
 869                 }
 870                 i += n34
 871         }
 872         return i, nil
 873 }
 874
 875 func (m *ResourceMetricStatus) Marshal() (dAtA []byte, err error) {
 876         size := m.Size()
 877         dAtA = make([]byte, size)
 878         n, err := m.MarshalTo(dAtA)
 879         if err != nil {
 880                 return nil, err
 881         }
 882         return dAtA[:n], nil
 883 }
 884
 885 func (m *ResourceMetricStatus) MarshalTo(dAtA []byte) (int, error) {
 886         var i int
 887         _ = i
 888         var l int
 889         _ = l
 890         dAtA[i] = 0xa
 891         i++
 892         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
 893         i += copy(dAtA[i:], m.Name)
 894         if m.CurrentAverageUtilization != nil {
 895                 dAtA[i] = 0x10
 896                 i++
 897                 i = encodeVarintGenerated(dAtA, i, uint64(*m.CurrentAverageUtilization))
 898         }
 899         dAtA[i] = 0x1a
 900         i++
 901         i = encodeVarintGenerated(dAtA, i, uint64(m.CurrentAverageValue.Size()))
 902         n35, err := m.CurrentAverageValue.MarshalTo(dAtA[i:])
 903         if err != nil {
 904                 return 0, err
 905         }
 906         i += n35
 907         return i, nil
 908 }
 909
 910 func (m *Scale) Marshal() (dAtA []byte, err error) {
 911         size := m.Size()
 912         dAtA = make([]byte, size)
 913         n, err := m.MarshalTo(dAtA)
 914         if err != nil {
 915                 return nil, err
 916         }
 917         return dAtA[:n], nil
 918 }
 919
 920 func (m *Scale) MarshalTo(dAtA []byte) (int, error) {
 921         var i int
 922         _ = i
 923         var l int
 924         _ = l
 925         dAtA[i] = 0xa
 926         i++
 927         i = encodeVarintGenerated(dAtA, i, uint64(m.ObjectMeta.Size()))
 928         n36, err := m.ObjectMeta.MarshalTo(dAtA[i:])
 929         if err != nil {
 930                 return 0, err
 931         }
 932         i += n36
 933         dAtA[i] = 0x12
 934         i++
 935         i = encodeVarintGenerated(dAtA, i, uint64(m.Spec.Size()))
 936         n37, err := m.Spec.MarshalTo(dAtA[i:])
 937         if err != nil {
 938                 return 0, err
 939         }
 940         i += n37
 941         dAtA[i] = 0x1a
 942         i++
 943         i = encodeVarintGenerated(dAtA, i, uint64(m.Status.Size()))
 944         n38, err := m.Status.MarshalTo(dAtA[i:])
 945         if err != nil {
 946                 return 0, err
 947         }
 948         i += n38
 949         return i, nil
 950 }
 951
 952 func (m *ScaleSpec) Marshal() (dAtA []byte, err error) {
 953         size := m.Size()
 954         dAtA = make([]byte, size)
 955         n, err := m.MarshalTo(dAtA)
 956         if err != nil {
 957                 return nil, err
 958         }
 959         return dAtA[:n], nil
 960 }
 961
 962 func (m *ScaleSpec) MarshalTo(dAtA []byte) (int, error) {
 963         var i int
 964         _ = i
 965         var l int
 966         _ = l
 967         dAtA[i] = 0x8
 968         i++
 969         i = encodeVarintGenerated(dAtA, i, uint64(m.Replicas))
 970         return i, nil
 971 }
 972
 973 func (m *ScaleStatus) Marshal() (dAtA []byte, err error) {
 974         size := m.Size()
 975         dAtA = make([]byte, size)
 976         n, err := m.MarshalTo(dAtA)
 977         if err != nil {
 978                 return nil, err
 979         }
 980         return dAtA[:n], nil
 981 }
 982
 983 func (m *ScaleStatus) MarshalTo(dAtA []byte) (int, error) {
 984         var i int
 985         _ = i
 986         var l int
 987         _ = l
 988         dAtA[i] = 0x8
 989         i++
 990         i = encodeVarintGenerated(dAtA, i, uint64(m.Replicas))
 991         dAtA[i] = 0x12
 992         i++
 993         i = encodeVarintGenerated(dAtA, i, uint64(len(m.Selector)))
 994         i += copy(dAtA[i:], m.Selector)
 995         return i, nil
 996 }
 997
 998 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
 999         for v >= 1<<7 {
1000                 dAtA[offset] = uint8(v&0x7f | 0x80)
1001                 v >>= 7
1002                 offset++
1003         }
1004         dAtA[offset] = uint8(v)
1005         return offset + 1
1006 }
1007 func (m *CrossVersionObjectReference) Size() (n int) {
1008         var l int
1009         _ = l
1010         l = len(m.Kind)
1011         n += 1 + l + sovGenerated(uint64(l))
1012         l = len(m.Name)
1013         n += 1 + l + sovGenerated(uint64(l))
1014         l = len(m.APIVersion)
1015         n += 1 + l + sovGenerated(uint64(l))
1016         return n
1017 }
1018
1019 func (m *ExternalMetricSource) Size() (n int) {
1020         var l int
1021         _ = l
1022         l = len(m.MetricName)
1023         n += 1 + l + sovGenerated(uint64(l))
1024         if m.MetricSelector != nil {
1025                 l = m.MetricSelector.Size()
1026                 n += 1 + l + sovGenerated(uint64(l))
1027         }
1028         if m.TargetValue != nil {
1029                 l = m.TargetValue.Size()
1030                 n += 1 + l + sovGenerated(uint64(l))
1031         }
1032         if m.TargetAverageValue != nil {
1033                 l = m.TargetAverageValue.Size()
1034                 n += 1 + l + sovGenerated(uint64(l))
1035         }
1036         return n
1037 }
1038
1039 func (m *ExternalMetricStatus) Size() (n int) {
1040         var l int
1041         _ = l
1042         l = len(m.MetricName)
1043         n += 1 + l + sovGenerated(uint64(l))
1044         if m.MetricSelector != nil {
1045                 l = m.MetricSelector.Size()
1046                 n += 1 + l + sovGenerated(uint64(l))
1047         }
1048         l = m.CurrentValue.Size()
1049         n += 1 + l + sovGenerated(uint64(l))
1050         if m.CurrentAverageValue != nil {
1051                 l = m.CurrentAverageValue.Size()
1052                 n += 1 + l + sovGenerated(uint64(l))
1053         }
1054         return n
1055 }
1056
1057 func (m *HorizontalPodAutoscaler) Size() (n int) {
1058         var l int
1059         _ = l
1060         l = m.ObjectMeta.Size()
1061         n += 1 + l + sovGenerated(uint64(l))
1062         l = m.Spec.Size()
1063         n += 1 + l + sovGenerated(uint64(l))
1064         l = m.Status.Size()
1065         n += 1 + l + sovGenerated(uint64(l))
1066         return n
1067 }
1068
1069 func (m *HorizontalPodAutoscalerCondition) Size() (n int) {
1070         var l int
1071         _ = l
1072         l = len(m.Type)
1073         n += 1 + l + sovGenerated(uint64(l))
1074         l = len(m.Status)
1075         n += 1 + l + sovGenerated(uint64(l))
1076         l = m.LastTransitionTime.Size()
1077         n += 1 + l + sovGenerated(uint64(l))
1078         l = len(m.Reason)
1079         n += 1 + l + sovGenerated(uint64(l))
1080         l = len(m.Message)
1081         n += 1 + l + sovGenerated(uint64(l))
1082         return n
1083 }
1084
1085 func (m *HorizontalPodAutoscalerList) Size() (n int) {
1086         var l int
1087         _ = l
1088         l = m.ListMeta.Size()
1089         n += 1 + l + sovGenerated(uint64(l))
1090         if len(m.Items) > 0 {
1091                 for _, e := range m.Items {
1092                         l = e.Size()
1093                         n += 1 + l + sovGenerated(uint64(l))
1094                 }
1095         }
1096         return n
1097 }
1098
1099 func (m *HorizontalPodAutoscalerSpec) Size() (n int) {
1100         var l int
1101         _ = l
1102         l = m.ScaleTargetRef.Size()
1103         n += 1 + l + sovGenerated(uint64(l))
1104         if m.MinReplicas != nil {
1105                 n += 1 + sovGenerated(uint64(*m.MinReplicas))
1106         }
1107         n += 1 + sovGenerated(uint64(m.MaxReplicas))
1108         if m.TargetCPUUtilizationPercentage != nil {
1109                 n += 1 + sovGenerated(uint64(*m.TargetCPUUtilizationPercentage))
1110         }
1111         return n
1112 }
1113
1114 func (m *HorizontalPodAutoscalerStatus) Size() (n int) {
1115         var l int
1116         _ = l
1117         if m.ObservedGeneration != nil {
1118                 n += 1 + sovGenerated(uint64(*m.ObservedGeneration))
1119         }
1120         if m.LastScaleTime != nil {
1121                 l = m.LastScaleTime.Size()
1122                 n += 1 + l + sovGenerated(uint64(l))
1123         }
1124         n += 1 + sovGenerated(uint64(m.CurrentReplicas))
1125         n += 1 + sovGenerated(uint64(m.DesiredReplicas))
1126         if m.CurrentCPUUtilizationPercentage != nil {
1127                 n += 1 + sovGenerated(uint64(*m.CurrentCPUUtilizationPercentage))
1128         }
1129         return n
1130 }
1131
1132 func (m *MetricSpec) Size() (n int) {
1133         var l int
1134         _ = l
1135         l = len(m.Type)
1136         n += 1 + l + sovGenerated(uint64(l))
1137         if m.Object != nil {
1138                 l = m.Object.Size()
1139                 n += 1 + l + sovGenerated(uint64(l))
1140         }
1141         if m.Pods != nil {
1142                 l = m.Pods.Size()
1143                 n += 1 + l + sovGenerated(uint64(l))
1144         }
1145         if m.Resource != nil {
1146                 l = m.Resource.Size()
1147                 n += 1 + l + sovGenerated(uint64(l))
1148         }
1149         if m.External != nil {
1150                 l = m.External.Size()
1151                 n += 1 + l + sovGenerated(uint64(l))
1152         }
1153         return n
1154 }
1155
1156 func (m *MetricStatus) Size() (n int) {
1157         var l int
1158         _ = l
1159         l = len(m.Type)
1160         n += 1 + l + sovGenerated(uint64(l))
1161         if m.Object != nil {
1162                 l = m.Object.Size()
1163                 n += 1 + l + sovGenerated(uint64(l))
1164         }
1165         if m.Pods != nil {
1166                 l = m.Pods.Size()
1167                 n += 1 + l + sovGenerated(uint64(l))
1168         }
1169         if m.Resource != nil {
1170                 l = m.Resource.Size()
1171                 n += 1 + l + sovGenerated(uint64(l))
1172         }
1173         if m.External != nil {
1174                 l = m.External.Size()
1175                 n += 1 + l + sovGenerated(uint64(l))
1176         }
1177         return n
1178 }
1179
1180 func (m *ObjectMetricSource) Size() (n int) {
1181         var l int
1182         _ = l
1183         l = m.Target.Size()
1184         n += 1 + l + sovGenerated(uint64(l))
1185         l = len(m.MetricName)
1186         n += 1 + l + sovGenerated(uint64(l))
1187         l = m.TargetValue.Size()
1188         n += 1 + l + sovGenerated(uint64(l))
1189         if m.Selector != nil {
1190                 l = m.Selector.Size()
1191                 n += 1 + l + sovGenerated(uint64(l))
1192         }
1193         if m.AverageValue != nil {
1194                 l = m.AverageValue.Size()
1195                 n += 1 + l + sovGenerated(uint64(l))
1196         }
1197         return n
1198 }
1199
1200 func (m *ObjectMetricStatus) Size() (n int) {
1201         var l int
1202         _ = l
1203         l = m.Target.Size()
1204         n += 1 + l + sovGenerated(uint64(l))
1205         l = len(m.MetricName)
1206         n += 1 + l + sovGenerated(uint64(l))
1207         l = m.CurrentValue.Size()
1208         n += 1 + l + sovGenerated(uint64(l))
1209         if m.Selector != nil {
1210                 l = m.Selector.Size()
1211                 n += 1 + l + sovGenerated(uint64(l))
1212         }
1213         if m.AverageValue != nil {
1214                 l = m.AverageValue.Size()
1215                 n += 1 + l + sovGenerated(uint64(l))
1216         }
1217         return n
1218 }
1219
1220 func (m *PodsMetricSource) Size() (n int) {
1221         var l int
1222         _ = l
1223         l = len(m.MetricName)
1224         n += 1 + l + sovGenerated(uint64(l))
1225         l = m.TargetAverageValue.Size()
1226         n += 1 + l + sovGenerated(uint64(l))
1227         if m.Selector != nil {
1228                 l = m.Selector.Size()
1229                 n += 1 + l + sovGenerated(uint64(l))
1230         }
1231         return n
1232 }
1233
1234 func (m *PodsMetricStatus) Size() (n int) {
1235         var l int
1236         _ = l
1237         l = len(m.MetricName)
1238         n += 1 + l + sovGenerated(uint64(l))
1239         l = m.CurrentAverageValue.Size()
1240         n += 1 + l + sovGenerated(uint64(l))
1241         if m.Selector != nil {
1242                 l = m.Selector.Size()
1243                 n += 1 + l + sovGenerated(uint64(l))
1244         }
1245         return n
1246 }
1247
1248 func (m *ResourceMetricSource) Size() (n int) {
1249         var l int
1250         _ = l
1251         l = len(m.Name)
1252         n += 1 + l + sovGenerated(uint64(l))
1253         if m.TargetAverageUtilization != nil {
1254                 n += 1 + sovGenerated(uint64(*m.TargetAverageUtilization))
1255         }
1256         if m.TargetAverageValue != nil {
1257                 l = m.TargetAverageValue.Size()
1258                 n += 1 + l + sovGenerated(uint64(l))
1259         }
1260         return n
1261 }
1262
1263 func (m *ResourceMetricStatus) Size() (n int) {
1264         var l int
1265         _ = l
1266         l = len(m.Name)
1267         n += 1 + l + sovGenerated(uint64(l))
1268         if m.CurrentAverageUtilization != nil {
1269                 n += 1 + sovGenerated(uint64(*m.CurrentAverageUtilization))
1270         }
1271         l = m.CurrentAverageValue.Size()
1272         n += 1 + l + sovGenerated(uint64(l))
1273         return n
1274 }
1275
1276 func (m *Scale) Size() (n int) {
1277         var l int
1278         _ = l
1279         l = m.ObjectMeta.Size()
1280         n += 1 + l + sovGenerated(uint64(l))
1281         l = m.Spec.Size()
1282         n += 1 + l + sovGenerated(uint64(l))
1283         l = m.Status.Size()
1284         n += 1 + l + sovGenerated(uint64(l))
1285         return n
1286 }
1287
1288 func (m *ScaleSpec) Size() (n int) {
1289         var l int
1290         _ = l
1291         n += 1 + sovGenerated(uint64(m.Replicas))
1292         return n
1293 }
1294
1295 func (m *ScaleStatus) Size() (n int) {
1296         var l int
1297         _ = l
1298         n += 1 + sovGenerated(uint64(m.Replicas))
1299         l = len(m.Selector)
1300         n += 1 + l + sovGenerated(uint64(l))
1301         return n
1302 }
1303
1304 func sovGenerated(x uint64) (n int) {
1305         for {
1306                 n++
1307                 x >>= 7
1308                 if x == 0 {
1309                         break
1310                 }
1311         }
1312         return n
1313 }
1314 func sozGenerated(x uint64) (n int) {
1315         return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
1316 }
1317 func (this *CrossVersionObjectReference) String() string {
1318         if this == nil {
1319                 return "nil"
1320         }
1321         s := strings.Join([]string{`&CrossVersionObjectReference{`,
1322                 `Kind:` + fmt.Sprintf("%v", this.Kind) + `,`,
1323                 `Name:` + fmt.Sprintf("%v", this.Name) + `,`,
1324                 `APIVersion:` + fmt.Sprintf("%v", this.APIVersion) + `,`,
1325                 `}`,
1326         }, "")
1327         return s
1328 }
1329 func (this *ExternalMetricSource) String() string {
1330         if this == nil {
1331                 return "nil"
1332         }
1333         s := strings.Join([]string{`&ExternalMetricSource{`,
1334                 `MetricName:` + fmt.Sprintf("%v", this.MetricName) + `,`,
1335                 `MetricSelector:` + strings.Replace(fmt.Sprintf("%v", this.MetricSelector), "LabelSelector", "k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector", 1) + `,`,
1336                 `TargetValue:` + strings.Replace(fmt.Sprintf("%v", this.TargetValue), "Quantity", "k8s_io_apimachinery_pkg_api_resource.Quantity", 1) + `,`,
1337                 `TargetAverageValue:` + strings.Replace(fmt.Sprintf("%v", this.TargetAverageValue), "Quantity", "k8s_io_apimachinery_pkg_api_resource.Quantity", 1) + `,`,
1338                 `}`,
1339         }, "")
1340         return s
1341 }
1342 func (this *ExternalMetricStatus) String() string {
1343         if this == nil {
1344                 return "nil"
1345         }
1346         s := strings.Join([]string{`&ExternalMetricStatus{`,
1347                 `MetricName:` + fmt.Sprintf("%v", this.MetricName) + `,`,
1348                 `MetricSelector:` + strings.Replace(fmt.Sprintf("%v", this.MetricSelector), "LabelSelector", "k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector", 1) + `,`,
1349                 `CurrentValue:` + strings.Replace(strings.Replace(this.CurrentValue.String(), "Quantity", "k8s_io_apimachinery_pkg_api_resource.Quantity", 1), `&`, ``, 1) + `,`,
1350                 `CurrentAverageValue:` + strings.Replace(fmt.Sprintf("%v", this.CurrentAverageValue), "Quantity", "k8s_io_apimachinery_pkg_api_resource.Quantity", 1) + `,`,
1351                 `}`,
1352         }, "")
1353         return s
1354 }
1355 func (this *HorizontalPodAutoscaler) String() string {
1356         if this == nil {
1357                 return "nil"
1358         }
1359         s := strings.Join([]string{`&HorizontalPodAutoscaler{`,
1360                 `ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
1361                 `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "HorizontalPodAutoscalerSpec", "HorizontalPodAutoscalerSpec", 1), `&`, ``, 1) + `,`,
1362                 `Status:` + strings.Replace(strings.Replace(this.Status.String(), "HorizontalPodAutoscalerStatus", "HorizontalPodAutoscalerStatus", 1), `&`, ``, 1) + `,`,
1363                 `}`,
1364         }, "")
1365         return s
1366 }
1367 func (this *HorizontalPodAutoscalerCondition) String() string {
1368         if this == nil {
1369                 return "nil"
1370         }
1371         s := strings.Join([]string{`&HorizontalPodAutoscalerCondition{`,
1372                 `Type:` + fmt.Sprintf("%v", this.Type) + `,`,
1373                 `Status:` + fmt.Sprintf("%v", this.Status) + `,`,
1374                 `LastTransitionTime:` + strings.Replace(strings.Replace(this.LastTransitionTime.String(), "Time", "k8s_io_apimachinery_pkg_apis_meta_v1.Time", 1), `&`, ``, 1) + `,`,
1375                 `Reason:` + fmt.Sprintf("%v", this.Reason) + `,`,
1376                 `Message:` + fmt.Sprintf("%v", this.Message) + `,`,
1377                 `}`,
1378         }, "")
1379         return s
1380 }
1381 func (this *HorizontalPodAutoscalerList) String() string {
1382         if this == nil {
1383                 return "nil"
1384         }
1385         s := strings.Join([]string{`&HorizontalPodAutoscalerList{`,
1386                 `ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ListMeta", 1), `&`, ``, 1) + `,`,
1387                 `Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "HorizontalPodAutoscaler", "HorizontalPodAutoscaler", 1), `&`, ``, 1) + `,`,
1388                 `}`,
1389         }, "")
1390         return s
1391 }
1392 func (this *HorizontalPodAutoscalerSpec) String() string {
1393         if this == nil {
1394                 return "nil"
1395         }
1396         s := strings.Join([]string{`&HorizontalPodAutoscalerSpec{`,
1397                 `ScaleTargetRef:` + strings.Replace(strings.Replace(this.ScaleTargetRef.String(), "CrossVersionObjectReference", "CrossVersionObjectReference", 1), `&`, ``, 1) + `,`,
1398                 `MinReplicas:` + valueToStringGenerated(this.MinReplicas) + `,`,
1399                 `MaxReplicas:` + fmt.Sprintf("%v", this.MaxReplicas) + `,`,
1400                 `TargetCPUUtilizationPercentage:` + valueToStringGenerated(this.TargetCPUUtilizationPercentage) + `,`,
1401                 `}`,
1402         }, "")
1403         return s
1404 }
1405 func (this *HorizontalPodAutoscalerStatus) String() string {
1406         if this == nil {
1407                 return "nil"
1408         }
1409         s := strings.Join([]string{`&HorizontalPodAutoscalerStatus{`,
1410                 `ObservedGeneration:` + valueToStringGenerated(this.ObservedGeneration) + `,`,
1411                 `LastScaleTime:` + strings.Replace(fmt.Sprintf("%v", this.LastScaleTime), "Time", "k8s_io_apimachinery_pkg_apis_meta_v1.Time", 1) + `,`,
1412                 `CurrentReplicas:` + fmt.Sprintf("%v", this.CurrentReplicas) + `,`,
1413                 `DesiredReplicas:` + fmt.Sprintf("%v", this.DesiredReplicas) + `,`,
1414                 `CurrentCPUUtilizationPercentage:` + valueToStringGenerated(this.CurrentCPUUtilizationPercentage) + `,`,
1415                 `}`,
1416         }, "")
1417         return s
1418 }
1419 func (this *MetricSpec) String() string {
1420         if this == nil {
1421                 return "nil"
1422         }
1423         s := strings.Join([]string{`&MetricSpec{`,
1424                 `Type:` + fmt.Sprintf("%v", this.Type) + `,`,
1425                 `Object:` + strings.Replace(fmt.Sprintf("%v", this.Object), "ObjectMetricSource", "ObjectMetricSource", 1) + `,`,
1426                 `Pods:` + strings.Replace(fmt.Sprintf("%v", this.Pods), "PodsMetricSource", "PodsMetricSource", 1) + `,`,
1427                 `Resource:` + strings.Replace(fmt.Sprintf("%v", this.Resource), "ResourceMetricSource", "ResourceMetricSource", 1) + `,`,
1428                 `External:` + strings.Replace(fmt.Sprintf("%v", this.External), "ExternalMetricSource", "ExternalMetricSource", 1) + `,`,
1429                 `}`,
1430         }, "")
1431         return s
1432 }
1433 func (this *MetricStatus) String() string {
1434         if this == nil {
1435                 return "nil"
1436         }
1437         s := strings.Join([]string{`&MetricStatus{`,
1438                 `Type:` + fmt.Sprintf("%v", this.Type) + `,`,
1439                 `Object:` + strings.Replace(fmt.Sprintf("%v", this.Object), "ObjectMetricStatus", "ObjectMetricStatus", 1) + `,`,
1440                 `Pods:` + strings.Replace(fmt.Sprintf("%v", this.Pods), "PodsMetricStatus", "PodsMetricStatus", 1) + `,`,
1441                 `Resource:` + strings.Replace(fmt.Sprintf("%v", this.Resource), "ResourceMetricStatus", "ResourceMetricStatus", 1) + `,`,
1442                 `External:` + strings.Replace(fmt.Sprintf("%v", this.External), "ExternalMetricStatus", "ExternalMetricStatus", 1) + `,`,
1443                 `}`,
1444         }, "")
1445         return s
1446 }
1447 func (this *ObjectMetricSource) String() string {
1448         if this == nil {
1449                 return "nil"
1450         }
1451         s := strings.Join([]string{`&ObjectMetricSource{`,
1452                 `Target:` + strings.Replace(strings.Replace(this.Target.String(), "CrossVersionObjectReference", "CrossVersionObjectReference", 1), `&`, ``, 1) + `,`,
1453                 `MetricName:` + fmt.Sprintf("%v", this.MetricName) + `,`,
1454                 `TargetValue:` + strings.Replace(strings.Replace(this.TargetValue.String(), "Quantity", "k8s_io_apimachinery_pkg_api_resource.Quantity", 1), `&`, ``, 1) + `,`,
1455                 `Selector:` + strings.Replace(fmt.Sprintf("%v", this.Selector), "LabelSelector", "k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector", 1) + `,`,
1456                 `AverageValue:` + strings.Replace(fmt.Sprintf("%v", this.AverageValue), "Quantity", "k8s_io_apimachinery_pkg_api_resource.Quantity", 1) + `,`,
1457                 `}`,
1458         }, "")
1459         return s
1460 }
1461 func (this *ObjectMetricStatus) String() string {
1462         if this == nil {
1463                 return "nil"
1464         }
1465         s := strings.Join([]string{`&ObjectMetricStatus{`,
1466                 `Target:` + strings.Replace(strings.Replace(this.Target.String(), "CrossVersionObjectReference", "CrossVersionObjectReference", 1), `&`, ``, 1) + `,`,
1467                 `MetricName:` + fmt.Sprintf("%v", this.MetricName) + `,`,
1468                 `CurrentValue:` + strings.Replace(strings.Replace(this.CurrentValue.String(), "Quantity", "k8s_io_apimachinery_pkg_api_resource.Quantity", 1), `&`, ``, 1) + `,`,
1469                 `Selector:` + strings.Replace(fmt.Sprintf("%v", this.Selector), "LabelSelector", "k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector", 1) + `,`,
1470                 `AverageValue:` + strings.Replace(fmt.Sprintf("%v", this.AverageValue), "Quantity", "k8s_io_apimachinery_pkg_api_resource.Quantity", 1) + `,`,
1471                 `}`,
1472         }, "")
1473         return s
1474 }
1475 func (this *PodsMetricSource) String() string {
1476         if this == nil {
1477                 return "nil"
1478         }
1479         s := strings.Join([]string{`&PodsMetricSource{`,
1480                 `MetricName:` + fmt.Sprintf("%v", this.MetricName) + `,`,
1481                 `TargetAverageValue:` + strings.Replace(strings.Replace(this.TargetAverageValue.String(), "Quantity", "k8s_io_apimachinery_pkg_api_resource.Quantity", 1), `&`, ``, 1) + `,`,
1482                 `Selector:` + strings.Replace(fmt.Sprintf("%v", this.Selector), "LabelSelector", "k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector", 1) + `,`,
1483                 `}`,
1484         }, "")
1485         return s
1486 }
1487 func (this *PodsMetricStatus) String() string {
1488         if this == nil {
1489                 return "nil"
1490         }
1491         s := strings.Join([]string{`&PodsMetricStatus{`,
1492                 `MetricName:` + fmt.Sprintf("%v", this.MetricName) + `,`,
1493                 `CurrentAverageValue:` + strings.Replace(strings.Replace(this.CurrentAverageValue.String(), "Quantity", "k8s_io_apimachinery_pkg_api_resource.Quantity", 1), `&`, ``, 1) + `,`,
1494                 `Selector:` + strings.Replace(fmt.Sprintf("%v", this.Selector), "LabelSelector", "k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector", 1) + `,`,
1495                 `}`,
1496         }, "")
1497         return s
1498 }
1499 func (this *ResourceMetricSource) String() string {
1500         if this == nil {
1501                 return "nil"
1502         }
1503         s := strings.Join([]string{`&ResourceMetricSource{`,
1504                 `Name:` + fmt.Sprintf("%v", this.Name) + `,`,
1505                 `TargetAverageUtilization:` + valueToStringGenerated(this.TargetAverageUtilization) + `,`,
1506                 `TargetAverageValue:` + strings.Replace(fmt.Sprintf("%v", this.TargetAverageValue), "Quantity", "k8s_io_apimachinery_pkg_api_resource.Quantity", 1) + `,`,
1507                 `}`,
1508         }, "")
1509         return s
1510 }
1511 func (this *ResourceMetricStatus) String() string {
1512         if this == nil {
1513                 return "nil"
1514         }
1515         s := strings.Join([]string{`&ResourceMetricStatus{`,
1516                 `Name:` + fmt.Sprintf("%v", this.Name) + `,`,
1517                 `CurrentAverageUtilization:` + valueToStringGenerated(this.CurrentAverageUtilization) + `,`,
1518                 `CurrentAverageValue:` + strings.Replace(strings.Replace(this.CurrentAverageValue.String(), "Quantity", "k8s_io_apimachinery_pkg_api_resource.Quantity", 1), `&`, ``, 1) + `,`,
1519                 `}`,
1520         }, "")
1521         return s
1522 }
1523 func (this *Scale) String() string {
1524         if this == nil {
1525                 return "nil"
1526         }
1527         s := strings.Join([]string{`&Scale{`,
1528                 `ObjectMeta:` + strings.Replace(strings.Replace(this.ObjectMeta.String(), "ObjectMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
1529                 `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "ScaleSpec", "ScaleSpec", 1), `&`, ``, 1) + `,`,
1530                 `Status:` + strings.Replace(strings.Replace(this.Status.String(), "ScaleStatus", "ScaleStatus", 1), `&`, ``, 1) + `,`,
1531                 `}`,
1532         }, "")
1533         return s
1534 }
1535 func (this *ScaleSpec) String() string {
1536         if this == nil {
1537                 return "nil"
1538         }
1539         s := strings.Join([]string{`&ScaleSpec{`,
1540                 `Replicas:` + fmt.Sprintf("%v", this.Replicas) + `,`,
1541                 `}`,
1542         }, "")
1543         return s
1544 }
1545 func (this *ScaleStatus) String() string {
1546         if this == nil {
1547                 return "nil"
1548         }
1549         s := strings.Join([]string{`&ScaleStatus{`,
1550                 `Replicas:` + fmt.Sprintf("%v", this.Replicas) + `,`,
1551                 `Selector:` + fmt.Sprintf("%v", this.Selector) + `,`,
1552                 `}`,
1553         }, "")
1554         return s
1555 }
1556 func valueToStringGenerated(v interface{}) string {
1557         rv := reflect.ValueOf(v)
1558         if rv.IsNil() {
1559                 return "nil"
1560         }
1561         pv := reflect.Indirect(rv).Interface()
1562         return fmt.Sprintf("*%v", pv)
1563 }
1564 func (m *CrossVersionObjectReference) Unmarshal(dAtA []byte) error {
1565         l := len(dAtA)
1566         iNdEx := 0
1567         for iNdEx < l {
1568                 preIndex := iNdEx
1569                 var wire uint64
1570                 for shift := uint(0); ; shift += 7 {
1571                         if shift >= 64 {
1572                                 return ErrIntOverflowGenerated
1573                         }
1574                         if iNdEx >= l {
1575                                 return io.ErrUnexpectedEOF
1576                         }
1577                         b := dAtA[iNdEx]
1578                         iNdEx++
1579                         wire |= (uint64(b) & 0x7F) << shift
1580                         if b < 0x80 {
1581                                 break
1582                         }
1583                 }
1584                 fieldNum := int32(wire >> 3)
1585                 wireType := int(wire & 0x7)
1586                 if wireType == 4 {
1587                         return fmt.Errorf("proto: CrossVersionObjectReference: wiretype end group for non-group")
1588                 }
1589                 if fieldNum <= 0 {
1590                         return fmt.Errorf("proto: CrossVersionObjectReference: illegal tag %d (wire type %d)", fieldNum, wire)
1591                 }
1592                 switch fieldNum {
1593                 case 1:
1594                         if wireType != 2 {
1595                                 return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType)
1596                         }
1597                         var stringLen uint64
1598                         for shift := uint(0); ; shift += 7 {
1599                                 if shift >= 64 {
1600                                         return ErrIntOverflowGenerated
1601                                 }
1602                                 if iNdEx >= l {
1603                                         return io.ErrUnexpectedEOF
1604                                 }
1605                                 b := dAtA[iNdEx]
1606                                 iNdEx++
1607                                 stringLen |= (uint64(b) & 0x7F) << shift
1608                                 if b < 0x80 {
1609                                         break
1610                                 }
1611                         }
1612                         intStringLen := int(stringLen)
1613                         if intStringLen < 0 {
1614                                 return ErrInvalidLengthGenerated
1615                         }
1616                         postIndex := iNdEx + intStringLen
1617                         if postIndex > l {
1618                                 return io.ErrUnexpectedEOF
1619                         }
1620                         m.Kind = string(dAtA[iNdEx:postIndex])
1621                         iNdEx = postIndex
1622                 case 2:
1623                         if wireType != 2 {
1624                                 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
1625                         }
1626                         var stringLen uint64
1627                         for shift := uint(0); ; shift += 7 {
1628                                 if shift >= 64 {
1629                                         return ErrIntOverflowGenerated
1630                                 }
1631                                 if iNdEx >= l {
1632                                         return io.ErrUnexpectedEOF
1633                                 }
1634                                 b := dAtA[iNdEx]
1635                                 iNdEx++
1636                                 stringLen |= (uint64(b) & 0x7F) << shift
1637                                 if b < 0x80 {
1638                                         break
1639                                 }
1640                         }
1641                         intStringLen := int(stringLen)
1642                         if intStringLen < 0 {
1643                                 return ErrInvalidLengthGenerated
1644                         }
1645                         postIndex := iNdEx + intStringLen
1646                         if postIndex > l {
1647                                 return io.ErrUnexpectedEOF
1648                         }
1649                         m.Name = string(dAtA[iNdEx:postIndex])
1650                         iNdEx = postIndex
1651                 case 3:
1652                         if wireType != 2 {
1653                                 return fmt.Errorf("proto: wrong wireType = %d for field APIVersion", wireType)
1654                         }
1655                         var stringLen uint64
1656                         for shift := uint(0); ; shift += 7 {
1657                                 if shift >= 64 {
1658                                         return ErrIntOverflowGenerated
1659                                 }
1660                                 if iNdEx >= l {
1661                                         return io.ErrUnexpectedEOF
1662                                 }
1663                                 b := dAtA[iNdEx]
1664                                 iNdEx++
1665                                 stringLen |= (uint64(b) & 0x7F) << shift
1666                                 if b < 0x80 {
1667                                         break
1668                                 }
1669                         }
1670                         intStringLen := int(stringLen)
1671                         if intStringLen < 0 {
1672                                 return ErrInvalidLengthGenerated
1673                         }
1674                         postIndex := iNdEx + intStringLen
1675                         if postIndex > l {
1676                                 return io.ErrUnexpectedEOF
1677                         }
1678                         m.APIVersion = string(dAtA[iNdEx:postIndex])
1679                         iNdEx = postIndex
1680                 default:
1681                         iNdEx = preIndex
1682                         skippy, err := skipGenerated(dAtA[iNdEx:])
1683                         if err != nil {
1684                                 return err
1685                         }
1686                         if skippy < 0 {
1687                                 return ErrInvalidLengthGenerated
1688                         }
1689                         if (iNdEx + skippy) > l {
1690                                 return io.ErrUnexpectedEOF
1691                         }
1692                         iNdEx += skippy
1693                 }
1694         }
1695
1696         if iNdEx > l {
1697                 return io.ErrUnexpectedEOF
1698         }
1699         return nil
1700 }
1701 func (m *ExternalMetricSource) Unmarshal(dAtA []byte) error {
1702         l := len(dAtA)
1703         iNdEx := 0
1704         for iNdEx < l {
1705                 preIndex := iNdEx
1706                 var wire uint64
1707                 for shift := uint(0); ; shift += 7 {
1708                         if shift >= 64 {
1709                                 return ErrIntOverflowGenerated
1710                         }
1711                         if iNdEx >= l {
1712                                 return io.ErrUnexpectedEOF
1713                         }
1714                         b := dAtA[iNdEx]
1715                         iNdEx++
1716                         wire |= (uint64(b) & 0x7F) << shift
1717                         if b < 0x80 {
1718                                 break
1719                         }
1720                 }
1721                 fieldNum := int32(wire >> 3)
1722                 wireType := int(wire & 0x7)
1723                 if wireType == 4 {
1724                         return fmt.Errorf("proto: ExternalMetricSource: wiretype end group for non-group")
1725                 }
1726                 if fieldNum <= 0 {
1727                         return fmt.Errorf("proto: ExternalMetricSource: illegal tag %d (wire type %d)", fieldNum, wire)
1728                 }
1729                 switch fieldNum {
1730                 case 1:
1731                         if wireType != 2 {
1732                                 return fmt.Errorf("proto: wrong wireType = %d for field MetricName", wireType)
1733                         }
1734                         var stringLen uint64
1735                         for shift := uint(0); ; shift += 7 {
1736                                 if shift >= 64 {
1737                                         return ErrIntOverflowGenerated
1738                                 }
1739                                 if iNdEx >= l {
1740                                         return io.ErrUnexpectedEOF
1741                                 }
1742                                 b := dAtA[iNdEx]
1743                                 iNdEx++
1744                                 stringLen |= (uint64(b) & 0x7F) << shift
1745                                 if b < 0x80 {
1746                                         break
1747                                 }
1748                         }
1749                         intStringLen := int(stringLen)
1750                         if intStringLen < 0 {
1751                                 return ErrInvalidLengthGenerated
1752                         }
1753                         postIndex := iNdEx + intStringLen
1754                         if postIndex > l {
1755                                 return io.ErrUnexpectedEOF
1756                         }
1757                         m.MetricName = string(dAtA[iNdEx:postIndex])
1758                         iNdEx = postIndex
1759                 case 2:
1760                         if wireType != 2 {
1761                                 return fmt.Errorf("proto: wrong wireType = %d for field MetricSelector", wireType)
1762                         }
1763                         var msglen int
1764                         for shift := uint(0); ; shift += 7 {
1765                                 if shift >= 64 {
1766                                         return ErrIntOverflowGenerated
1767                                 }
1768                                 if iNdEx >= l {
1769                                         return io.ErrUnexpectedEOF
1770                                 }
1771                                 b := dAtA[iNdEx]
1772                                 iNdEx++
1773                                 msglen |= (int(b) & 0x7F) << shift
1774                                 if b < 0x80 {
1775                                         break
1776                                 }
1777                         }
1778                         if msglen < 0 {
1779                                 return ErrInvalidLengthGenerated
1780                         }
1781                         postIndex := iNdEx + msglen
1782                         if postIndex > l {
1783                                 return io.ErrUnexpectedEOF
1784                         }
1785                         if m.MetricSelector == nil {
1786                                 m.MetricSelector = &k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector{}
1787                         }
1788                         if err := m.MetricSelector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1789                                 return err
1790                         }
1791                         iNdEx = postIndex
1792                 case 3:
1793                         if wireType != 2 {
1794                                 return fmt.Errorf("proto: wrong wireType = %d for field TargetValue", wireType)
1795                         }
1796                         var msglen int
1797                         for shift := uint(0); ; shift += 7 {
1798                                 if shift >= 64 {
1799                                         return ErrIntOverflowGenerated
1800                                 }
1801                                 if iNdEx >= l {
1802                                         return io.ErrUnexpectedEOF
1803                                 }
1804                                 b := dAtA[iNdEx]
1805                                 iNdEx++
1806                                 msglen |= (int(b) & 0x7F) << shift
1807                                 if b < 0x80 {
1808                                         break
1809                                 }
1810                         }
1811                         if msglen < 0 {
1812                                 return ErrInvalidLengthGenerated
1813                         }
1814                         postIndex := iNdEx + msglen
1815                         if postIndex > l {
1816                                 return io.ErrUnexpectedEOF
1817                         }
1818                         if m.TargetValue == nil {
1819                                 m.TargetValue = &k8s_io_apimachinery_pkg_api_resource.Quantity{}
1820                         }
1821                         if err := m.TargetValue.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1822                                 return err
1823                         }
1824                         iNdEx = postIndex
1825                 case 4:
1826                         if wireType != 2 {
1827                                 return fmt.Errorf("proto: wrong wireType = %d for field TargetAverageValue", wireType)
1828                         }
1829                         var msglen int
1830                         for shift := uint(0); ; shift += 7 {
1831                                 if shift >= 64 {
1832                                         return ErrIntOverflowGenerated
1833                                 }
1834                                 if iNdEx >= l {
1835                                         return io.ErrUnexpectedEOF
1836                                 }
1837                                 b := dAtA[iNdEx]
1838                                 iNdEx++
1839                                 msglen |= (int(b) & 0x7F) << shift
1840                                 if b < 0x80 {
1841                                         break
1842                                 }
1843                         }
1844                         if msglen < 0 {
1845                                 return ErrInvalidLengthGenerated
1846                         }
1847                         postIndex := iNdEx + msglen
1848                         if postIndex > l {
1849                                 return io.ErrUnexpectedEOF
1850                         }
1851                         if m.TargetAverageValue == nil {
1852                                 m.TargetAverageValue = &k8s_io_apimachinery_pkg_api_resource.Quantity{}
1853                         }
1854                         if err := m.TargetAverageValue.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1855                                 return err
1856                         }
1857                         iNdEx = postIndex
1858                 default:
1859                         iNdEx = preIndex
1860                         skippy, err := skipGenerated(dAtA[iNdEx:])
1861                         if err != nil {
1862                                 return err
1863                         }
1864                         if skippy < 0 {
1865                                 return ErrInvalidLengthGenerated
1866                         }
1867                         if (iNdEx + skippy) > l {
1868                                 return io.ErrUnexpectedEOF
1869                         }
1870                         iNdEx += skippy
1871                 }
1872         }
1873
1874         if iNdEx > l {
1875                 return io.ErrUnexpectedEOF
1876         }
1877         return nil
1878 }
1879 func (m *ExternalMetricStatus) Unmarshal(dAtA []byte) error {
1880         l := len(dAtA)
1881         iNdEx := 0
1882         for iNdEx < l {
1883                 preIndex := iNdEx
1884                 var wire uint64
1885                 for shift := uint(0); ; shift += 7 {
1886                         if shift >= 64 {
1887                                 return ErrIntOverflowGenerated
1888                         }
1889                         if iNdEx >= l {
1890                                 return io.ErrUnexpectedEOF
1891                         }
1892                         b := dAtA[iNdEx]
1893                         iNdEx++
1894                         wire |= (uint64(b) & 0x7F) << shift
1895                         if b < 0x80 {
1896                                 break
1897                         }
1898                 }
1899                 fieldNum := int32(wire >> 3)
1900                 wireType := int(wire & 0x7)
1901                 if wireType == 4 {
1902                         return fmt.Errorf("proto: ExternalMetricStatus: wiretype end group for non-group")
1903                 }
1904                 if fieldNum <= 0 {
1905                         return fmt.Errorf("proto: ExternalMetricStatus: illegal tag %d (wire type %d)", fieldNum, wire)
1906                 }
1907                 switch fieldNum {
1908                 case 1:
1909                         if wireType != 2 {
1910                                 return fmt.Errorf("proto: wrong wireType = %d for field MetricName", wireType)
1911                         }
1912                         var stringLen uint64
1913                         for shift := uint(0); ; shift += 7 {
1914                                 if shift >= 64 {
1915                                         return ErrIntOverflowGenerated
1916                                 }
1917                                 if iNdEx >= l {
1918                                         return io.ErrUnexpectedEOF
1919                                 }
1920                                 b := dAtA[iNdEx]
1921                                 iNdEx++
1922                                 stringLen |= (uint64(b) & 0x7F) << shift
1923                                 if b < 0x80 {
1924                                         break
1925                                 }
1926                         }
1927                         intStringLen := int(stringLen)
1928                         if intStringLen < 0 {
1929                                 return ErrInvalidLengthGenerated
1930                         }
1931                         postIndex := iNdEx + intStringLen
1932                         if postIndex > l {
1933                                 return io.ErrUnexpectedEOF
1934                         }
1935                         m.MetricName = string(dAtA[iNdEx:postIndex])
1936                         iNdEx = postIndex
1937                 case 2:
1938                         if wireType != 2 {
1939                                 return fmt.Errorf("proto: wrong wireType = %d for field MetricSelector", wireType)
1940                         }
1941                         var msglen int
1942                         for shift := uint(0); ; shift += 7 {
1943                                 if shift >= 64 {
1944                                         return ErrIntOverflowGenerated
1945                                 }
1946                                 if iNdEx >= l {
1947                                         return io.ErrUnexpectedEOF
1948                                 }
1949                                 b := dAtA[iNdEx]
1950                                 iNdEx++
1951                                 msglen |= (int(b) & 0x7F) << shift
1952                                 if b < 0x80 {
1953                                         break
1954                                 }
1955                         }
1956                         if msglen < 0 {
1957                                 return ErrInvalidLengthGenerated
1958                         }
1959                         postIndex := iNdEx + msglen
1960                         if postIndex > l {
1961                                 return io.ErrUnexpectedEOF
1962                         }
1963                         if m.MetricSelector == nil {
1964                                 m.MetricSelector = &k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector{}
1965                         }
1966                         if err := m.MetricSelector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1967                                 return err
1968                         }
1969                         iNdEx = postIndex
1970                 case 3:
1971                         if wireType != 2 {
1972                                 return fmt.Errorf("proto: wrong wireType = %d for field CurrentValue", wireType)
1973                         }
1974                         var msglen int
1975                         for shift := uint(0); ; shift += 7 {
1976                                 if shift >= 64 {
1977                                         return ErrIntOverflowGenerated
1978                                 }
1979                                 if iNdEx >= l {
1980                                         return io.ErrUnexpectedEOF
1981                                 }
1982                                 b := dAtA[iNdEx]
1983                                 iNdEx++
1984                                 msglen |= (int(b) & 0x7F) << shift
1985                                 if b < 0x80 {
1986                                         break
1987                                 }
1988                         }
1989                         if msglen < 0 {
1990                                 return ErrInvalidLengthGenerated
1991                         }
1992                         postIndex := iNdEx + msglen
1993                         if postIndex > l {
1994                                 return io.ErrUnexpectedEOF
1995                         }
1996                         if err := m.CurrentValue.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1997                                 return err
1998                         }
1999                         iNdEx = postIndex
2000                 case 4:
2001                         if wireType != 2 {
2002                                 return fmt.Errorf("proto: wrong wireType = %d for field CurrentAverageValue", wireType)
2003                         }
2004                         var msglen int
2005                         for shift := uint(0); ; shift += 7 {
2006                                 if shift >= 64 {
2007                                         return ErrIntOverflowGenerated
2008                                 }
2009                                 if iNdEx >= l {
2010                                         return io.ErrUnexpectedEOF
2011                                 }
2012                                 b := dAtA[iNdEx]
2013                                 iNdEx++
2014                                 msglen |= (int(b) & 0x7F) << shift
2015                                 if b < 0x80 {
2016                                         break
2017                                 }
2018                         }
2019                         if msglen < 0 {
2020                                 return ErrInvalidLengthGenerated
2021                         }
2022                         postIndex := iNdEx + msglen
2023                         if postIndex > l {
2024                                 return io.ErrUnexpectedEOF
2025                         }
2026                         if m.CurrentAverageValue == nil {
2027                                 m.CurrentAverageValue = &k8s_io_apimachinery_pkg_api_resource.Quantity{}
2028                         }
2029                         if err := m.CurrentAverageValue.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2030                                 return err
2031                         }
2032                         iNdEx = postIndex
2033                 default:
2034                         iNdEx = preIndex
2035                         skippy, err := skipGenerated(dAtA[iNdEx:])
2036                         if err != nil {
2037                                 return err
2038                         }
2039                         if skippy < 0 {
2040                                 return ErrInvalidLengthGenerated
2041                         }
2042                         if (iNdEx + skippy) > l {
2043                                 return io.ErrUnexpectedEOF
2044                         }
2045                         iNdEx += skippy
2046                 }
2047         }
2048
2049         if iNdEx > l {
2050                 return io.ErrUnexpectedEOF
2051         }
2052         return nil
2053 }
2054 func (m *HorizontalPodAutoscaler) Unmarshal(dAtA []byte) error {
2055         l := len(dAtA)
2056         iNdEx := 0
2057         for iNdEx < l {
2058                 preIndex := iNdEx
2059                 var wire uint64
2060                 for shift := uint(0); ; shift += 7 {
2061                         if shift >= 64 {
2062                                 return ErrIntOverflowGenerated
2063                         }
2064                         if iNdEx >= l {
2065                                 return io.ErrUnexpectedEOF
2066                         }
2067                         b := dAtA[iNdEx]
2068                         iNdEx++
2069                         wire |= (uint64(b) & 0x7F) << shift
2070                         if b < 0x80 {
2071                                 break
2072                         }
2073                 }
2074                 fieldNum := int32(wire >> 3)
2075                 wireType := int(wire & 0x7)
2076                 if wireType == 4 {
2077                         return fmt.Errorf("proto: HorizontalPodAutoscaler: wiretype end group for non-group")
2078                 }
2079                 if fieldNum <= 0 {
2080                         return fmt.Errorf("proto: HorizontalPodAutoscaler: illegal tag %d (wire type %d)", fieldNum, wire)
2081                 }
2082                 switch fieldNum {
2083                 case 1:
2084                         if wireType != 2 {
2085                                 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
2086                         }
2087                         var msglen int
2088                         for shift := uint(0); ; shift += 7 {
2089                                 if shift >= 64 {
2090                                         return ErrIntOverflowGenerated
2091                                 }
2092                                 if iNdEx >= l {
2093                                         return io.ErrUnexpectedEOF
2094                                 }
2095                                 b := dAtA[iNdEx]
2096                                 iNdEx++
2097                                 msglen |= (int(b) & 0x7F) << shift
2098                                 if b < 0x80 {
2099                                         break
2100                                 }
2101                         }
2102                         if msglen < 0 {
2103                                 return ErrInvalidLengthGenerated
2104                         }
2105                         postIndex := iNdEx + msglen
2106                         if postIndex > l {
2107                                 return io.ErrUnexpectedEOF
2108                         }
2109                         if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2110                                 return err
2111                         }
2112                         iNdEx = postIndex
2113                 case 2:
2114                         if wireType != 2 {
2115                                 return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
2116                         }
2117                         var msglen int
2118                         for shift := uint(0); ; shift += 7 {
2119                                 if shift >= 64 {
2120                                         return ErrIntOverflowGenerated
2121                                 }
2122                                 if iNdEx >= l {
2123                                         return io.ErrUnexpectedEOF
2124                                 }
2125                                 b := dAtA[iNdEx]
2126                                 iNdEx++
2127                                 msglen |= (int(b) & 0x7F) << shift
2128                                 if b < 0x80 {
2129                                         break
2130                                 }
2131                         }
2132                         if msglen < 0 {
2133                                 return ErrInvalidLengthGenerated
2134                         }
2135                         postIndex := iNdEx + msglen
2136                         if postIndex > l {
2137                                 return io.ErrUnexpectedEOF
2138                         }
2139                         if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2140                                 return err
2141                         }
2142                         iNdEx = postIndex
2143                 case 3:
2144                         if wireType != 2 {
2145                                 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
2146                         }
2147                         var msglen int
2148                         for shift := uint(0); ; shift += 7 {
2149                                 if shift >= 64 {
2150                                         return ErrIntOverflowGenerated
2151                                 }
2152                                 if iNdEx >= l {
2153                                         return io.ErrUnexpectedEOF
2154                                 }
2155                                 b := dAtA[iNdEx]
2156                                 iNdEx++
2157                                 msglen |= (int(b) & 0x7F) << shift
2158                                 if b < 0x80 {
2159                                         break
2160                                 }
2161                         }
2162                         if msglen < 0 {
2163                                 return ErrInvalidLengthGenerated
2164                         }
2165                         postIndex := iNdEx + msglen
2166                         if postIndex > l {
2167                                 return io.ErrUnexpectedEOF
2168                         }
2169                         if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2170                                 return err
2171                         }
2172                         iNdEx = postIndex
2173                 default:
2174                         iNdEx = preIndex
2175                         skippy, err := skipGenerated(dAtA[iNdEx:])
2176                         if err != nil {
2177                                 return err
2178                         }
2179                         if skippy < 0 {
2180                                 return ErrInvalidLengthGenerated
2181                         }
2182                         if (iNdEx + skippy) > l {
2183                                 return io.ErrUnexpectedEOF
2184                         }
2185                         iNdEx += skippy
2186                 }
2187         }
2188
2189         if iNdEx > l {
2190                 return io.ErrUnexpectedEOF
2191         }
2192         return nil
2193 }
2194 func (m *HorizontalPodAutoscalerCondition) Unmarshal(dAtA []byte) error {
2195         l := len(dAtA)
2196         iNdEx := 0
2197         for iNdEx < l {
2198                 preIndex := iNdEx
2199                 var wire uint64
2200                 for shift := uint(0); ; shift += 7 {
2201                         if shift >= 64 {
2202                                 return ErrIntOverflowGenerated
2203                         }
2204                         if iNdEx >= l {
2205                                 return io.ErrUnexpectedEOF
2206                         }
2207                         b := dAtA[iNdEx]
2208                         iNdEx++
2209                         wire |= (uint64(b) & 0x7F) << shift
2210                         if b < 0x80 {
2211                                 break
2212                         }
2213                 }
2214                 fieldNum := int32(wire >> 3)
2215                 wireType := int(wire & 0x7)
2216                 if wireType == 4 {
2217                         return fmt.Errorf("proto: HorizontalPodAutoscalerCondition: wiretype end group for non-group")
2218                 }
2219                 if fieldNum <= 0 {
2220                         return fmt.Errorf("proto: HorizontalPodAutoscalerCondition: illegal tag %d (wire type %d)", fieldNum, wire)
2221                 }
2222                 switch fieldNum {
2223                 case 1:
2224                         if wireType != 2 {
2225                                 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
2226                         }
2227                         var stringLen uint64
2228                         for shift := uint(0); ; shift += 7 {
2229                                 if shift >= 64 {
2230                                         return ErrIntOverflowGenerated
2231                                 }
2232                                 if iNdEx >= l {
2233                                         return io.ErrUnexpectedEOF
2234                                 }
2235                                 b := dAtA[iNdEx]
2236                                 iNdEx++
2237                                 stringLen |= (uint64(b) & 0x7F) << shift
2238                                 if b < 0x80 {
2239                                         break
2240                                 }
2241                         }
2242                         intStringLen := int(stringLen)
2243                         if intStringLen < 0 {
2244                                 return ErrInvalidLengthGenerated
2245                         }
2246                         postIndex := iNdEx + intStringLen
2247                         if postIndex > l {
2248                                 return io.ErrUnexpectedEOF
2249                         }
2250                         m.Type = HorizontalPodAutoscalerConditionType(dAtA[iNdEx:postIndex])
2251                         iNdEx = postIndex
2252                 case 2:
2253                         if wireType != 2 {
2254                                 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
2255                         }
2256                         var stringLen uint64
2257                         for shift := uint(0); ; shift += 7 {
2258                                 if shift >= 64 {
2259                                         return ErrIntOverflowGenerated
2260                                 }
2261                                 if iNdEx >= l {
2262                                         return io.ErrUnexpectedEOF
2263                                 }
2264                                 b := dAtA[iNdEx]
2265                                 iNdEx++
2266                                 stringLen |= (uint64(b) & 0x7F) << shift
2267                                 if b < 0x80 {
2268                                         break
2269                                 }
2270                         }
2271                         intStringLen := int(stringLen)
2272                         if intStringLen < 0 {
2273                                 return ErrInvalidLengthGenerated
2274                         }
2275                         postIndex := iNdEx + intStringLen
2276                         if postIndex > l {
2277                                 return io.ErrUnexpectedEOF
2278                         }
2279                         m.Status = k8s_io_api_core_v1.ConditionStatus(dAtA[iNdEx:postIndex])
2280                         iNdEx = postIndex
2281                 case 3:
2282                         if wireType != 2 {
2283                                 return fmt.Errorf("proto: wrong wireType = %d for field LastTransitionTime", wireType)
2284                         }
2285                         var msglen int
2286                         for shift := uint(0); ; shift += 7 {
2287                                 if shift >= 64 {
2288                                         return ErrIntOverflowGenerated
2289                                 }
2290                                 if iNdEx >= l {
2291                                         return io.ErrUnexpectedEOF
2292                                 }
2293                                 b := dAtA[iNdEx]
2294                                 iNdEx++
2295                                 msglen |= (int(b) & 0x7F) << shift
2296                                 if b < 0x80 {
2297                                         break
2298                                 }
2299                         }
2300                         if msglen < 0 {
2301                                 return ErrInvalidLengthGenerated
2302                         }
2303                         postIndex := iNdEx + msglen
2304                         if postIndex > l {
2305                                 return io.ErrUnexpectedEOF
2306                         }
2307                         if err := m.LastTransitionTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2308                                 return err
2309                         }
2310                         iNdEx = postIndex
2311                 case 4:
2312                         if wireType != 2 {
2313                                 return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
2314                         }
2315                         var stringLen uint64
2316                         for shift := uint(0); ; shift += 7 {
2317                                 if shift >= 64 {
2318                                         return ErrIntOverflowGenerated
2319                                 }
2320                                 if iNdEx >= l {
2321                                         return io.ErrUnexpectedEOF
2322                                 }
2323                                 b := dAtA[iNdEx]
2324                                 iNdEx++
2325                                 stringLen |= (uint64(b) & 0x7F) << shift
2326                                 if b < 0x80 {
2327                                         break
2328                                 }
2329                         }
2330                         intStringLen := int(stringLen)
2331                         if intStringLen < 0 {
2332                                 return ErrInvalidLengthGenerated
2333                         }
2334                         postIndex := iNdEx + intStringLen
2335                         if postIndex > l {
2336                                 return io.ErrUnexpectedEOF
2337                         }
2338                         m.Reason = string(dAtA[iNdEx:postIndex])
2339                         iNdEx = postIndex
2340                 case 5:
2341                         if wireType != 2 {
2342                                 return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
2343                         }
2344                         var stringLen uint64
2345                         for shift := uint(0); ; shift += 7 {
2346                                 if shift >= 64 {
2347                                         return ErrIntOverflowGenerated
2348                                 }
2349                                 if iNdEx >= l {
2350                                         return io.ErrUnexpectedEOF
2351                                 }
2352                                 b := dAtA[iNdEx]
2353                                 iNdEx++
2354                                 stringLen |= (uint64(b) & 0x7F) << shift
2355                                 if b < 0x80 {
2356                                         break
2357                                 }
2358                         }
2359                         intStringLen := int(stringLen)
2360                         if intStringLen < 0 {
2361                                 return ErrInvalidLengthGenerated
2362                         }
2363                         postIndex := iNdEx + intStringLen
2364                         if postIndex > l {
2365                                 return io.ErrUnexpectedEOF
2366                         }
2367                         m.Message = string(dAtA[iNdEx:postIndex])
2368                         iNdEx = postIndex
2369                 default:
2370                         iNdEx = preIndex
2371                         skippy, err := skipGenerated(dAtA[iNdEx:])
2372                         if err != nil {
2373                                 return err
2374                         }
2375                         if skippy < 0 {
2376                                 return ErrInvalidLengthGenerated
2377                         }
2378                         if (iNdEx + skippy) > l {
2379                                 return io.ErrUnexpectedEOF
2380                         }
2381                         iNdEx += skippy
2382                 }
2383         }
2384
2385         if iNdEx > l {
2386                 return io.ErrUnexpectedEOF
2387         }
2388         return nil
2389 }
2390 func (m *HorizontalPodAutoscalerList) Unmarshal(dAtA []byte) error {
2391         l := len(dAtA)
2392         iNdEx := 0
2393         for iNdEx < l {
2394                 preIndex := iNdEx
2395                 var wire uint64
2396                 for shift := uint(0); ; shift += 7 {
2397                         if shift >= 64 {
2398                                 return ErrIntOverflowGenerated
2399                         }
2400                         if iNdEx >= l {
2401                                 return io.ErrUnexpectedEOF
2402                         }
2403                         b := dAtA[iNdEx]
2404                         iNdEx++
2405                         wire |= (uint64(b) & 0x7F) << shift
2406                         if b < 0x80 {
2407                                 break
2408                         }
2409                 }
2410                 fieldNum := int32(wire >> 3)
2411                 wireType := int(wire & 0x7)
2412                 if wireType == 4 {
2413                         return fmt.Errorf("proto: HorizontalPodAutoscalerList: wiretype end group for non-group")
2414                 }
2415                 if fieldNum <= 0 {
2416                         return fmt.Errorf("proto: HorizontalPodAutoscalerList: illegal tag %d (wire type %d)", fieldNum, wire)
2417                 }
2418                 switch fieldNum {
2419                 case 1:
2420                         if wireType != 2 {
2421                                 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
2422                         }
2423                         var msglen int
2424                         for shift := uint(0); ; shift += 7 {
2425                                 if shift >= 64 {
2426                                         return ErrIntOverflowGenerated
2427                                 }
2428                                 if iNdEx >= l {
2429                                         return io.ErrUnexpectedEOF
2430                                 }
2431                                 b := dAtA[iNdEx]
2432                                 iNdEx++
2433                                 msglen |= (int(b) & 0x7F) << shift
2434                                 if b < 0x80 {
2435                                         break
2436                                 }
2437                         }
2438                         if msglen < 0 {
2439                                 return ErrInvalidLengthGenerated
2440                         }
2441                         postIndex := iNdEx + msglen
2442                         if postIndex > l {
2443                                 return io.ErrUnexpectedEOF
2444                         }
2445                         if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2446                                 return err
2447                         }
2448                         iNdEx = postIndex
2449                 case 2:
2450                         if wireType != 2 {
2451                                 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
2452                         }
2453                         var msglen int
2454                         for shift := uint(0); ; shift += 7 {
2455                                 if shift >= 64 {
2456                                         return ErrIntOverflowGenerated
2457                                 }
2458                                 if iNdEx >= l {
2459                                         return io.ErrUnexpectedEOF
2460                                 }
2461                                 b := dAtA[iNdEx]
2462                                 iNdEx++
2463                                 msglen |= (int(b) & 0x7F) << shift
2464                                 if b < 0x80 {
2465                                         break
2466                                 }
2467                         }
2468                         if msglen < 0 {
2469                                 return ErrInvalidLengthGenerated
2470                         }
2471                         postIndex := iNdEx + msglen
2472                         if postIndex > l {
2473                                 return io.ErrUnexpectedEOF
2474                         }
2475                         m.Items = append(m.Items, HorizontalPodAutoscaler{})
2476                         if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2477                                 return err
2478                         }
2479                         iNdEx = postIndex
2480                 default:
2481                         iNdEx = preIndex
2482                         skippy, err := skipGenerated(dAtA[iNdEx:])
2483                         if err != nil {
2484                                 return err
2485                         }
2486                         if skippy < 0 {
2487                                 return ErrInvalidLengthGenerated
2488                         }
2489                         if (iNdEx + skippy) > l {
2490                                 return io.ErrUnexpectedEOF
2491                         }
2492                         iNdEx += skippy
2493                 }
2494         }
2495
2496         if iNdEx > l {
2497                 return io.ErrUnexpectedEOF
2498         }
2499         return nil
2500 }
2501 func (m *HorizontalPodAutoscalerSpec) Unmarshal(dAtA []byte) error {
2502         l := len(dAtA)
2503         iNdEx := 0
2504         for iNdEx < l {
2505                 preIndex := iNdEx
2506                 var wire uint64
2507                 for shift := uint(0); ; shift += 7 {
2508                         if shift >= 64 {
2509                                 return ErrIntOverflowGenerated
2510                         }
2511                         if iNdEx >= l {
2512                                 return io.ErrUnexpectedEOF
2513                         }
2514                         b := dAtA[iNdEx]
2515                         iNdEx++
2516                         wire |= (uint64(b) & 0x7F) << shift
2517                         if b < 0x80 {
2518                                 break
2519                         }
2520                 }
2521                 fieldNum := int32(wire >> 3)
2522                 wireType := int(wire & 0x7)
2523                 if wireType == 4 {
2524                         return fmt.Errorf("proto: HorizontalPodAutoscalerSpec: wiretype end group for non-group")
2525                 }
2526                 if fieldNum <= 0 {
2527                         return fmt.Errorf("proto: HorizontalPodAutoscalerSpec: illegal tag %d (wire type %d)", fieldNum, wire)
2528                 }
2529                 switch fieldNum {
2530                 case 1:
2531                         if wireType != 2 {
2532                                 return fmt.Errorf("proto: wrong wireType = %d for field ScaleTargetRef", wireType)
2533                         }
2534                         var msglen int
2535                         for shift := uint(0); ; shift += 7 {
2536                                 if shift >= 64 {
2537                                         return ErrIntOverflowGenerated
2538                                 }
2539                                 if iNdEx >= l {
2540                                         return io.ErrUnexpectedEOF
2541                                 }
2542                                 b := dAtA[iNdEx]
2543                                 iNdEx++
2544                                 msglen |= (int(b) & 0x7F) << shift
2545                                 if b < 0x80 {
2546                                         break
2547                                 }
2548                         }
2549                         if msglen < 0 {
2550                                 return ErrInvalidLengthGenerated
2551                         }
2552                         postIndex := iNdEx + msglen
2553                         if postIndex > l {
2554                                 return io.ErrUnexpectedEOF
2555                         }
2556                         if err := m.ScaleTargetRef.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2557                                 return err
2558                         }
2559                         iNdEx = postIndex
2560                 case 2:
2561                         if wireType != 0 {
2562                                 return fmt.Errorf("proto: wrong wireType = %d for field MinReplicas", wireType)
2563                         }
2564                         var v int32
2565                         for shift := uint(0); ; shift += 7 {
2566                                 if shift >= 64 {
2567                                         return ErrIntOverflowGenerated
2568                                 }
2569                                 if iNdEx >= l {
2570                                         return io.ErrUnexpectedEOF
2571                                 }
2572                                 b := dAtA[iNdEx]
2573                                 iNdEx++
2574                                 v |= (int32(b) & 0x7F) << shift
2575                                 if b < 0x80 {
2576                                         break
2577                                 }
2578                         }
2579                         m.MinReplicas = &v
2580                 case 3:
2581                         if wireType != 0 {
2582                                 return fmt.Errorf("proto: wrong wireType = %d for field MaxReplicas", wireType)
2583                         }
2584                         m.MaxReplicas = 0
2585                         for shift := uint(0); ; shift += 7 {
2586                                 if shift >= 64 {
2587                                         return ErrIntOverflowGenerated
2588                                 }
2589                                 if iNdEx >= l {
2590                                         return io.ErrUnexpectedEOF
2591                                 }
2592                                 b := dAtA[iNdEx]
2593                                 iNdEx++
2594                                 m.MaxReplicas |= (int32(b) & 0x7F) << shift
2595                                 if b < 0x80 {
2596                                         break
2597                                 }
2598                         }
2599                 case 4:
2600                         if wireType != 0 {
2601                                 return fmt.Errorf("proto: wrong wireType = %d for field TargetCPUUtilizationPercentage", wireType)
2602                         }
2603                         var v int32
2604                         for shift := uint(0); ; shift += 7 {
2605                                 if shift >= 64 {
2606                                         return ErrIntOverflowGenerated
2607                                 }
2608                                 if iNdEx >= l {
2609                                         return io.ErrUnexpectedEOF
2610                                 }
2611                                 b := dAtA[iNdEx]
2612                                 iNdEx++
2613                                 v |= (int32(b) & 0x7F) << shift
2614                                 if b < 0x80 {
2615                                         break
2616                                 }
2617                         }
2618                         m.TargetCPUUtilizationPercentage = &v
2619                 default:
2620                         iNdEx = preIndex
2621                         skippy, err := skipGenerated(dAtA[iNdEx:])
2622                         if err != nil {
2623                                 return err
2624                         }
2625                         if skippy < 0 {
2626                                 return ErrInvalidLengthGenerated
2627                         }
2628                         if (iNdEx + skippy) > l {
2629                                 return io.ErrUnexpectedEOF
2630                         }
2631                         iNdEx += skippy
2632                 }
2633         }
2634
2635         if iNdEx > l {
2636                 return io.ErrUnexpectedEOF
2637         }
2638         return nil
2639 }
2640 func (m *HorizontalPodAutoscalerStatus) Unmarshal(dAtA []byte) error {
2641         l := len(dAtA)
2642         iNdEx := 0
2643         for iNdEx < l {
2644                 preIndex := iNdEx
2645                 var wire uint64
2646                 for shift := uint(0); ; shift += 7 {
2647                         if shift >= 64 {
2648                                 return ErrIntOverflowGenerated
2649                         }
2650                         if iNdEx >= l {
2651                                 return io.ErrUnexpectedEOF
2652                         }
2653                         b := dAtA[iNdEx]
2654                         iNdEx++
2655                         wire |= (uint64(b) & 0x7F) << shift
2656                         if b < 0x80 {
2657                                 break
2658                         }
2659                 }
2660                 fieldNum := int32(wire >> 3)
2661                 wireType := int(wire & 0x7)
2662                 if wireType == 4 {
2663                         return fmt.Errorf("proto: HorizontalPodAutoscalerStatus: wiretype end group for non-group")
2664                 }
2665                 if fieldNum <= 0 {
2666                         return fmt.Errorf("proto: HorizontalPodAutoscalerStatus: illegal tag %d (wire type %d)", fieldNum, wire)
2667                 }
2668                 switch fieldNum {
2669                 case 1:
2670                         if wireType != 0 {
2671                                 return fmt.Errorf("proto: wrong wireType = %d for field ObservedGeneration", wireType)
2672                         }
2673                         var v int64
2674                         for shift := uint(0); ; shift += 7 {
2675                                 if shift >= 64 {
2676                                         return ErrIntOverflowGenerated
2677                                 }
2678                                 if iNdEx >= l {
2679                                         return io.ErrUnexpectedEOF
2680                                 }
2681                                 b := dAtA[iNdEx]
2682                                 iNdEx++
2683                                 v |= (int64(b) & 0x7F) << shift
2684                                 if b < 0x80 {
2685                                         break
2686                                 }
2687                         }
2688                         m.ObservedGeneration = &v
2689                 case 2:
2690                         if wireType != 2 {
2691                                 return fmt.Errorf("proto: wrong wireType = %d for field LastScaleTime", wireType)
2692                         }
2693                         var msglen int
2694                         for shift := uint(0); ; shift += 7 {
2695                                 if shift >= 64 {
2696                                         return ErrIntOverflowGenerated
2697                                 }
2698                                 if iNdEx >= l {
2699                                         return io.ErrUnexpectedEOF
2700                                 }
2701                                 b := dAtA[iNdEx]
2702                                 iNdEx++
2703                                 msglen |= (int(b) & 0x7F) << shift
2704                                 if b < 0x80 {
2705                                         break
2706                                 }
2707                         }
2708                         if msglen < 0 {
2709                                 return ErrInvalidLengthGenerated
2710                         }
2711                         postIndex := iNdEx + msglen
2712                         if postIndex > l {
2713                                 return io.ErrUnexpectedEOF
2714                         }
2715                         if m.LastScaleTime == nil {
2716                                 m.LastScaleTime = &k8s_io_apimachinery_pkg_apis_meta_v1.Time{}
2717                         }
2718                         if err := m.LastScaleTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2719                                 return err
2720                         }
2721                         iNdEx = postIndex
2722                 case 3:
2723                         if wireType != 0 {
2724                                 return fmt.Errorf("proto: wrong wireType = %d for field CurrentReplicas", wireType)
2725                         }
2726                         m.CurrentReplicas = 0
2727                         for shift := uint(0); ; shift += 7 {
2728                                 if shift >= 64 {
2729                                         return ErrIntOverflowGenerated
2730                                 }
2731                                 if iNdEx >= l {
2732                                         return io.ErrUnexpectedEOF
2733                                 }
2734                                 b := dAtA[iNdEx]
2735                                 iNdEx++
2736                                 m.CurrentReplicas |= (int32(b) & 0x7F) << shift
2737                                 if b < 0x80 {
2738                                         break
2739                                 }
2740                         }
2741                 case 4:
2742                         if wireType != 0 {
2743                                 return fmt.Errorf("proto: wrong wireType = %d for field DesiredReplicas", wireType)
2744                         }
2745                         m.DesiredReplicas = 0
2746                         for shift := uint(0); ; shift += 7 {
2747                                 if shift >= 64 {
2748                                         return ErrIntOverflowGenerated
2749                                 }
2750                                 if iNdEx >= l {
2751                                         return io.ErrUnexpectedEOF
2752                                 }
2753                                 b := dAtA[iNdEx]
2754                                 iNdEx++
2755                                 m.DesiredReplicas |= (int32(b) & 0x7F) << shift
2756                                 if b < 0x80 {
2757                                         break
2758                                 }
2759                         }
2760                 case 5:
2761                         if wireType != 0 {
2762                                 return fmt.Errorf("proto: wrong wireType = %d for field CurrentCPUUtilizationPercentage", wireType)
2763                         }
2764                         var v int32
2765                         for shift := uint(0); ; shift += 7 {
2766                                 if shift >= 64 {
2767                                         return ErrIntOverflowGenerated
2768                                 }
2769                                 if iNdEx >= l {
2770                                         return io.ErrUnexpectedEOF
2771                                 }
2772                                 b := dAtA[iNdEx]
2773                                 iNdEx++
2774                                 v |= (int32(b) & 0x7F) << shift
2775                                 if b < 0x80 {
2776                                         break
2777                                 }
2778                         }
2779                         m.CurrentCPUUtilizationPercentage = &v
2780                 default:
2781                         iNdEx = preIndex
2782                         skippy, err := skipGenerated(dAtA[iNdEx:])
2783                         if err != nil {
2784                                 return err
2785                         }
2786                         if skippy < 0 {
2787                                 return ErrInvalidLengthGenerated
2788                         }
2789                         if (iNdEx + skippy) > l {
2790                                 return io.ErrUnexpectedEOF
2791                         }
2792                         iNdEx += skippy
2793                 }
2794         }
2795
2796         if iNdEx > l {
2797                 return io.ErrUnexpectedEOF
2798         }
2799         return nil
2800 }
2801 func (m *MetricSpec) Unmarshal(dAtA []byte) error {
2802         l := len(dAtA)
2803         iNdEx := 0
2804         for iNdEx < l {
2805                 preIndex := iNdEx
2806                 var wire uint64
2807                 for shift := uint(0); ; shift += 7 {
2808                         if shift >= 64 {
2809                                 return ErrIntOverflowGenerated
2810                         }
2811                         if iNdEx >= l {
2812                                 return io.ErrUnexpectedEOF
2813                         }
2814                         b := dAtA[iNdEx]
2815                         iNdEx++
2816                         wire |= (uint64(b) & 0x7F) << shift
2817                         if b < 0x80 {
2818                                 break
2819                         }
2820                 }
2821                 fieldNum := int32(wire >> 3)
2822                 wireType := int(wire & 0x7)
2823                 if wireType == 4 {
2824                         return fmt.Errorf("proto: MetricSpec: wiretype end group for non-group")
2825                 }
2826                 if fieldNum <= 0 {
2827                         return fmt.Errorf("proto: MetricSpec: illegal tag %d (wire type %d)", fieldNum, wire)
2828                 }
2829                 switch fieldNum {
2830                 case 1:
2831                         if wireType != 2 {
2832                                 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
2833                         }
2834                         var stringLen uint64
2835                         for shift := uint(0); ; shift += 7 {
2836                                 if shift >= 64 {
2837                                         return ErrIntOverflowGenerated
2838                                 }
2839                                 if iNdEx >= l {
2840                                         return io.ErrUnexpectedEOF
2841                                 }
2842                                 b := dAtA[iNdEx]
2843                                 iNdEx++
2844                                 stringLen |= (uint64(b) & 0x7F) << shift
2845                                 if b < 0x80 {
2846                                         break
2847                                 }
2848                         }
2849                         intStringLen := int(stringLen)
2850                         if intStringLen < 0 {
2851                                 return ErrInvalidLengthGenerated
2852                         }
2853                         postIndex := iNdEx + intStringLen
2854                         if postIndex > l {
2855                                 return io.ErrUnexpectedEOF
2856                         }
2857                         m.Type = MetricSourceType(dAtA[iNdEx:postIndex])
2858                         iNdEx = postIndex
2859                 case 2:
2860                         if wireType != 2 {
2861                                 return fmt.Errorf("proto: wrong wireType = %d for field Object", wireType)
2862                         }
2863                         var msglen int
2864                         for shift := uint(0); ; shift += 7 {
2865                                 if shift >= 64 {
2866                                         return ErrIntOverflowGenerated
2867                                 }
2868                                 if iNdEx >= l {
2869                                         return io.ErrUnexpectedEOF
2870                                 }
2871                                 b := dAtA[iNdEx]
2872                                 iNdEx++
2873                                 msglen |= (int(b) & 0x7F) << shift
2874                                 if b < 0x80 {
2875                                         break
2876                                 }
2877                         }
2878                         if msglen < 0 {
2879                                 return ErrInvalidLengthGenerated
2880                         }
2881                         postIndex := iNdEx + msglen
2882                         if postIndex > l {
2883                                 return io.ErrUnexpectedEOF
2884                         }
2885                         if m.Object == nil {
2886                                 m.Object = &ObjectMetricSource{}
2887                         }
2888                         if err := m.Object.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2889                                 return err
2890                         }
2891                         iNdEx = postIndex
2892                 case 3:
2893                         if wireType != 2 {
2894                                 return fmt.Errorf("proto: wrong wireType = %d for field Pods", wireType)
2895                         }
2896                         var msglen int
2897                         for shift := uint(0); ; shift += 7 {
2898                                 if shift >= 64 {
2899                                         return ErrIntOverflowGenerated
2900                                 }
2901                                 if iNdEx >= l {
2902                                         return io.ErrUnexpectedEOF
2903                                 }
2904                                 b := dAtA[iNdEx]
2905                                 iNdEx++
2906                                 msglen |= (int(b) & 0x7F) << shift
2907                                 if b < 0x80 {
2908                                         break
2909                                 }
2910                         }
2911                         if msglen < 0 {
2912                                 return ErrInvalidLengthGenerated
2913                         }
2914                         postIndex := iNdEx + msglen
2915                         if postIndex > l {
2916                                 return io.ErrUnexpectedEOF
2917                         }
2918                         if m.Pods == nil {
2919                                 m.Pods = &PodsMetricSource{}
2920                         }
2921                         if err := m.Pods.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2922                                 return err
2923                         }
2924                         iNdEx = postIndex
2925                 case 4:
2926                         if wireType != 2 {
2927                                 return fmt.Errorf("proto: wrong wireType = %d for field Resource", wireType)
2928                         }
2929                         var msglen int
2930                         for shift := uint(0); ; shift += 7 {
2931                                 if shift >= 64 {
2932                                         return ErrIntOverflowGenerated
2933                                 }
2934                                 if iNdEx >= l {
2935                                         return io.ErrUnexpectedEOF
2936                                 }
2937                                 b := dAtA[iNdEx]
2938                                 iNdEx++
2939                                 msglen |= (int(b) & 0x7F) << shift
2940                                 if b < 0x80 {
2941                                         break
2942                                 }
2943                         }
2944                         if msglen < 0 {
2945                                 return ErrInvalidLengthGenerated
2946                         }
2947                         postIndex := iNdEx + msglen
2948                         if postIndex > l {
2949                                 return io.ErrUnexpectedEOF
2950                         }
2951                         if m.Resource == nil {
2952                                 m.Resource = &ResourceMetricSource{}
2953                         }
2954                         if err := m.Resource.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2955                                 return err
2956                         }
2957                         iNdEx = postIndex
2958                 case 5:
2959                         if wireType != 2 {
2960                                 return fmt.Errorf("proto: wrong wireType = %d for field External", wireType)
2961                         }
2962                         var msglen int
2963                         for shift := uint(0); ; shift += 7 {
2964                                 if shift >= 64 {
2965                                         return ErrIntOverflowGenerated
2966                                 }
2967                                 if iNdEx >= l {
2968                                         return io.ErrUnexpectedEOF
2969                                 }
2970                                 b := dAtA[iNdEx]
2971                                 iNdEx++
2972                                 msglen |= (int(b) & 0x7F) << shift
2973                                 if b < 0x80 {
2974                                         break
2975                                 }
2976                         }
2977                         if msglen < 0 {
2978                                 return ErrInvalidLengthGenerated
2979                         }
2980                         postIndex := iNdEx + msglen
2981                         if postIndex > l {
2982                                 return io.ErrUnexpectedEOF
2983                         }
2984                         if m.External == nil {
2985                                 m.External = &ExternalMetricSource{}
2986                         }
2987                         if err := m.External.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
2988                                 return err
2989                         }
2990                         iNdEx = postIndex
2991                 default:
2992                         iNdEx = preIndex
2993                         skippy, err := skipGenerated(dAtA[iNdEx:])
2994                         if err != nil {
2995                                 return err
2996                         }
2997                         if skippy < 0 {
2998                                 return ErrInvalidLengthGenerated
2999                         }
3000                         if (iNdEx + skippy) > l {
3001                                 return io.ErrUnexpectedEOF
3002                         }
3003                         iNdEx += skippy
3004                 }
3005         }
3006
3007         if iNdEx > l {
3008                 return io.ErrUnexpectedEOF
3009         }
3010         return nil
3011 }
3012 func (m *MetricStatus) Unmarshal(dAtA []byte) error {
3013         l := len(dAtA)
3014         iNdEx := 0
3015         for iNdEx < l {
3016                 preIndex := iNdEx
3017                 var wire uint64
3018                 for shift := uint(0); ; shift += 7 {
3019                         if shift >= 64 {
3020                                 return ErrIntOverflowGenerated
3021                         }
3022                         if iNdEx >= l {
3023                                 return io.ErrUnexpectedEOF
3024                         }
3025                         b := dAtA[iNdEx]
3026                         iNdEx++
3027                         wire |= (uint64(b) & 0x7F) << shift
3028                         if b < 0x80 {
3029                                 break
3030                         }
3031                 }
3032                 fieldNum := int32(wire >> 3)
3033                 wireType := int(wire & 0x7)
3034                 if wireType == 4 {
3035                         return fmt.Errorf("proto: MetricStatus: wiretype end group for non-group")
3036                 }
3037                 if fieldNum <= 0 {
3038                         return fmt.Errorf("proto: MetricStatus: illegal tag %d (wire type %d)", fieldNum, wire)
3039                 }
3040                 switch fieldNum {
3041                 case 1:
3042                         if wireType != 2 {
3043                                 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
3044                         }
3045                         var stringLen uint64
3046                         for shift := uint(0); ; shift += 7 {
3047                                 if shift >= 64 {
3048                                         return ErrIntOverflowGenerated
3049                                 }
3050                                 if iNdEx >= l {
3051                                         return io.ErrUnexpectedEOF
3052                                 }
3053                                 b := dAtA[iNdEx]
3054                                 iNdEx++
3055                                 stringLen |= (uint64(b) & 0x7F) << shift
3056                                 if b < 0x80 {
3057                                         break
3058                                 }
3059                         }
3060                         intStringLen := int(stringLen)
3061                         if intStringLen < 0 {
3062                                 return ErrInvalidLengthGenerated
3063                         }
3064                         postIndex := iNdEx + intStringLen
3065                         if postIndex > l {
3066                                 return io.ErrUnexpectedEOF
3067                         }
3068                         m.Type = MetricSourceType(dAtA[iNdEx:postIndex])
3069                         iNdEx = postIndex
3070                 case 2:
3071                         if wireType != 2 {
3072                                 return fmt.Errorf("proto: wrong wireType = %d for field Object", wireType)
3073                         }
3074                         var msglen int
3075                         for shift := uint(0); ; shift += 7 {
3076                                 if shift >= 64 {
3077                                         return ErrIntOverflowGenerated
3078                                 }
3079                                 if iNdEx >= l {
3080                                         return io.ErrUnexpectedEOF
3081                                 }
3082                                 b := dAtA[iNdEx]
3083                                 iNdEx++
3084                                 msglen |= (int(b) & 0x7F) << shift
3085                                 if b < 0x80 {
3086                                         break
3087                                 }
3088                         }
3089                         if msglen < 0 {
3090                                 return ErrInvalidLengthGenerated
3091                         }
3092                         postIndex := iNdEx + msglen
3093                         if postIndex > l {
3094                                 return io.ErrUnexpectedEOF
3095                         }
3096                         if m.Object == nil {
3097                                 m.Object = &ObjectMetricStatus{}
3098                         }
3099                         if err := m.Object.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3100                                 return err
3101                         }
3102                         iNdEx = postIndex
3103                 case 3:
3104                         if wireType != 2 {
3105                                 return fmt.Errorf("proto: wrong wireType = %d for field Pods", wireType)
3106                         }
3107                         var msglen int
3108                         for shift := uint(0); ; shift += 7 {
3109                                 if shift >= 64 {
3110                                         return ErrIntOverflowGenerated
3111                                 }
3112                                 if iNdEx >= l {
3113                                         return io.ErrUnexpectedEOF
3114                                 }
3115                                 b := dAtA[iNdEx]
3116                                 iNdEx++
3117                                 msglen |= (int(b) & 0x7F) << shift
3118                                 if b < 0x80 {
3119                                         break
3120                                 }
3121                         }
3122                         if msglen < 0 {
3123                                 return ErrInvalidLengthGenerated
3124                         }
3125                         postIndex := iNdEx + msglen
3126                         if postIndex > l {
3127                                 return io.ErrUnexpectedEOF
3128                         }
3129                         if m.Pods == nil {
3130                                 m.Pods = &PodsMetricStatus{}
3131                         }
3132                         if err := m.Pods.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3133                                 return err
3134                         }
3135                         iNdEx = postIndex
3136                 case 4:
3137                         if wireType != 2 {
3138                                 return fmt.Errorf("proto: wrong wireType = %d for field Resource", wireType)
3139                         }
3140                         var msglen int
3141                         for shift := uint(0); ; shift += 7 {
3142                                 if shift >= 64 {
3143                                         return ErrIntOverflowGenerated
3144                                 }
3145                                 if iNdEx >= l {
3146                                         return io.ErrUnexpectedEOF
3147                                 }
3148                                 b := dAtA[iNdEx]
3149                                 iNdEx++
3150                                 msglen |= (int(b) & 0x7F) << shift
3151                                 if b < 0x80 {
3152                                         break
3153                                 }
3154                         }
3155                         if msglen < 0 {
3156                                 return ErrInvalidLengthGenerated
3157                         }
3158                         postIndex := iNdEx + msglen
3159                         if postIndex > l {
3160                                 return io.ErrUnexpectedEOF
3161                         }
3162                         if m.Resource == nil {
3163                                 m.Resource = &ResourceMetricStatus{}
3164                         }
3165                         if err := m.Resource.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3166                                 return err
3167                         }
3168                         iNdEx = postIndex
3169                 case 5:
3170                         if wireType != 2 {
3171                                 return fmt.Errorf("proto: wrong wireType = %d for field External", wireType)
3172                         }
3173                         var msglen int
3174                         for shift := uint(0); ; shift += 7 {
3175                                 if shift >= 64 {
3176                                         return ErrIntOverflowGenerated
3177                                 }
3178                                 if iNdEx >= l {
3179                                         return io.ErrUnexpectedEOF
3180                                 }
3181                                 b := dAtA[iNdEx]
3182                                 iNdEx++
3183                                 msglen |= (int(b) & 0x7F) << shift
3184                                 if b < 0x80 {
3185                                         break
3186                                 }
3187                         }
3188                         if msglen < 0 {
3189                                 return ErrInvalidLengthGenerated
3190                         }
3191                         postIndex := iNdEx + msglen
3192                         if postIndex > l {
3193                                 return io.ErrUnexpectedEOF
3194                         }
3195                         if m.External == nil {
3196                                 m.External = &ExternalMetricStatus{}
3197                         }
3198                         if err := m.External.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3199                                 return err
3200                         }
3201                         iNdEx = postIndex
3202                 default:
3203                         iNdEx = preIndex
3204                         skippy, err := skipGenerated(dAtA[iNdEx:])
3205                         if err != nil {
3206                                 return err
3207                         }
3208                         if skippy < 0 {
3209                                 return ErrInvalidLengthGenerated
3210                         }
3211                         if (iNdEx + skippy) > l {
3212                                 return io.ErrUnexpectedEOF
3213                         }
3214                         iNdEx += skippy
3215                 }
3216         }
3217
3218         if iNdEx > l {
3219                 return io.ErrUnexpectedEOF
3220         }
3221         return nil
3222 }
3223 func (m *ObjectMetricSource) Unmarshal(dAtA []byte) error {
3224         l := len(dAtA)
3225         iNdEx := 0
3226         for iNdEx < l {
3227                 preIndex := iNdEx
3228                 var wire uint64
3229                 for shift := uint(0); ; shift += 7 {
3230                         if shift >= 64 {
3231                                 return ErrIntOverflowGenerated
3232                         }
3233                         if iNdEx >= l {
3234                                 return io.ErrUnexpectedEOF
3235                         }
3236                         b := dAtA[iNdEx]
3237                         iNdEx++
3238                         wire |= (uint64(b) & 0x7F) << shift
3239                         if b < 0x80 {
3240                                 break
3241                         }
3242                 }
3243                 fieldNum := int32(wire >> 3)
3244                 wireType := int(wire & 0x7)
3245                 if wireType == 4 {
3246                         return fmt.Errorf("proto: ObjectMetricSource: wiretype end group for non-group")
3247                 }
3248                 if fieldNum <= 0 {
3249                         return fmt.Errorf("proto: ObjectMetricSource: illegal tag %d (wire type %d)", fieldNum, wire)
3250                 }
3251                 switch fieldNum {
3252                 case 1:
3253                         if wireType != 2 {
3254                                 return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType)
3255                         }
3256                         var msglen int
3257                         for shift := uint(0); ; shift += 7 {
3258                                 if shift >= 64 {
3259                                         return ErrIntOverflowGenerated
3260                                 }
3261                                 if iNdEx >= l {
3262                                         return io.ErrUnexpectedEOF
3263                                 }
3264                                 b := dAtA[iNdEx]
3265                                 iNdEx++
3266                                 msglen |= (int(b) & 0x7F) << shift
3267                                 if b < 0x80 {
3268                                         break
3269                                 }
3270                         }
3271                         if msglen < 0 {
3272                                 return ErrInvalidLengthGenerated
3273                         }
3274                         postIndex := iNdEx + msglen
3275                         if postIndex > l {
3276                                 return io.ErrUnexpectedEOF
3277                         }
3278                         if err := m.Target.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3279                                 return err
3280                         }
3281                         iNdEx = postIndex
3282                 case 2:
3283                         if wireType != 2 {
3284                                 return fmt.Errorf("proto: wrong wireType = %d for field MetricName", wireType)
3285                         }
3286                         var stringLen uint64
3287                         for shift := uint(0); ; shift += 7 {
3288                                 if shift >= 64 {
3289                                         return ErrIntOverflowGenerated
3290                                 }
3291                                 if iNdEx >= l {
3292                                         return io.ErrUnexpectedEOF
3293                                 }
3294                                 b := dAtA[iNdEx]
3295                                 iNdEx++
3296                                 stringLen |= (uint64(b) & 0x7F) << shift
3297                                 if b < 0x80 {
3298                                         break
3299                                 }
3300                         }
3301                         intStringLen := int(stringLen)
3302                         if intStringLen < 0 {
3303                                 return ErrInvalidLengthGenerated
3304                         }
3305                         postIndex := iNdEx + intStringLen
3306                         if postIndex > l {
3307                                 return io.ErrUnexpectedEOF
3308                         }
3309                         m.MetricName = string(dAtA[iNdEx:postIndex])
3310                         iNdEx = postIndex
3311                 case 3:
3312                         if wireType != 2 {
3313                                 return fmt.Errorf("proto: wrong wireType = %d for field TargetValue", wireType)
3314                         }
3315                         var msglen int
3316                         for shift := uint(0); ; shift += 7 {
3317                                 if shift >= 64 {
3318                                         return ErrIntOverflowGenerated
3319                                 }
3320                                 if iNdEx >= l {
3321                                         return io.ErrUnexpectedEOF
3322                                 }
3323                                 b := dAtA[iNdEx]
3324                                 iNdEx++
3325                                 msglen |= (int(b) & 0x7F) << shift
3326                                 if b < 0x80 {
3327                                         break
3328                                 }
3329                         }
3330                         if msglen < 0 {
3331                                 return ErrInvalidLengthGenerated
3332                         }
3333                         postIndex := iNdEx + msglen
3334                         if postIndex > l {
3335                                 return io.ErrUnexpectedEOF
3336                         }
3337                         if err := m.TargetValue.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3338                                 return err
3339                         }
3340                         iNdEx = postIndex
3341                 case 4:
3342                         if wireType != 2 {
3343                                 return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType)
3344                         }
3345                         var msglen int
3346                         for shift := uint(0); ; shift += 7 {
3347                                 if shift >= 64 {
3348                                         return ErrIntOverflowGenerated
3349                                 }
3350                                 if iNdEx >= l {
3351                                         return io.ErrUnexpectedEOF
3352                                 }
3353                                 b := dAtA[iNdEx]
3354                                 iNdEx++
3355                                 msglen |= (int(b) & 0x7F) << shift
3356                                 if b < 0x80 {
3357                                         break
3358                                 }
3359                         }
3360                         if msglen < 0 {
3361                                 return ErrInvalidLengthGenerated
3362                         }
3363                         postIndex := iNdEx + msglen
3364                         if postIndex > l {
3365                                 return io.ErrUnexpectedEOF
3366                         }
3367                         if m.Selector == nil {
3368                                 m.Selector = &k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector{}
3369                         }
3370                         if err := m.Selector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3371                                 return err
3372                         }
3373                         iNdEx = postIndex
3374                 case 5:
3375                         if wireType != 2 {
3376                                 return fmt.Errorf("proto: wrong wireType = %d for field AverageValue", wireType)
3377                         }
3378                         var msglen int
3379                         for shift := uint(0); ; shift += 7 {
3380                                 if shift >= 64 {
3381                                         return ErrIntOverflowGenerated
3382                                 }
3383                                 if iNdEx >= l {
3384                                         return io.ErrUnexpectedEOF
3385                                 }
3386                                 b := dAtA[iNdEx]
3387                                 iNdEx++
3388                                 msglen |= (int(b) & 0x7F) << shift
3389                                 if b < 0x80 {
3390                                         break
3391                                 }
3392                         }
3393                         if msglen < 0 {
3394                                 return ErrInvalidLengthGenerated
3395                         }
3396                         postIndex := iNdEx + msglen
3397                         if postIndex > l {
3398                                 return io.ErrUnexpectedEOF
3399                         }
3400                         if m.AverageValue == nil {
3401                                 m.AverageValue = &k8s_io_apimachinery_pkg_api_resource.Quantity{}
3402                         }
3403                         if err := m.AverageValue.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3404                                 return err
3405                         }
3406                         iNdEx = postIndex
3407                 default:
3408                         iNdEx = preIndex
3409                         skippy, err := skipGenerated(dAtA[iNdEx:])
3410                         if err != nil {
3411                                 return err
3412                         }
3413                         if skippy < 0 {
3414                                 return ErrInvalidLengthGenerated
3415                         }
3416                         if (iNdEx + skippy) > l {
3417                                 return io.ErrUnexpectedEOF
3418                         }
3419                         iNdEx += skippy
3420                 }
3421         }
3422
3423         if iNdEx > l {
3424                 return io.ErrUnexpectedEOF
3425         }
3426         return nil
3427 }
3428 func (m *ObjectMetricStatus) Unmarshal(dAtA []byte) error {
3429         l := len(dAtA)
3430         iNdEx := 0
3431         for iNdEx < l {
3432                 preIndex := iNdEx
3433                 var wire uint64
3434                 for shift := uint(0); ; shift += 7 {
3435                         if shift >= 64 {
3436                                 return ErrIntOverflowGenerated
3437                         }
3438                         if iNdEx >= l {
3439                                 return io.ErrUnexpectedEOF
3440                         }
3441                         b := dAtA[iNdEx]
3442                         iNdEx++
3443                         wire |= (uint64(b) & 0x7F) << shift
3444                         if b < 0x80 {
3445                                 break
3446                         }
3447                 }
3448                 fieldNum := int32(wire >> 3)
3449                 wireType := int(wire & 0x7)
3450                 if wireType == 4 {
3451                         return fmt.Errorf("proto: ObjectMetricStatus: wiretype end group for non-group")
3452                 }
3453                 if fieldNum <= 0 {
3454                         return fmt.Errorf("proto: ObjectMetricStatus: illegal tag %d (wire type %d)", fieldNum, wire)
3455                 }
3456                 switch fieldNum {
3457                 case 1:
3458                         if wireType != 2 {
3459                                 return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType)
3460                         }
3461                         var msglen int
3462                         for shift := uint(0); ; shift += 7 {
3463                                 if shift >= 64 {
3464                                         return ErrIntOverflowGenerated
3465                                 }
3466                                 if iNdEx >= l {
3467                                         return io.ErrUnexpectedEOF
3468                                 }
3469                                 b := dAtA[iNdEx]
3470                                 iNdEx++
3471                                 msglen |= (int(b) & 0x7F) << shift
3472                                 if b < 0x80 {
3473                                         break
3474                                 }
3475                         }
3476                         if msglen < 0 {
3477                                 return ErrInvalidLengthGenerated
3478                         }
3479                         postIndex := iNdEx + msglen
3480                         if postIndex > l {
3481                                 return io.ErrUnexpectedEOF
3482                         }
3483                         if err := m.Target.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3484                                 return err
3485                         }
3486                         iNdEx = postIndex
3487                 case 2:
3488                         if wireType != 2 {
3489                                 return fmt.Errorf("proto: wrong wireType = %d for field MetricName", wireType)
3490                         }
3491                         var stringLen uint64
3492                         for shift := uint(0); ; shift += 7 {
3493                                 if shift >= 64 {
3494                                         return ErrIntOverflowGenerated
3495                                 }
3496                                 if iNdEx >= l {
3497                                         return io.ErrUnexpectedEOF
3498                                 }
3499                                 b := dAtA[iNdEx]
3500                                 iNdEx++
3501                                 stringLen |= (uint64(b) & 0x7F) << shift
3502                                 if b < 0x80 {
3503                                         break
3504                                 }
3505                         }
3506                         intStringLen := int(stringLen)
3507                         if intStringLen < 0 {
3508                                 return ErrInvalidLengthGenerated
3509                         }
3510                         postIndex := iNdEx + intStringLen
3511                         if postIndex > l {
3512                                 return io.ErrUnexpectedEOF
3513                         }
3514                         m.MetricName = string(dAtA[iNdEx:postIndex])
3515                         iNdEx = postIndex
3516                 case 3:
3517                         if wireType != 2 {
3518                                 return fmt.Errorf("proto: wrong wireType = %d for field CurrentValue", wireType)
3519                         }
3520                         var msglen int
3521                         for shift := uint(0); ; shift += 7 {
3522                                 if shift >= 64 {
3523                                         return ErrIntOverflowGenerated
3524                                 }
3525                                 if iNdEx >= l {
3526                                         return io.ErrUnexpectedEOF
3527                                 }
3528                                 b := dAtA[iNdEx]
3529                                 iNdEx++
3530                                 msglen |= (int(b) & 0x7F) << shift
3531                                 if b < 0x80 {
3532                                         break
3533                                 }
3534                         }
3535                         if msglen < 0 {
3536                                 return ErrInvalidLengthGenerated
3537                         }
3538                         postIndex := iNdEx + msglen
3539                         if postIndex > l {
3540                                 return io.ErrUnexpectedEOF
3541                         }
3542                         if err := m.CurrentValue.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3543                                 return err
3544                         }
3545                         iNdEx = postIndex
3546                 case 4:
3547                         if wireType != 2 {
3548                                 return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType)
3549                         }
3550                         var msglen int
3551                         for shift := uint(0); ; shift += 7 {
3552                                 if shift >= 64 {
3553                                         return ErrIntOverflowGenerated
3554                                 }
3555                                 if iNdEx >= l {
3556                                         return io.ErrUnexpectedEOF
3557                                 }
3558                                 b := dAtA[iNdEx]
3559                                 iNdEx++
3560                                 msglen |= (int(b) & 0x7F) << shift
3561                                 if b < 0x80 {
3562                                         break
3563                                 }
3564                         }
3565                         if msglen < 0 {
3566                                 return ErrInvalidLengthGenerated
3567                         }
3568                         postIndex := iNdEx + msglen
3569                         if postIndex > l {
3570                                 return io.ErrUnexpectedEOF
3571                         }
3572                         if m.Selector == nil {
3573                                 m.Selector = &k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector{}
3574                         }
3575                         if err := m.Selector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3576                                 return err
3577                         }
3578                         iNdEx = postIndex
3579                 case 5:
3580                         if wireType != 2 {
3581                                 return fmt.Errorf("proto: wrong wireType = %d for field AverageValue", wireType)
3582                         }
3583                         var msglen int
3584                         for shift := uint(0); ; shift += 7 {
3585                                 if shift >= 64 {
3586                                         return ErrIntOverflowGenerated
3587                                 }
3588                                 if iNdEx >= l {
3589                                         return io.ErrUnexpectedEOF
3590                                 }
3591                                 b := dAtA[iNdEx]
3592                                 iNdEx++
3593                                 msglen |= (int(b) & 0x7F) << shift
3594                                 if b < 0x80 {
3595                                         break
3596                                 }
3597                         }
3598                         if msglen < 0 {
3599                                 return ErrInvalidLengthGenerated
3600                         }
3601                         postIndex := iNdEx + msglen
3602                         if postIndex > l {
3603                                 return io.ErrUnexpectedEOF
3604                         }
3605                         if m.AverageValue == nil {
3606                                 m.AverageValue = &k8s_io_apimachinery_pkg_api_resource.Quantity{}
3607                         }
3608                         if err := m.AverageValue.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3609                                 return err
3610                         }
3611                         iNdEx = postIndex
3612                 default:
3613                         iNdEx = preIndex
3614                         skippy, err := skipGenerated(dAtA[iNdEx:])
3615                         if err != nil {
3616                                 return err
3617                         }
3618                         if skippy < 0 {
3619                                 return ErrInvalidLengthGenerated
3620                         }
3621                         if (iNdEx + skippy) > l {
3622                                 return io.ErrUnexpectedEOF
3623                         }
3624                         iNdEx += skippy
3625                 }
3626         }
3627
3628         if iNdEx > l {
3629                 return io.ErrUnexpectedEOF
3630         }
3631         return nil
3632 }
3633 func (m *PodsMetricSource) Unmarshal(dAtA []byte) error {
3634         l := len(dAtA)
3635         iNdEx := 0
3636         for iNdEx < l {
3637                 preIndex := iNdEx
3638                 var wire uint64
3639                 for shift := uint(0); ; shift += 7 {
3640                         if shift >= 64 {
3641                                 return ErrIntOverflowGenerated
3642                         }
3643                         if iNdEx >= l {
3644                                 return io.ErrUnexpectedEOF
3645                         }
3646                         b := dAtA[iNdEx]
3647                         iNdEx++
3648                         wire |= (uint64(b) & 0x7F) << shift
3649                         if b < 0x80 {
3650                                 break
3651                         }
3652                 }
3653                 fieldNum := int32(wire >> 3)
3654                 wireType := int(wire & 0x7)
3655                 if wireType == 4 {
3656                         return fmt.Errorf("proto: PodsMetricSource: wiretype end group for non-group")
3657                 }
3658                 if fieldNum <= 0 {
3659                         return fmt.Errorf("proto: PodsMetricSource: illegal tag %d (wire type %d)", fieldNum, wire)
3660                 }
3661                 switch fieldNum {
3662                 case 1:
3663                         if wireType != 2 {
3664                                 return fmt.Errorf("proto: wrong wireType = %d for field MetricName", wireType)
3665                         }
3666                         var stringLen uint64
3667                         for shift := uint(0); ; shift += 7 {
3668                                 if shift >= 64 {
3669                                         return ErrIntOverflowGenerated
3670                                 }
3671                                 if iNdEx >= l {
3672                                         return io.ErrUnexpectedEOF
3673                                 }
3674                                 b := dAtA[iNdEx]
3675                                 iNdEx++
3676                                 stringLen |= (uint64(b) & 0x7F) << shift
3677                                 if b < 0x80 {
3678                                         break
3679                                 }
3680                         }
3681                         intStringLen := int(stringLen)
3682                         if intStringLen < 0 {
3683                                 return ErrInvalidLengthGenerated
3684                         }
3685                         postIndex := iNdEx + intStringLen
3686                         if postIndex > l {
3687                                 return io.ErrUnexpectedEOF
3688                         }
3689                         m.MetricName = string(dAtA[iNdEx:postIndex])
3690                         iNdEx = postIndex
3691                 case 2:
3692                         if wireType != 2 {
3693                                 return fmt.Errorf("proto: wrong wireType = %d for field TargetAverageValue", wireType)
3694                         }
3695                         var msglen int
3696                         for shift := uint(0); ; shift += 7 {
3697                                 if shift >= 64 {
3698                                         return ErrIntOverflowGenerated
3699                                 }
3700                                 if iNdEx >= l {
3701                                         return io.ErrUnexpectedEOF
3702                                 }
3703                                 b := dAtA[iNdEx]
3704                                 iNdEx++
3705                                 msglen |= (int(b) & 0x7F) << shift
3706                                 if b < 0x80 {
3707                                         break
3708                                 }
3709                         }
3710                         if msglen < 0 {
3711                                 return ErrInvalidLengthGenerated
3712                         }
3713                         postIndex := iNdEx + msglen
3714                         if postIndex > l {
3715                                 return io.ErrUnexpectedEOF
3716                         }
3717                         if err := m.TargetAverageValue.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3718                                 return err
3719                         }
3720                         iNdEx = postIndex
3721                 case 3:
3722                         if wireType != 2 {
3723                                 return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType)
3724                         }
3725                         var msglen int
3726                         for shift := uint(0); ; shift += 7 {
3727                                 if shift >= 64 {
3728                                         return ErrIntOverflowGenerated
3729                                 }
3730                                 if iNdEx >= l {
3731                                         return io.ErrUnexpectedEOF
3732                                 }
3733                                 b := dAtA[iNdEx]
3734                                 iNdEx++
3735                                 msglen |= (int(b) & 0x7F) << shift
3736                                 if b < 0x80 {
3737                                         break
3738                                 }
3739                         }
3740                         if msglen < 0 {
3741                                 return ErrInvalidLengthGenerated
3742                         }
3743                         postIndex := iNdEx + msglen
3744                         if postIndex > l {
3745                                 return io.ErrUnexpectedEOF
3746                         }
3747                         if m.Selector == nil {
3748                                 m.Selector = &k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector{}
3749                         }
3750                         if err := m.Selector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3751                                 return err
3752                         }
3753                         iNdEx = postIndex
3754                 default:
3755                         iNdEx = preIndex
3756                         skippy, err := skipGenerated(dAtA[iNdEx:])
3757                         if err != nil {
3758                                 return err
3759                         }
3760                         if skippy < 0 {
3761                                 return ErrInvalidLengthGenerated
3762                         }
3763                         if (iNdEx + skippy) > l {
3764                                 return io.ErrUnexpectedEOF
3765                         }
3766                         iNdEx += skippy
3767                 }
3768         }
3769
3770         if iNdEx > l {
3771                 return io.ErrUnexpectedEOF
3772         }
3773         return nil
3774 }
3775 func (m *PodsMetricStatus) Unmarshal(dAtA []byte) error {
3776         l := len(dAtA)
3777         iNdEx := 0
3778         for iNdEx < l {
3779                 preIndex := iNdEx
3780                 var wire uint64
3781                 for shift := uint(0); ; shift += 7 {
3782                         if shift >= 64 {
3783                                 return ErrIntOverflowGenerated
3784                         }
3785                         if iNdEx >= l {
3786                                 return io.ErrUnexpectedEOF
3787                         }
3788                         b := dAtA[iNdEx]
3789                         iNdEx++
3790                         wire |= (uint64(b) & 0x7F) << shift
3791                         if b < 0x80 {
3792                                 break
3793                         }
3794                 }
3795                 fieldNum := int32(wire >> 3)
3796                 wireType := int(wire & 0x7)
3797                 if wireType == 4 {
3798                         return fmt.Errorf("proto: PodsMetricStatus: wiretype end group for non-group")
3799                 }
3800                 if fieldNum <= 0 {
3801                         return fmt.Errorf("proto: PodsMetricStatus: illegal tag %d (wire type %d)", fieldNum, wire)
3802                 }
3803                 switch fieldNum {
3804                 case 1:
3805                         if wireType != 2 {
3806                                 return fmt.Errorf("proto: wrong wireType = %d for field MetricName", wireType)
3807                         }
3808                         var stringLen uint64
3809                         for shift := uint(0); ; shift += 7 {
3810                                 if shift >= 64 {
3811                                         return ErrIntOverflowGenerated
3812                                 }
3813                                 if iNdEx >= l {
3814                                         return io.ErrUnexpectedEOF
3815                                 }
3816                                 b := dAtA[iNdEx]
3817                                 iNdEx++
3818                                 stringLen |= (uint64(b) & 0x7F) << shift
3819                                 if b < 0x80 {
3820                                         break
3821                                 }
3822                         }
3823                         intStringLen := int(stringLen)
3824                         if intStringLen < 0 {
3825                                 return ErrInvalidLengthGenerated
3826                         }
3827                         postIndex := iNdEx + intStringLen
3828                         if postIndex > l {
3829                                 return io.ErrUnexpectedEOF
3830                         }
3831                         m.MetricName = string(dAtA[iNdEx:postIndex])
3832                         iNdEx = postIndex
3833                 case 2:
3834                         if wireType != 2 {
3835                                 return fmt.Errorf("proto: wrong wireType = %d for field CurrentAverageValue", wireType)
3836                         }
3837                         var msglen int
3838                         for shift := uint(0); ; shift += 7 {
3839                                 if shift >= 64 {
3840                                         return ErrIntOverflowGenerated
3841                                 }
3842                                 if iNdEx >= l {
3843                                         return io.ErrUnexpectedEOF
3844                                 }
3845                                 b := dAtA[iNdEx]
3846                                 iNdEx++
3847                                 msglen |= (int(b) & 0x7F) << shift
3848                                 if b < 0x80 {
3849                                         break
3850                                 }
3851                         }
3852                         if msglen < 0 {
3853                                 return ErrInvalidLengthGenerated
3854                         }
3855                         postIndex := iNdEx + msglen
3856                         if postIndex > l {
3857                                 return io.ErrUnexpectedEOF
3858                         }
3859                         if err := m.CurrentAverageValue.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3860                                 return err
3861                         }
3862                         iNdEx = postIndex
3863                 case 3:
3864                         if wireType != 2 {
3865                                 return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType)
3866                         }
3867                         var msglen int
3868                         for shift := uint(0); ; shift += 7 {
3869                                 if shift >= 64 {
3870                                         return ErrIntOverflowGenerated
3871                                 }
3872                                 if iNdEx >= l {
3873                                         return io.ErrUnexpectedEOF
3874                                 }
3875                                 b := dAtA[iNdEx]
3876                                 iNdEx++
3877                                 msglen |= (int(b) & 0x7F) << shift
3878                                 if b < 0x80 {
3879                                         break
3880                                 }
3881                         }
3882                         if msglen < 0 {
3883                                 return ErrInvalidLengthGenerated
3884                         }
3885                         postIndex := iNdEx + msglen
3886                         if postIndex > l {
3887                                 return io.ErrUnexpectedEOF
3888                         }
3889                         if m.Selector == nil {
3890                                 m.Selector = &k8s_io_apimachinery_pkg_apis_meta_v1.LabelSelector{}
3891                         }
3892                         if err := m.Selector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
3893                                 return err
3894                         }
3895                         iNdEx = postIndex
3896                 default:
3897                         iNdEx = preIndex
3898                         skippy, err := skipGenerated(dAtA[iNdEx:])
3899                         if err != nil {
3900                                 return err
3901                         }
3902                         if skippy < 0 {
3903                                 return ErrInvalidLengthGenerated
3904                         }
3905                         if (iNdEx + skippy) > l {
3906                                 return io.ErrUnexpectedEOF
3907                         }
3908                         iNdEx += skippy
3909                 }
3910         }
3911
3912         if iNdEx > l {
3913                 return io.ErrUnexpectedEOF
3914         }
3915         return nil
3916 }
3917 func (m *ResourceMetricSource) Unmarshal(dAtA []byte) error {
3918         l := len(dAtA)
3919         iNdEx := 0
3920         for iNdEx < l {
3921                 preIndex := iNdEx
3922                 var wire uint64
3923                 for shift := uint(0); ; shift += 7 {
3924                         if shift >= 64 {
3925                                 return ErrIntOverflowGenerated
3926                         }
3927                         if iNdEx >= l {
3928                                 return io.ErrUnexpectedEOF
3929                         }
3930                         b := dAtA[iNdEx]
3931                         iNdEx++
3932                         wire |= (uint64(b) & 0x7F) << shift
3933                         if b < 0x80 {
3934                                 break
3935                         }
3936                 }
3937                 fieldNum := int32(wire >> 3)
3938                 wireType := int(wire & 0x7)
3939                 if wireType == 4 {
3940                         return fmt.Errorf("proto: ResourceMetricSource: wiretype end group for non-group")
3941                 }
3942                 if fieldNum <= 0 {
3943                         return fmt.Errorf("proto: ResourceMetricSource: illegal tag %d (wire type %d)", fieldNum, wire)
3944                 }
3945                 switch fieldNum {
3946                 case 1:
3947                         if wireType != 2 {
3948                                 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
3949                         }
3950                         var stringLen uint64
3951                         for shift := uint(0); ; shift += 7 {
3952                                 if shift >= 64 {
3953                                         return ErrIntOverflowGenerated
3954                                 }
3955                                 if iNdEx >= l {
3956                                         return io.ErrUnexpectedEOF
3957                                 }
3958                                 b := dAtA[iNdEx]
3959                                 iNdEx++
3960                                 stringLen |= (uint64(b) & 0x7F) << shift
3961                                 if b < 0x80 {
3962                                         break
3963                                 }
3964                         }
3965                         intStringLen := int(stringLen)
3966                         if intStringLen < 0 {
3967                                 return ErrInvalidLengthGenerated
3968                         }
3969                         postIndex := iNdEx + intStringLen
3970                         if postIndex > l {
3971                                 return io.ErrUnexpectedEOF
3972                         }
3973                         m.Name = k8s_io_api_core_v1.ResourceName(dAtA[iNdEx:postIndex])
3974                         iNdEx = postIndex
3975                 case 2:
3976                         if wireType != 0 {
3977                                 return fmt.Errorf("proto: wrong wireType = %d for field TargetAverageUtilization", wireType)
3978                         }
3979                         var v int32
3980                         for shift := uint(0); ; shift += 7 {
3981                                 if shift >= 64 {
3982                                         return ErrIntOverflowGenerated
3983                                 }
3984                                 if iNdEx >= l {
3985                                         return io.ErrUnexpectedEOF
3986                                 }
3987                                 b := dAtA[iNdEx]
3988                                 iNdEx++
3989                                 v |= (int32(b) & 0x7F) << shift
3990                                 if b < 0x80 {
3991                                         break
3992                                 }
3993                         }
3994                         m.TargetAverageUtilization = &v
3995                 case 3:
3996                         if wireType != 2 {
3997                                 return fmt.Errorf("proto: wrong wireType = %d for field TargetAverageValue", wireType)
3998                         }
3999                         var msglen int
4000                         for shift := uint(0); ; shift += 7 {
4001                                 if shift >= 64 {
4002                                         return ErrIntOverflowGenerated
4003                                 }
4004                                 if iNdEx >= l {
4005                                         return io.ErrUnexpectedEOF
4006                                 }
4007                                 b := dAtA[iNdEx]
4008                                 iNdEx++
4009                                 msglen |= (int(b) & 0x7F) << shift
4010                                 if b < 0x80 {
4011                                         break
4012                                 }
4013                         }
4014                         if msglen < 0 {
4015                                 return ErrInvalidLengthGenerated
4016                         }
4017                         postIndex := iNdEx + msglen
4018                         if postIndex > l {
4019                                 return io.ErrUnexpectedEOF
4020                         }
4021                         if m.TargetAverageValue == nil {
4022                                 m.TargetAverageValue = &k8s_io_apimachinery_pkg_api_resource.Quantity{}
4023                         }
4024                         if err := m.TargetAverageValue.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4025                                 return err
4026                         }
4027                         iNdEx = postIndex
4028                 default:
4029                         iNdEx = preIndex
4030                         skippy, err := skipGenerated(dAtA[iNdEx:])
4031                         if err != nil {
4032                                 return err
4033                         }
4034                         if skippy < 0 {
4035                                 return ErrInvalidLengthGenerated
4036                         }
4037                         if (iNdEx + skippy) > l {
4038                                 return io.ErrUnexpectedEOF
4039                         }
4040                         iNdEx += skippy
4041                 }
4042         }
4043
4044         if iNdEx > l {
4045                 return io.ErrUnexpectedEOF
4046         }
4047         return nil
4048 }
4049 func (m *ResourceMetricStatus) Unmarshal(dAtA []byte) error {
4050         l := len(dAtA)
4051         iNdEx := 0
4052         for iNdEx < l {
4053                 preIndex := iNdEx
4054                 var wire uint64
4055                 for shift := uint(0); ; shift += 7 {
4056                         if shift >= 64 {
4057                                 return ErrIntOverflowGenerated
4058                         }
4059                         if iNdEx >= l {
4060                                 return io.ErrUnexpectedEOF
4061                         }
4062                         b := dAtA[iNdEx]
4063                         iNdEx++
4064                         wire |= (uint64(b) & 0x7F) << shift
4065                         if b < 0x80 {
4066                                 break
4067                         }
4068                 }
4069                 fieldNum := int32(wire >> 3)
4070                 wireType := int(wire & 0x7)
4071                 if wireType == 4 {
4072                         return fmt.Errorf("proto: ResourceMetricStatus: wiretype end group for non-group")
4073                 }
4074                 if fieldNum <= 0 {
4075                         return fmt.Errorf("proto: ResourceMetricStatus: illegal tag %d (wire type %d)", fieldNum, wire)
4076                 }
4077                 switch fieldNum {
4078                 case 1:
4079                         if wireType != 2 {
4080                                 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
4081                         }
4082                         var stringLen uint64
4083                         for shift := uint(0); ; shift += 7 {
4084                                 if shift >= 64 {
4085                                         return ErrIntOverflowGenerated
4086                                 }
4087                                 if iNdEx >= l {
4088                                         return io.ErrUnexpectedEOF
4089                                 }
4090                                 b := dAtA[iNdEx]
4091                                 iNdEx++
4092                                 stringLen |= (uint64(b) & 0x7F) << shift
4093                                 if b < 0x80 {
4094                                         break
4095                                 }
4096                         }
4097                         intStringLen := int(stringLen)
4098                         if intStringLen < 0 {
4099                                 return ErrInvalidLengthGenerated
4100                         }
4101                         postIndex := iNdEx + intStringLen
4102                         if postIndex > l {
4103                                 return io.ErrUnexpectedEOF
4104                         }
4105                         m.Name = k8s_io_api_core_v1.ResourceName(dAtA[iNdEx:postIndex])
4106                         iNdEx = postIndex
4107                 case 2:
4108                         if wireType != 0 {
4109                                 return fmt.Errorf("proto: wrong wireType = %d for field CurrentAverageUtilization", wireType)
4110                         }
4111                         var v int32
4112                         for shift := uint(0); ; shift += 7 {
4113                                 if shift >= 64 {
4114                                         return ErrIntOverflowGenerated
4115                                 }
4116                                 if iNdEx >= l {
4117                                         return io.ErrUnexpectedEOF
4118                                 }
4119                                 b := dAtA[iNdEx]
4120                                 iNdEx++
4121                                 v |= (int32(b) & 0x7F) << shift
4122                                 if b < 0x80 {
4123                                         break
4124                                 }
4125                         }
4126                         m.CurrentAverageUtilization = &v
4127                 case 3:
4128                         if wireType != 2 {
4129                                 return fmt.Errorf("proto: wrong wireType = %d for field CurrentAverageValue", wireType)
4130                         }
4131                         var msglen int
4132                         for shift := uint(0); ; shift += 7 {
4133                                 if shift >= 64 {
4134                                         return ErrIntOverflowGenerated
4135                                 }
4136                                 if iNdEx >= l {
4137                                         return io.ErrUnexpectedEOF
4138                                 }
4139                                 b := dAtA[iNdEx]
4140                                 iNdEx++
4141                                 msglen |= (int(b) & 0x7F) << shift
4142                                 if b < 0x80 {
4143                                         break
4144                                 }
4145                         }
4146                         if msglen < 0 {
4147                                 return ErrInvalidLengthGenerated
4148                         }
4149                         postIndex := iNdEx + msglen
4150                         if postIndex > l {
4151                                 return io.ErrUnexpectedEOF
4152                         }
4153                         if err := m.CurrentAverageValue.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4154                                 return err
4155                         }
4156                         iNdEx = postIndex
4157                 default:
4158                         iNdEx = preIndex
4159                         skippy, err := skipGenerated(dAtA[iNdEx:])
4160                         if err != nil {
4161                                 return err
4162                         }
4163                         if skippy < 0 {
4164                                 return ErrInvalidLengthGenerated
4165                         }
4166                         if (iNdEx + skippy) > l {
4167                                 return io.ErrUnexpectedEOF
4168                         }
4169                         iNdEx += skippy
4170                 }
4171         }
4172
4173         if iNdEx > l {
4174                 return io.ErrUnexpectedEOF
4175         }
4176         return nil
4177 }
4178 func (m *Scale) Unmarshal(dAtA []byte) error {
4179         l := len(dAtA)
4180         iNdEx := 0
4181         for iNdEx < l {
4182                 preIndex := iNdEx
4183                 var wire uint64
4184                 for shift := uint(0); ; shift += 7 {
4185                         if shift >= 64 {
4186                                 return ErrIntOverflowGenerated
4187                         }
4188                         if iNdEx >= l {
4189                                 return io.ErrUnexpectedEOF
4190                         }
4191                         b := dAtA[iNdEx]
4192                         iNdEx++
4193                         wire |= (uint64(b) & 0x7F) << shift
4194                         if b < 0x80 {
4195                                 break
4196                         }
4197                 }
4198                 fieldNum := int32(wire >> 3)
4199                 wireType := int(wire & 0x7)
4200                 if wireType == 4 {
4201                         return fmt.Errorf("proto: Scale: wiretype end group for non-group")
4202                 }
4203                 if fieldNum <= 0 {
4204                         return fmt.Errorf("proto: Scale: illegal tag %d (wire type %d)", fieldNum, wire)
4205                 }
4206                 switch fieldNum {
4207                 case 1:
4208                         if wireType != 2 {
4209                                 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
4210                         }
4211                         var msglen int
4212                         for shift := uint(0); ; shift += 7 {
4213                                 if shift >= 64 {
4214                                         return ErrIntOverflowGenerated
4215                                 }
4216                                 if iNdEx >= l {
4217                                         return io.ErrUnexpectedEOF
4218                                 }
4219                                 b := dAtA[iNdEx]
4220                                 iNdEx++
4221                                 msglen |= (int(b) & 0x7F) << shift
4222                                 if b < 0x80 {
4223                                         break
4224                                 }
4225                         }
4226                         if msglen < 0 {
4227                                 return ErrInvalidLengthGenerated
4228                         }
4229                         postIndex := iNdEx + msglen
4230                         if postIndex > l {
4231                                 return io.ErrUnexpectedEOF
4232                         }
4233                         if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4234                                 return err
4235                         }
4236                         iNdEx = postIndex
4237                 case 2:
4238                         if wireType != 2 {
4239                                 return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
4240                         }
4241                         var msglen int
4242                         for shift := uint(0); ; shift += 7 {
4243                                 if shift >= 64 {
4244                                         return ErrIntOverflowGenerated
4245                                 }
4246                                 if iNdEx >= l {
4247                                         return io.ErrUnexpectedEOF
4248                                 }
4249                                 b := dAtA[iNdEx]
4250                                 iNdEx++
4251                                 msglen |= (int(b) & 0x7F) << shift
4252                                 if b < 0x80 {
4253                                         break
4254                                 }
4255                         }
4256                         if msglen < 0 {
4257                                 return ErrInvalidLengthGenerated
4258                         }
4259                         postIndex := iNdEx + msglen
4260                         if postIndex > l {
4261                                 return io.ErrUnexpectedEOF
4262                         }
4263                         if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4264                                 return err
4265                         }
4266                         iNdEx = postIndex
4267                 case 3:
4268                         if wireType != 2 {
4269                                 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
4270                         }
4271                         var msglen int
4272                         for shift := uint(0); ; shift += 7 {
4273                                 if shift >= 64 {
4274                                         return ErrIntOverflowGenerated
4275                                 }
4276                                 if iNdEx >= l {
4277                                         return io.ErrUnexpectedEOF
4278                                 }
4279                                 b := dAtA[iNdEx]
4280                                 iNdEx++
4281                                 msglen |= (int(b) & 0x7F) << shift
4282                                 if b < 0x80 {
4283                                         break
4284                                 }
4285                         }
4286                         if msglen < 0 {
4287                                 return ErrInvalidLengthGenerated
4288                         }
4289                         postIndex := iNdEx + msglen
4290                         if postIndex > l {
4291                                 return io.ErrUnexpectedEOF
4292                         }
4293                         if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
4294                                 return err
4295                         }
4296                         iNdEx = postIndex
4297                 default:
4298                         iNdEx = preIndex
4299                         skippy, err := skipGenerated(dAtA[iNdEx:])
4300                         if err != nil {
4301                                 return err
4302                         }
4303                         if skippy < 0 {
4304                                 return ErrInvalidLengthGenerated
4305                         }
4306                         if (iNdEx + skippy) > l {
4307                                 return io.ErrUnexpectedEOF
4308                         }
4309                         iNdEx += skippy
4310                 }
4311         }
4312
4313         if iNdEx > l {
4314                 return io.ErrUnexpectedEOF
4315         }
4316         return nil
4317 }
4318 func (m *ScaleSpec) Unmarshal(dAtA []byte) error {
4319         l := len(dAtA)
4320         iNdEx := 0
4321         for iNdEx < l {
4322                 preIndex := iNdEx
4323                 var wire uint64
4324                 for shift := uint(0); ; shift += 7 {
4325                         if shift >= 64 {
4326                                 return ErrIntOverflowGenerated
4327                         }
4328                         if iNdEx >= l {
4329                                 return io.ErrUnexpectedEOF
4330                         }
4331                         b := dAtA[iNdEx]
4332                         iNdEx++
4333                         wire |= (uint64(b) & 0x7F) << shift
4334                         if b < 0x80 {
4335                                 break
4336                         }
4337                 }
4338                 fieldNum := int32(wire >> 3)
4339                 wireType := int(wire & 0x7)
4340                 if wireType == 4 {
4341                         return fmt.Errorf("proto: ScaleSpec: wiretype end group for non-group")
4342                 }
4343                 if fieldNum <= 0 {
4344                         return fmt.Errorf("proto: ScaleSpec: illegal tag %d (wire type %d)", fieldNum, wire)
4345                 }
4346                 switch fieldNum {
4347                 case 1:
4348                         if wireType != 0 {
4349                                 return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
4350                         }
4351                         m.Replicas = 0
4352                         for shift := uint(0); ; shift += 7 {
4353                                 if shift >= 64 {
4354                                         return ErrIntOverflowGenerated
4355                                 }
4356                                 if iNdEx >= l {
4357                                         return io.ErrUnexpectedEOF
4358                                 }
4359                                 b := dAtA[iNdEx]
4360                                 iNdEx++
4361                                 m.Replicas |= (int32(b) & 0x7F) << shift
4362                                 if b < 0x80 {
4363                                         break
4364                                 }
4365                         }
4366                 default:
4367                         iNdEx = preIndex
4368                         skippy, err := skipGenerated(dAtA[iNdEx:])
4369                         if err != nil {
4370                                 return err
4371                         }
4372                         if skippy < 0 {
4373                                 return ErrInvalidLengthGenerated
4374                         }
4375                         if (iNdEx + skippy) > l {
4376                                 return io.ErrUnexpectedEOF
4377                         }
4378                         iNdEx += skippy
4379                 }
4380         }
4381
4382         if iNdEx > l {
4383                 return io.ErrUnexpectedEOF
4384         }
4385         return nil
4386 }
4387 func (m *ScaleStatus) Unmarshal(dAtA []byte) error {
4388         l := len(dAtA)
4389         iNdEx := 0
4390         for iNdEx < l {
4391                 preIndex := iNdEx
4392                 var wire uint64
4393                 for shift := uint(0); ; shift += 7 {
4394                         if shift >= 64 {
4395                                 return ErrIntOverflowGenerated
4396                         }
4397                         if iNdEx >= l {
4398                                 return io.ErrUnexpectedEOF
4399                         }
4400                         b := dAtA[iNdEx]
4401                         iNdEx++
4402                         wire |= (uint64(b) & 0x7F) << shift
4403                         if b < 0x80 {
4404                                 break
4405                         }
4406                 }
4407                 fieldNum := int32(wire >> 3)
4408                 wireType := int(wire & 0x7)
4409                 if wireType == 4 {
4410                         return fmt.Errorf("proto: ScaleStatus: wiretype end group for non-group")
4411                 }
4412                 if fieldNum <= 0 {
4413                         return fmt.Errorf("proto: ScaleStatus: illegal tag %d (wire type %d)", fieldNum, wire)
4414                 }
4415                 switch fieldNum {
4416                 case 1:
4417                         if wireType != 0 {
4418                                 return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)
4419                         }
4420                         m.Replicas = 0
4421                         for shift := uint(0); ; shift += 7 {
4422                                 if shift >= 64 {
4423                                         return ErrIntOverflowGenerated
4424                                 }
4425                                 if iNdEx >= l {
4426                                         return io.ErrUnexpectedEOF
4427                                 }
4428                                 b := dAtA[iNdEx]
4429                                 iNdEx++
4430                                 m.Replicas |= (int32(b) & 0x7F) << shift
4431                                 if b < 0x80 {
4432                                         break
4433                                 }
4434                         }
4435                 case 2:
4436                         if wireType != 2 {
4437                                 return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType)
4438                         }
4439                         var stringLen uint64
4440                         for shift := uint(0); ; shift += 7 {
4441                                 if shift >= 64 {
4442                                         return ErrIntOverflowGenerated
4443                                 }
4444                                 if iNdEx >= l {
4445                                         return io.ErrUnexpectedEOF
4446                                 }
4447                                 b := dAtA[iNdEx]
4448                                 iNdEx++
4449                                 stringLen |= (uint64(b) & 0x7F) << shift
4450                                 if b < 0x80 {
4451                                         break
4452                                 }
4453                         }
4454                         intStringLen := int(stringLen)
4455                         if intStringLen < 0 {
4456                                 return ErrInvalidLengthGenerated
4457                         }
4458                         postIndex := iNdEx + intStringLen
4459                         if postIndex > l {
4460                                 return io.ErrUnexpectedEOF
4461                         }
4462                         m.Selector = string(dAtA[iNdEx:postIndex])
4463                         iNdEx = postIndex
4464                 default:
4465                         iNdEx = preIndex
4466                         skippy, err := skipGenerated(dAtA[iNdEx:])
4467                         if err != nil {
4468                                 return err
4469                         }
4470                         if skippy < 0 {
4471                                 return ErrInvalidLengthGenerated
4472                         }
4473                         if (iNdEx + skippy) > l {
4474                                 return io.ErrUnexpectedEOF
4475                         }
4476                         iNdEx += skippy
4477                 }
4478         }
4479
4480         if iNdEx > l {
4481                 return io.ErrUnexpectedEOF
4482         }
4483         return nil
4484 }
4485 func skipGenerated(dAtA []byte) (n int, err error) {
4486         l := len(dAtA)
4487         iNdEx := 0
4488         for iNdEx < l {
4489                 var wire uint64
4490                 for shift := uint(0); ; shift += 7 {
4491                         if shift >= 64 {
4492                                 return 0, ErrIntOverflowGenerated
4493                         }
4494                         if iNdEx >= l {
4495                                 return 0, io.ErrUnexpectedEOF
4496                         }
4497                         b := dAtA[iNdEx]
4498                         iNdEx++
4499                         wire |= (uint64(b) & 0x7F) << shift
4500                         if b < 0x80 {
4501                                 break
4502                         }
4503                 }
4504                 wireType := int(wire & 0x7)
4505                 switch wireType {
4506                 case 0:
4507                         for shift := uint(0); ; shift += 7 {
4508                                 if shift >= 64 {
4509                                         return 0, ErrIntOverflowGenerated
4510                                 }
4511                                 if iNdEx >= l {
4512                                         return 0, io.ErrUnexpectedEOF
4513                                 }
4514                                 iNdEx++
4515                                 if dAtA[iNdEx-1] < 0x80 {
4516                                         break
4517                                 }
4518                         }
4519                         return iNdEx, nil
4520                 case 1:
4521                         iNdEx += 8
4522                         return iNdEx, nil
4523                 case 2:
4524                         var length int
4525                         for shift := uint(0); ; shift += 7 {
4526                                 if shift >= 64 {
4527                                         return 0, ErrIntOverflowGenerated
4528                                 }
4529                                 if iNdEx >= l {
4530                                         return 0, io.ErrUnexpectedEOF
4531                                 }
4532                                 b := dAtA[iNdEx]
4533                                 iNdEx++
4534                                 length |= (int(b) & 0x7F) << shift
4535                                 if b < 0x80 {
4536                                         break
4537                                 }
4538                         }
4539                         iNdEx += length
4540                         if length < 0 {
4541                                 return 0, ErrInvalidLengthGenerated
4542                         }
4543                         return iNdEx, nil
4544                 case 3:
4545                         for {
4546                                 var innerWire uint64
4547                                 var start int = iNdEx
4548                                 for shift := uint(0); ; shift += 7 {
4549                                         if shift >= 64 {
4550                                                 return 0, ErrIntOverflowGenerated
4551                                         }
4552                                         if iNdEx >= l {
4553                                                 return 0, io.ErrUnexpectedEOF
4554                                         }
4555                                         b := dAtA[iNdEx]
4556                                         iNdEx++
4557                                         innerWire |= (uint64(b) & 0x7F) << shift
4558                                         if b < 0x80 {
4559                                                 break
4560                                         }
4561                                 }
4562                                 innerWireType := int(innerWire & 0x7)
4563                                 if innerWireType == 4 {
4564                                         break
4565                                 }
4566                                 next, err := skipGenerated(dAtA[start:])
4567                                 if err != nil {
4568                                         return 0, err
4569                                 }
4570                                 iNdEx = start + next
4571                         }
4572                         return iNdEx, nil
4573                 case 4:
4574                         return iNdEx, nil
4575                 case 5:
4576                         iNdEx += 4
4577                         return iNdEx, nil
4578                 default:
4579                         return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
4580                 }
4581         }
4582         panic("unreachable")
4583 }
4584
4585 var (
4586         ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling")
4587         ErrIntOverflowGenerated   = fmt.Errorf("proto: integer overflow")
4588 )
4589
4590 func init() {
4591         proto.RegisterFile("k8s.io/kubernetes/vendor/k8s.io/api/autoscaling/v1/generated.proto", fileDescriptorGenerated)
4592 }
4593
4594 var fileDescriptorGenerated = []byte{
4595         // 1516 bytes of a gzipped FileDescriptorProto
4596         0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x58, 0xcf, 0x6f, 0x13, 0xc7,
4597         0x17, 0x8f, 0x7f, 0x24, 0x24, 0xe3, 0x90, 0xe4, 0x3b, 0x20, 0x08, 0xe1, 0x8b, 0x37, 0xda, 0x22,
4598         0x44, 0x7f, 0xb0, 0x6e, 0x52, 0x8a, 0xe8, 0x31, 0x76, 0x4b, 0x41, 0x8d, 0x21, 0x4c, 0x02, 0xa5,
4599         0x3f, 0xc5, 0x64, 0x3d, 0x38, 0x43, 0xbc, 0xbb, 0xd6, 0xec, 0xd8, 0x22, 0x48, 0x95, 0xda, 0x43,
4600         0xef, 0xbd, 0xb4, 0xea, 0xb1, 0x95, 0x7a, 0xed, 0x99, 0x73, 0x6f, 0x1c, 0x39, 0x20, 0x95, 0xd3,
4601         0xaa, 0x6c, 0x8f, 0xfd, 0x0f, 0x38, 0x55, 0xf3, 0xc3, 0xeb, 0x5d, 0xdb, 0xeb, 0x24, 0x26, 0x44,
4602         0x6d, 0x6f, 0x3b, 0x33, 0xef, 0x7d, 0xde, 0xec, 0x7b, 0x6f, 0xde, 0x2f, 0x50, 0xde, 0xbe, 0xec,
4603         0x5b, 0xd4, 0x2b, 0x6d, 0xb7, 0x36, 0x09, 0x73, 0x09, 0x27, 0x7e, 0xa9, 0x4d, 0xdc, 0x9a, 0xc7,
4604         0x4a, 0xfa, 0x00, 0x37, 0x69, 0x09, 0xb7, 0xb8, 0xe7, 0xdb, 0xb8, 0x41, 0xdd, 0x7a, 0xa9, 0xbd,
4605         0x54, 0xaa, 0x13, 0x97, 0x30, 0xcc, 0x49, 0xcd, 0x6a, 0x32, 0x8f, 0x7b, 0xf0, 0x94, 0x22, 0xb5,
4606         0x70, 0x93, 0x5a, 0x31, 0x52, 0xab, 0xbd, 0xb4, 0x70, 0xa1, 0x4e, 0xf9, 0x56, 0x6b, 0xd3, 0xb2,
4607         0x3d, 0xa7, 0x54, 0xf7, 0xea, 0x5e, 0x49, 0x72, 0x6c, 0xb6, 0xee, 0xc9, 0x95, 0x5c, 0xc8, 0x2f,
4608         0x85, 0xb4, 0x60, 0xc6, 0x84, 0xda, 0x1e, 0x23, 0x03, 0xa4, 0x2d, 0x5c, 0xec, 0xd2, 0x38, 0xd8,
4609         0xde, 0xa2, 0x2e, 0x61, 0x3b, 0xa5, 0xe6, 0x76, 0x5d, 0x32, 0x31, 0xe2, 0x7b, 0x2d, 0x66, 0x93,
4610         0x7d, 0x71, 0xf9, 0x25, 0x87, 0x70, 0x3c, 0x48, 0x56, 0x29, 0x8d, 0x8b, 0xb5, 0x5c, 0x4e, 0x9d,
4611         0x7e, 0x31, 0x97, 0x76, 0x63, 0xf0, 0xed, 0x2d, 0xe2, 0xe0, 0x5e, 0x3e, 0xf3, 0xfb, 0x0c, 0x38,
4612         0x5d, 0x61, 0x9e, 0xef, 0xdf, 0x26, 0xcc, 0xa7, 0x9e, 0x7b, 0x63, 0xf3, 0x3e, 0xb1, 0x39, 0x22,
4613         0xf7, 0x08, 0x23, 0xae, 0x4d, 0xe0, 0x22, 0xc8, 0x6f, 0x53, 0xb7, 0x36, 0x9f, 0x59, 0xcc, 0x9c,
4614         0x9f, 0x2a, 0x4f, 0x3f, 0x0e, 0x8c, 0xb1, 0x30, 0x30, 0xf2, 0x1f, 0x51, 0xb7, 0x86, 0xe4, 0x89,
4615         0xa0, 0x70, 0xb1, 0x43, 0xe6, 0xb3, 0x49, 0x8a, 0xeb, 0xd8, 0x21, 0x48, 0x9e, 0xc0, 0x65, 0x00,
4616         0x70, 0x93, 0x6a, 0x01, 0xf3, 0x39, 0x49, 0x07, 0x35, 0x1d, 0x58, 0x59, 0xbb, 0xa6, 0x4f, 0x50,
4617         0x8c, 0xca, 0xfc, 0x21, 0x07, 0x8e, 0x7f, 0xf0, 0x80, 0x13, 0xe6, 0xe2, 0x46, 0x95, 0x70, 0x46,
4618         0xed, 0x75, 0xa9, 0x5f, 0x01, 0xe6, 0xc8, 0xb5, 0x10, 0xa0, 0xaf, 0x15, 0x81, 0x55, 0xa3, 0x13,
4619         0x14, 0xa3, 0x82, 0x1e, 0x98, 0x51, 0xab, 0x75, 0xd2, 0x20, 0x36, 0xf7, 0x98, 0xbc, 0x6c, 0x61,
4620         0xf9, 0x1d, 0xab, 0xeb, 0x40, 0x91, 0xd6, 0xac, 0xe6, 0x76, 0x5d, 0x6c, 0xf8, 0x96, 0x30, 0x8e,
4621         0xd5, 0x5e, 0xb2, 0x56, 0xf1, 0x26, 0x69, 0x74, 0x58, 0xcb, 0x30, 0x0c, 0x8c, 0x99, 0x6a, 0x02,
4622         0x0e, 0xf5, 0xc0, 0x43, 0x0c, 0x0a, 0x1c, 0xb3, 0x3a, 0xe1, 0xb7, 0x71, 0xa3, 0x45, 0xe4, 0x2f,
4623         0x17, 0x96, 0xad, 0x61, 0xd2, 0xac, 0x8e, 0x03, 0x59, 0x37, 0x5b, 0xd8, 0xe5, 0x94, 0xef, 0x94,
4624         0x67, 0xc3, 0xc0, 0x28, 0x6c, 0x74, 0x61, 0x50, 0x1c, 0x13, 0xb6, 0x01, 0x54, 0xcb, 0x95, 0x36,
4625         0x61, 0xb8, 0x4e, 0x94, 0xa4, 0xfc, 0x48, 0x92, 0x4e, 0x84, 0x81, 0x01, 0x37, 0xfa, 0xd0, 0xd0,
4626         0x00, 0x09, 0xe6, 0x4f, 0xfd, 0x86, 0xe1, 0x98, 0xb7, 0xfc, 0x7f, 0x87, 0x61, 0xb6, 0xc0, 0xb4,
4627         0xdd, 0x62, 0x8c, 0xb8, 0x2f, 0x65, 0x99, 0xe3, 0xfa, 0xb7, 0xa6, 0x2b, 0x31, 0x2c, 0x94, 0x40,
4628         0x86, 0x3b, 0xe0, 0x98, 0x5e, 0x1f, 0x80, 0x81, 0x4e, 0x86, 0x81, 0x71, 0xac, 0xd2, 0x0f, 0x87,
4629         0x06, 0xc9, 0x30, 0x1f, 0x65, 0xc1, 0xc9, 0xab, 0x1e, 0xa3, 0x0f, 0x3d, 0x97, 0xe3, 0xc6, 0x9a,
4630         0x57, 0x5b, 0xd1, 0xb1, 0x91, 0x30, 0x78, 0x17, 0x4c, 0x0a, 0xed, 0xd5, 0x30, 0xc7, 0xd2, 0x46,
4631         0x85, 0xe5, 0xb7, 0xf7, 0xa6, 0x6b, 0x15, 0x18, 0xaa, 0x84, 0xe3, 0xae, 0x55, 0xbb, 0x7b, 0x28,
4632         0x42, 0x85, 0x77, 0x40, 0xde, 0x6f, 0x12, 0x5b, 0x5b, 0xf2, 0x92, 0x95, 0x1a, 0xa3, 0xad, 0x94,
4633         0x3b, 0xae, 0x37, 0x89, 0xdd, 0x8d, 0x23, 0x62, 0x85, 0x24, 0x22, 0xbc, 0x0b, 0x26, 0x7c, 0xe9,
4634         0x6b, 0xda, 0x6c, 0x97, 0x47, 0xc0, 0x96, 0xfc, 0xe5, 0x19, 0x8d, 0x3e, 0xa1, 0xd6, 0x48, 0xe3,
4635         0x9a, 0xdf, 0xe6, 0xc0, 0x62, 0x0a, 0x67, 0xc5, 0x73, 0x6b, 0x94, 0x53, 0xcf, 0x85, 0x57, 0x41,
4636         0x9e, 0xef, 0x34, 0x3b, 0x2e, 0x7e, 0xb1, 0x73, 0xd1, 0x8d, 0x9d, 0x26, 0x79, 0x11, 0x18, 0x67,
4637         0x77, 0xe3, 0x17, 0x74, 0x48, 0x22, 0xc0, 0xd5, 0xe8, 0x87, 0xb2, 0x09, 0x2c, 0x7d, 0xad, 0x17,
4638         0x81, 0x31, 0x20, 0x2f, 0x59, 0x11, 0x52, 0xf2, 0xf2, 0x22, 0x22, 0x34, 0xb0, 0xcf, 0x37, 0x18,
4639         0x76, 0x7d, 0x25, 0x89, 0x3a, 0x1d, 0x0f, 0x7f, 0x63, 0x6f, 0x46, 0x16, 0x1c, 0xe5, 0x05, 0x7d,
4640         0x0b, 0xb8, 0xda, 0x87, 0x86, 0x06, 0x48, 0x80, 0xe7, 0xc0, 0x04, 0x23, 0xd8, 0xf7, 0x5c, 0xe9,
4641         0xdc, 0x53, 0x5d, 0xe5, 0x22, 0xb9, 0x8b, 0xf4, 0x29, 0x7c, 0x1d, 0x1c, 0x71, 0x88, 0xef, 0xe3,
4642         0x3a, 0x99, 0x1f, 0x97, 0x84, 0xb3, 0x9a, 0xf0, 0x48, 0x55, 0x6d, 0xa3, 0xce, 0xb9, 0xf9, 0x34,
4643         0x03, 0x4e, 0xa7, 0xe8, 0x71, 0x95, 0xfa, 0x1c, 0x7e, 0xde, 0xe7, 0xc5, 0xd6, 0x1e, 0x23, 0x06,
4644         0xf5, 0x95, 0x0f, 0xcf, 0x69, 0xd9, 0x93, 0x9d, 0x9d, 0x98, 0x07, 0x7f, 0x0c, 0xc6, 0x29, 0x27,
4645         0x8e, 0xb0, 0x4a, 0xee, 0x7c, 0x61, 0x79, 0x79, 0xff, 0x6e, 0x56, 0x3e, 0xaa, 0xe1, 0xc7, 0xaf,
4646         0x09, 0x20, 0xa4, 0xf0, 0xcc, 0xbf, 0xb2, 0xa9, 0xbf, 0x25, 0xdc, 0x1c, 0xb6, 0xc1, 0x8c, 0x5c,
4647         0xa9, 0x50, 0x8c, 0xc8, 0x3d, 0xfd, 0x73, 0xc3, 0x1e, 0xd1, 0x90, 0xe4, 0x5d, 0x3e, 0xa1, 0x6f,
4648         0x31, 0xb3, 0x9e, 0x40, 0x45, 0x3d, 0x52, 0xe0, 0x12, 0x28, 0x38, 0xd4, 0x45, 0xa4, 0xd9, 0xa0,
4649         0x36, 0x56, 0xce, 0x38, 0xae, 0xd2, 0x4f, 0xb5, 0xbb, 0x8d, 0xe2, 0x34, 0xf0, 0x5d, 0x50, 0x70,
4650         0xf0, 0x83, 0x88, 0x25, 0x27, 0x59, 0x8e, 0x69, 0x79, 0x85, 0x6a, 0xf7, 0x08, 0xc5, 0xe9, 0xe0,
4651         0x7d, 0x50, 0x54, 0x39, 0xa5, 0xb2, 0x76, 0xeb, 0x16, 0xa7, 0x0d, 0xfa, 0x10, 0x0b, 0x3f, 0x5a,
4652         0x23, 0xcc, 0x26, 0x2e, 0x17, 0xae, 0x91, 0x97, 0x48, 0x66, 0x18, 0x18, 0xc5, 0x8d, 0xa1, 0x94,
4653         0x68, 0x17, 0x24, 0xf3, 0xb7, 0x1c, 0x38, 0x33, 0x34, 0x0c, 0xc0, 0x2b, 0x00, 0x7a, 0x9b, 0x3e,
4654         0x61, 0x6d, 0x52, 0xfb, 0x50, 0xd5, 0x45, 0xa2, 0x40, 0x11, 0x3a, 0xcf, 0xa9, 0x9c, 0x78, 0xa3,
4655         0xef, 0x14, 0x0d, 0xe0, 0x80, 0x36, 0x38, 0x2a, 0xde, 0x85, 0xd2, 0x32, 0xd5, 0xb5, 0xd0, 0xfe,
4656         0x1e, 0xdd, 0xff, 0xc2, 0xc0, 0x38, 0xba, 0x1a, 0x07, 0x41, 0x49, 0x4c, 0xb8, 0x02, 0x66, 0x75,
4657         0xb0, 0xef, 0xd1, 0xfa, 0x49, 0xad, 0xf5, 0xd9, 0x4a, 0xf2, 0x18, 0xf5, 0xd2, 0x0b, 0x88, 0x1a,
4658         0xf1, 0x29, 0x23, 0xb5, 0x08, 0x22, 0x9f, 0x84, 0x78, 0x3f, 0x79, 0x8c, 0x7a, 0xe9, 0xa1, 0x03,
4659         0x0c, 0x8d, 0x9a, 0x6a, 0xc1, 0x71, 0x09, 0xf9, 0x5a, 0x18, 0x18, 0x46, 0x65, 0x38, 0x29, 0xda,
4660         0x0d, 0x4b, 0x94, 0x81, 0xba, 0x76, 0x90, 0x0f, 0xe4, 0x62, 0x22, 0xf4, 0x2e, 0xf6, 0x84, 0xde,
4661         0xb9, 0x78, 0xa1, 0x18, 0x0b, 0xb3, 0x37, 0xc1, 0x84, 0x27, 0x5f, 0x86, 0xb6, 0xcb, 0x85, 0x21,
4662         0xcf, 0x29, 0x4a, 0x69, 0x11, 0x50, 0x19, 0x88, 0x58, 0xa6, 0x9f, 0x96, 0x06, 0x82, 0xd7, 0x40,
4663         0xbe, 0xe9, 0xd5, 0x3a, 0x89, 0xe8, 0xcd, 0x21, 0x80, 0x6b, 0x5e, 0xcd, 0x4f, 0xc0, 0x4d, 0x8a,
4664         0x1b, 0x8b, 0x5d, 0x24, 0x21, 0xe0, 0x27, 0x60, 0xb2, 0x93, 0xf0, 0x75, 0x75, 0x50, 0x1a, 0x02,
4665         0x87, 0x34, 0x69, 0x02, 0x72, 0x5a, 0x04, 0xb2, 0xce, 0x09, 0x8a, 0xe0, 0x04, 0x34, 0xd1, 0xa5,
4666         0x9a, 0xb4, 0xca, 0x70, 0xe8, 0x41, 0xe5, 0xb6, 0x82, 0xee, 0x9c, 0xa0, 0x08, 0xce, 0xfc, 0x31,
4667         0x07, 0xa6, 0x13, 0xe5, 0xdf, 0x21, 0x9b, 0x46, 0xe5, 0xf1, 0x03, 0x33, 0x8d, 0x82, 0x3b, 0x50,
4668         0xd3, 0x28, 0xc8, 0x57, 0x62, 0x9a, 0x18, 0xf4, 0x00, 0xd3, 0x3c, 0xcd, 0x01, 0xd8, 0xef, 0xc6,
4669         0xf0, 0x4b, 0x30, 0xa1, 0x02, 0xe6, 0x4b, 0x26, 0x95, 0x28, 0xbd, 0xeb, 0xfc, 0xa1, 0x51, 0x7b,
4670         0xea, 0xff, 0xec, 0x9e, 0xea, 0x7f, 0x72, 0x10, 0x7d, 0x52, 0x94, 0x75, 0x52, 0x7b, 0xa5, 0x2f,
4671         0xc0, 0xa4, 0xdf, 0x69, 0x30, 0xf2, 0xa3, 0x37, 0x18, 0x52, 0xe1, 0x51, 0x6b, 0x11, 0x41, 0xc2,
4672         0x1a, 0x98, 0xc6, 0xf1, 0x1a, 0x7f, 0x7c, 0xa4, 0xdf, 0x98, 0x13, 0x0d, 0x45, 0xa2, 0xb8, 0x4f,
4673         0xa0, 0x9a, 0xbf, 0xf7, 0x9a, 0x55, 0xbd, 0xbb, 0x7f, 0xa2, 0x59, 0x0f, 0xaf, 0xcb, 0xfa, 0x4f,
4674         0x58, 0xf6, 0xe7, 0x2c, 0x98, 0xeb, 0x4d, 0x13, 0x23, 0xb5, 0xd3, 0x0f, 0x07, 0xce, 0x04, 0xb2,
4675         0x23, 0x5d, 0x3a, 0xea, 0x02, 0xf6, 0x36, 0x17, 0x48, 0x58, 0x22, 0x77, 0xe0, 0x96, 0x30, 0x7f,
4676         0x49, 0xea, 0x68, 0xf4, 0x91, 0xc3, 0x57, 0x83, 0xfb, 0xf2, 0xd1, 0x94, 0x74, 0x5a, 0x0b, 0xdb,
4677         0x73, 0x6f, 0xfe, 0xaa, 0xd5, 0xf4, 0x6b, 0x16, 0x1c, 0x1f, 0x54, 0x22, 0xc0, 0x8a, 0x9e, 0xd2,
4678         0x29, 0x25, 0x95, 0xe2, 0x53, 0xba, 0x17, 0x81, 0x61, 0x0c, 0x68, 0x33, 0x3b, 0x30, 0xb1, 0x41,
4679         0xde, 0x1d, 0x30, 0x9f, 0xb0, 0x7c, 0xac, 0x66, 0xd3, 0x4d, 0xc3, 0xff, 0xc3, 0xc0, 0x98, 0xdf,
4680         0x48, 0xa1, 0x41, 0xa9, 0xdc, 0x29, 0xd3, 0xac, 0xdc, 0x2b, 0x9f, 0x66, 0x3d, 0xea, 0xd7, 0x97,
4681         0x72, 0xad, 0x03, 0xd1, 0xd7, 0x67, 0xe0, 0x54, 0xd2, 0x07, 0xfa, 0x15, 0x76, 0x26, 0x0c, 0x8c,
4682         0x53, 0x95, 0x34, 0x22, 0x94, 0xce, 0x9f, 0xe6, 0xc8, 0xb9, 0xc3, 0x71, 0x64, 0xf3, 0x9b, 0x2c,
4683         0x18, 0x97, 0xcd, 0xc9, 0x21, 0x8c, 0x94, 0xae, 0x24, 0x46, 0x4a, 0x67, 0x87, 0x64, 0x38, 0x79,
4684         0xa3, 0xd4, 0x01, 0xd2, 0xf5, 0x9e, 0x01, 0xd2, 0xb9, 0x5d, 0x91, 0x86, 0x8f, 0x8b, 0xde, 0x03,
4685         0x53, 0x91, 0x40, 0xf8, 0x96, 0x28, 0x16, 0x75, 0x57, 0x95, 0x91, 0xb6, 0x8d, 0x66, 0x0c, 0x51,
4686         0x3b, 0x15, 0x51, 0x98, 0x14, 0x14, 0x62, 0x12, 0xf6, 0xc7, 0x2c, 0xa8, 0xfd, 0xf8, 0xc0, 0x74,
4687         0xaa, 0x4b, 0xdd, 0x1f, 0x13, 0xca, 0xe7, 0x1f, 0x3f, 0x2f, 0x8e, 0x3d, 0x79, 0x5e, 0x1c, 0x7b,
4688         0xf6, 0xbc, 0x38, 0xf6, 0x75, 0x58, 0xcc, 0x3c, 0x0e, 0x8b, 0x99, 0x27, 0x61, 0x31, 0xf3, 0x2c,
4689         0x2c, 0x66, 0xfe, 0x08, 0x8b, 0x99, 0xef, 0xfe, 0x2c, 0x8e, 0x7d, 0x9a, 0x6d, 0x2f, 0xfd, 0x1d,
4690         0x00, 0x00, 0xff, 0xff, 0x3c, 0x26, 0x41, 0xcb, 0x94, 0x19, 0x00, 0x00,
4691 }