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