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