api.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: github.com/TheThingsNetwork/api/api.proto

package api

import (
	encoding_binary "encoding/binary"
	fmt "fmt"
	proto "github.com/gogo/protobuf/proto"
	golang_proto "github.com/golang/protobuf/proto"
	io "io"
	math "math"
	math_bits "math/bits"
	reflect "reflect"
	strings "strings"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = golang_proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package

type Percentiles struct {
	Percentile1          float32  `protobuf:"fixed32,1,opt,name=percentile1,proto3" json:"percentile1,omitempty"`
	Percentile5          float32  `protobuf:"fixed32,2,opt,name=percentile5,proto3" json:"percentile5,omitempty"`
	Percentile10         float32  `protobuf:"fixed32,3,opt,name=percentile10,proto3" json:"percentile10,omitempty"`
	Percentile25         float32  `protobuf:"fixed32,4,opt,name=percentile25,proto3" json:"percentile25,omitempty"`
	Percentile50         float32  `protobuf:"fixed32,5,opt,name=percentile50,proto3" json:"percentile50,omitempty"`
	Percentile75         float32  `protobuf:"fixed32,6,opt,name=percentile75,proto3" json:"percentile75,omitempty"`
	Percentile90         float32  `protobuf:"fixed32,7,opt,name=percentile90,proto3" json:"percentile90,omitempty"`
	Percentile95         float32  `protobuf:"fixed32,8,opt,name=percentile95,proto3" json:"percentile95,omitempty"`
	Percentile99         float32  `protobuf:"fixed32,9,opt,name=percentile99,proto3" json:"percentile99,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Percentiles) Reset()      { *m = Percentiles{} }
func (*Percentiles) ProtoMessage() {}
func (*Percentiles) Descriptor() ([]byte, []int) {
	return fileDescriptor_e12eef8980d9c5cc, []int{0}
}
func (m *Percentiles) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Percentiles) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Percentiles.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Percentiles) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Percentiles.Merge(m, src)
}
func (m *Percentiles) XXX_Size() int {
	return m.Size()
}
func (m *Percentiles) XXX_DiscardUnknown() {
	xxx_messageInfo_Percentiles.DiscardUnknown(m)
}

var xxx_messageInfo_Percentiles proto.InternalMessageInfo

func (m *Percentiles) GetPercentile1() float32 {
	if m != nil {
		return m.Percentile1
	}
	return 0
}

func (m *Percentiles) GetPercentile5() float32 {
	if m != nil {
		return m.Percentile5
	}
	return 0
}

func (m *Percentiles) GetPercentile10() float32 {
	if m != nil {
		return m.Percentile10
	}
	return 0
}

func (m *Percentiles) GetPercentile25() float32 {
	if m != nil {
		return m.Percentile25
	}
	return 0
}

func (m *Percentiles) GetPercentile50() float32 {
	if m != nil {
		return m.Percentile50
	}
	return 0
}

func (m *Percentiles) GetPercentile75() float32 {
	if m != nil {
		return m.Percentile75
	}
	return 0
}

func (m *Percentiles) GetPercentile90() float32 {
	if m != nil {
		return m.Percentile90
	}
	return 0
}

func (m *Percentiles) GetPercentile95() float32 {
	if m != nil {
		return m.Percentile95
	}
	return 0
}

func (m *Percentiles) GetPercentile99() float32 {
	if m != nil {
		return m.Percentile99
	}
	return 0
}

type Rates struct {
	Rate1                float32  `protobuf:"fixed32,1,opt,name=rate1,proto3" json:"rate1,omitempty"`
	Rate5                float32  `protobuf:"fixed32,2,opt,name=rate5,proto3" json:"rate5,omitempty"`
	Rate15               float32  `protobuf:"fixed32,3,opt,name=rate15,proto3" json:"rate15,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Rates) Reset()      { *m = Rates{} }
func (*Rates) ProtoMessage() {}
func (*Rates) Descriptor() ([]byte, []int) {
	return fileDescriptor_e12eef8980d9c5cc, []int{1}
}
func (m *Rates) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Rates) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Rates.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Rates) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Rates.Merge(m, src)
}
func (m *Rates) XXX_Size() int {
	return m.Size()
}
func (m *Rates) XXX_DiscardUnknown() {
	xxx_messageInfo_Rates.DiscardUnknown(m)
}

var xxx_messageInfo_Rates proto.InternalMessageInfo

func (m *Rates) GetRate1() float32 {
	if m != nil {
		return m.Rate1
	}
	return 0
}

func (m *Rates) GetRate5() float32 {
	if m != nil {
		return m.Rate5
	}
	return 0
}

func (m *Rates) GetRate15() float32 {
	if m != nil {
		return m.Rate15
	}
	return 0
}

type SystemStats struct {
	Load                 *SystemStats_Loadstats   `protobuf:"bytes,1,opt,name=load,proto3" json:"load,omitempty"`
	Cpu                  *SystemStats_CPUStats    `protobuf:"bytes,2,opt,name=cpu,proto3" json:"cpu,omitempty"`
	Memory               *SystemStats_MemoryStats `protobuf:"bytes,3,opt,name=memory,proto3" json:"memory,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
	XXX_sizecache        int32                    `json:"-"`
}

func (m *SystemStats) Reset()      { *m = SystemStats{} }
func (*SystemStats) ProtoMessage() {}
func (*SystemStats) Descriptor() ([]byte, []int) {
	return fileDescriptor_e12eef8980d9c5cc, []int{2}
}
func (m *SystemStats) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SystemStats) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SystemStats.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *SystemStats) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SystemStats.Merge(m, src)
}
func (m *SystemStats) XXX_Size() int {
	return m.Size()
}
func (m *SystemStats) XXX_DiscardUnknown() {
	xxx_messageInfo_SystemStats.DiscardUnknown(m)
}

var xxx_messageInfo_SystemStats proto.InternalMessageInfo

func (m *SystemStats) GetLoad() *SystemStats_Loadstats {
	if m != nil {
		return m.Load
	}
	return nil
}

func (m *SystemStats) GetCpu() *SystemStats_CPUStats {
	if m != nil {
		return m.Cpu
	}
	return nil
}

func (m *SystemStats) GetMemory() *SystemStats_MemoryStats {
	if m != nil {
		return m.Memory
	}
	return nil
}

type SystemStats_Loadstats struct {
	Load1                float32  `protobuf:"fixed32,1,opt,name=load1,proto3" json:"load1,omitempty"`
	Load5                float32  `protobuf:"fixed32,2,opt,name=load5,proto3" json:"load5,omitempty"`
	Load15               float32  `protobuf:"fixed32,3,opt,name=load15,proto3" json:"load15,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *SystemStats_Loadstats) Reset()      { *m = SystemStats_Loadstats{} }
func (*SystemStats_Loadstats) ProtoMessage() {}
func (*SystemStats_Loadstats) Descriptor() ([]byte, []int) {
	return fileDescriptor_e12eef8980d9c5cc, []int{2, 0}
}
func (m *SystemStats_Loadstats) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SystemStats_Loadstats) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SystemStats_Loadstats.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *SystemStats_Loadstats) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SystemStats_Loadstats.Merge(m, src)
}
func (m *SystemStats_Loadstats) XXX_Size() int {
	return m.Size()
}
func (m *SystemStats_Loadstats) XXX_DiscardUnknown() {
	xxx_messageInfo_SystemStats_Loadstats.DiscardUnknown(m)
}

var xxx_messageInfo_SystemStats_Loadstats proto.InternalMessageInfo

func (m *SystemStats_Loadstats) GetLoad1() float32 {
	if m != nil {
		return m.Load1
	}
	return 0
}

func (m *SystemStats_Loadstats) GetLoad5() float32 {
	if m != nil {
		return m.Load5
	}
	return 0
}

func (m *SystemStats_Loadstats) GetLoad15() float32 {
	if m != nil {
		return m.Load15
	}
	return 0
}

type SystemStats_CPUStats struct {
	User                 float32  `protobuf:"fixed32,1,opt,name=user,proto3" json:"user,omitempty"`
	System               float32  `protobuf:"fixed32,2,opt,name=system,proto3" json:"system,omitempty"`
	Idle                 float32  `protobuf:"fixed32,3,opt,name=idle,proto3" json:"idle,omitempty"`
	Percentage           float32  `protobuf:"fixed32,4,opt,name=percentage,proto3" json:"percentage,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *SystemStats_CPUStats) Reset()      { *m = SystemStats_CPUStats{} }
func (*SystemStats_CPUStats) ProtoMessage() {}
func (*SystemStats_CPUStats) Descriptor() ([]byte, []int) {
	return fileDescriptor_e12eef8980d9c5cc, []int{2, 1}
}
func (m *SystemStats_CPUStats) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SystemStats_CPUStats) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SystemStats_CPUStats.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *SystemStats_CPUStats) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SystemStats_CPUStats.Merge(m, src)
}
func (m *SystemStats_CPUStats) XXX_Size() int {
	return m.Size()
}
func (m *SystemStats_CPUStats) XXX_DiscardUnknown() {
	xxx_messageInfo_SystemStats_CPUStats.DiscardUnknown(m)
}

var xxx_messageInfo_SystemStats_CPUStats proto.InternalMessageInfo

func (m *SystemStats_CPUStats) GetUser() float32 {
	if m != nil {
		return m.User
	}
	return 0
}

func (m *SystemStats_CPUStats) GetSystem() float32 {
	if m != nil {
		return m.System
	}
	return 0
}

func (m *SystemStats_CPUStats) GetIdle() float32 {
	if m != nil {
		return m.Idle
	}
	return 0
}

func (m *SystemStats_CPUStats) GetPercentage() float32 {
	if m != nil {
		return m.Percentage
	}
	return 0
}

type SystemStats_MemoryStats struct {
	Total                uint64   `protobuf:"varint,1,opt,name=total,proto3" json:"total,omitempty"`
	Available            uint64   `protobuf:"varint,2,opt,name=available,proto3" json:"available,omitempty"`
	Used                 uint64   `protobuf:"varint,3,opt,name=used,proto3" json:"used,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *SystemStats_MemoryStats) Reset()      { *m = SystemStats_MemoryStats{} }
func (*SystemStats_MemoryStats) ProtoMessage() {}
func (*SystemStats_MemoryStats) Descriptor() ([]byte, []int) {
	return fileDescriptor_e12eef8980d9c5cc, []int{2, 2}
}
func (m *SystemStats_MemoryStats) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SystemStats_MemoryStats) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SystemStats_MemoryStats.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *SystemStats_MemoryStats) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SystemStats_MemoryStats.Merge(m, src)
}
func (m *SystemStats_MemoryStats) XXX_Size() int {
	return m.Size()
}
func (m *SystemStats_MemoryStats) XXX_DiscardUnknown() {
	xxx_messageInfo_SystemStats_MemoryStats.DiscardUnknown(m)
}

var xxx_messageInfo_SystemStats_MemoryStats proto.InternalMessageInfo

func (m *SystemStats_MemoryStats) GetTotal() uint64 {
	if m != nil {
		return m.Total
	}
	return 0
}

func (m *SystemStats_MemoryStats) GetAvailable() uint64 {
	if m != nil {
		return m.Available
	}
	return 0
}

func (m *SystemStats_MemoryStats) GetUsed() uint64 {
	if m != nil {
		return m.Used
	}
	return 0
}

type ComponentStats struct {
	Uptime               uint64                      `protobuf:"varint,1,opt,name=uptime,proto3" json:"uptime,omitempty"`
	Cpu                  *ComponentStats_CPUStats    `protobuf:"bytes,2,opt,name=cpu,proto3" json:"cpu,omitempty"`
	Memory               *ComponentStats_MemoryStats `protobuf:"bytes,3,opt,name=memory,proto3" json:"memory,omitempty"`
	Goroutines           uint64                      `protobuf:"varint,4,opt,name=goroutines,proto3" json:"goroutines,omitempty"`
	GcCpuFraction        float32                     `protobuf:"fixed32,5,opt,name=gc_cpu_fraction,json=gcCpuFraction,proto3" json:"gc_cpu_fraction,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                    `json:"-"`
	XXX_sizecache        int32                       `json:"-"`
}

func (m *ComponentStats) Reset()      { *m = ComponentStats{} }
func (*ComponentStats) ProtoMessage() {}
func (*ComponentStats) Descriptor() ([]byte, []int) {
	return fileDescriptor_e12eef8980d9c5cc, []int{3}
}
func (m *ComponentStats) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ComponentStats) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ComponentStats.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ComponentStats) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ComponentStats.Merge(m, src)
}
func (m *ComponentStats) XXX_Size() int {
	return m.Size()
}
func (m *ComponentStats) XXX_DiscardUnknown() {
	xxx_messageInfo_ComponentStats.DiscardUnknown(m)
}

var xxx_messageInfo_ComponentStats proto.InternalMessageInfo

func (m *ComponentStats) GetUptime() uint64 {
	if m != nil {
		return m.Uptime
	}
	return 0
}

func (m *ComponentStats) GetCpu() *ComponentStats_CPUStats {
	if m != nil {
		return m.Cpu
	}
	return nil
}

func (m *ComponentStats) GetMemory() *ComponentStats_MemoryStats {
	if m != nil {
		return m.Memory
	}
	return nil
}

func (m *ComponentStats) GetGoroutines() uint64 {
	if m != nil {
		return m.Goroutines
	}
	return 0
}

func (m *ComponentStats) GetGcCpuFraction() float32 {
	if m != nil {
		return m.GcCpuFraction
	}
	return 0
}

type ComponentStats_CPUStats struct {
	User                 float32  `protobuf:"fixed32,1,opt,name=user,proto3" json:"user,omitempty"`
	System               float32  `protobuf:"fixed32,2,opt,name=system,proto3" json:"system,omitempty"`
	Idle                 float32  `protobuf:"fixed32,3,opt,name=idle,proto3" json:"idle,omitempty"`
	Percentage           float32  `protobuf:"fixed32,4,opt,name=percentage,proto3" json:"percentage,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ComponentStats_CPUStats) Reset()      { *m = ComponentStats_CPUStats{} }
func (*ComponentStats_CPUStats) ProtoMessage() {}
func (*ComponentStats_CPUStats) Descriptor() ([]byte, []int) {
	return fileDescriptor_e12eef8980d9c5cc, []int{3, 0}
}
func (m *ComponentStats_CPUStats) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ComponentStats_CPUStats) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ComponentStats_CPUStats.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ComponentStats_CPUStats) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ComponentStats_CPUStats.Merge(m, src)
}
func (m *ComponentStats_CPUStats) XXX_Size() int {
	return m.Size()
}
func (m *ComponentStats_CPUStats) XXX_DiscardUnknown() {
	xxx_messageInfo_ComponentStats_CPUStats.DiscardUnknown(m)
}

var xxx_messageInfo_ComponentStats_CPUStats proto.InternalMessageInfo

func (m *ComponentStats_CPUStats) GetUser() float32 {
	if m != nil {
		return m.User
	}
	return 0
}

func (m *ComponentStats_CPUStats) GetSystem() float32 {
	if m != nil {
		return m.System
	}
	return 0
}

func (m *ComponentStats_CPUStats) GetIdle() float32 {
	if m != nil {
		return m.Idle
	}
	return 0
}

func (m *ComponentStats_CPUStats) GetPercentage() float32 {
	if m != nil {
		return m.Percentage
	}
	return 0
}

type ComponentStats_MemoryStats struct {
	Memory               uint64   `protobuf:"varint,1,opt,name=memory,proto3" json:"memory,omitempty"`
	Swap                 uint64   `protobuf:"varint,2,opt,name=swap,proto3" json:"swap,omitempty"`
	Heap                 uint64   `protobuf:"varint,10,opt,name=heap,proto3" json:"heap,omitempty"`
	Stack                uint64   `protobuf:"varint,11,opt,name=stack,proto3" json:"stack,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ComponentStats_MemoryStats) Reset()      { *m = ComponentStats_MemoryStats{} }
func (*ComponentStats_MemoryStats) ProtoMessage() {}
func (*ComponentStats_MemoryStats) Descriptor() ([]byte, []int) {
	return fileDescriptor_e12eef8980d9c5cc, []int{3, 1}
}
func (m *ComponentStats_MemoryStats) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ComponentStats_MemoryStats) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ComponentStats_MemoryStats.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ComponentStats_MemoryStats) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ComponentStats_MemoryStats.Merge(m, src)
}
func (m *ComponentStats_MemoryStats) XXX_Size() int {
	return m.Size()
}
func (m *ComponentStats_MemoryStats) XXX_DiscardUnknown() {
	xxx_messageInfo_ComponentStats_MemoryStats.DiscardUnknown(m)
}

var xxx_messageInfo_ComponentStats_MemoryStats proto.InternalMessageInfo

func (m *ComponentStats_MemoryStats) GetMemory() uint64 {
	if m != nil {
		return m.Memory
	}
	return 0
}

func (m *ComponentStats_MemoryStats) GetSwap() uint64 {
	if m != nil {
		return m.Swap
	}
	return 0
}

func (m *ComponentStats_MemoryStats) GetHeap() uint64 {
	if m != nil {
		return m.Heap
	}
	return 0
}

func (m *ComponentStats_MemoryStats) GetStack() uint64 {
	if m != nil {
		return m.Stack
	}
	return 0
}

func init() {
	proto.RegisterType((*Percentiles)(nil), "api.Percentiles")
	golang_proto.RegisterType((*Percentiles)(nil), "api.Percentiles")
	proto.RegisterType((*Rates)(nil), "api.Rates")
	golang_proto.RegisterType((*Rates)(nil), "api.Rates")
	proto.RegisterType((*SystemStats)(nil), "api.SystemStats")
	golang_proto.RegisterType((*SystemStats)(nil), "api.SystemStats")
	proto.RegisterType((*SystemStats_Loadstats)(nil), "api.SystemStats.Loadstats")
	golang_proto.RegisterType((*SystemStats_Loadstats)(nil), "api.SystemStats.Loadstats")
	proto.RegisterType((*SystemStats_CPUStats)(nil), "api.SystemStats.CPUStats")
	golang_proto.RegisterType((*SystemStats_CPUStats)(nil), "api.SystemStats.CPUStats")
	proto.RegisterType((*SystemStats_MemoryStats)(nil), "api.SystemStats.MemoryStats")
	golang_proto.RegisterType((*SystemStats_MemoryStats)(nil), "api.SystemStats.MemoryStats")
	proto.RegisterType((*ComponentStats)(nil), "api.ComponentStats")
	golang_proto.RegisterType((*ComponentStats)(nil), "api.ComponentStats")
	proto.RegisterType((*ComponentStats_CPUStats)(nil), "api.ComponentStats.CPUStats")
	golang_proto.RegisterType((*ComponentStats_CPUStats)(nil), "api.ComponentStats.CPUStats")
	proto.RegisterType((*ComponentStats_MemoryStats)(nil), "api.ComponentStats.MemoryStats")
	golang_proto.RegisterType((*ComponentStats_MemoryStats)(nil), "api.ComponentStats.MemoryStats")
}

func init() {
	proto.RegisterFile("github.com/TheThingsNetwork/api/api.proto", fileDescriptor_e12eef8980d9c5cc)
}
func init() {
	golang_proto.RegisterFile("github.com/TheThingsNetwork/api/api.proto", fileDescriptor_e12eef8980d9c5cc)
}

var fileDescriptor_e12eef8980d9c5cc = []byte{
	// 703 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x54, 0x3f, 0x4c, 0xdb, 0x4e,
	0x14, 0xbe, 0x4b, 0x4c, 0x7e, 0x70, 0xfe, 0xb5, 0x95, 0x4e, 0x08, 0xb9, 0x11, 0x7a, 0xa0, 0x0c,
	0x55, 0xab, 0x4a, 0x86, 0xa6, 0xb5, 0x50, 0x46, 0x40, 0xaa, 0x84, 0xfa, 0x2f, 0x0a, 0xb0, 0x74,
	0x41, 0x87, 0x73, 0x4d, 0x5c, 0x92, 0xd8, 0xb2, 0x2f, 0x45, 0x6c, 0x8c, 0x8c, 0x1d, 0x3b, 0x76,
	0x44, 0x4c, 0x0c, 0x1d, 0x18, 0x19, 0x59, 0x2a, 0xa1, 0x4e, 0x8c, 0xc4, 0x5e, 0x18, 0x19, 0x19,
	0xab, 0x3b, 0x5f, 0x52, 0xc7, 0x41, 0xea, 0xd6, 0x21, 0xd2, 0x7b, 0xdf, 0x7d, 0xf7, 0xbd, 0x3f,
	0x5f, 0x7c, 0xe4, 0x59, 0xcb, 0x13, 0xed, 0xfe, 0xae, 0xed, 0xfa, 0xdd, 0xa5, 0xad, 0x36, 0xdf,
	0x6a, 0x7b, 0xbd, 0x56, 0xf4, 0x9e, 0x8b, 0x7d, 0x3f, 0xdc, 0x5b, 0x62, 0x81, 0x27, 0x7f, 0x76,
	0x10, 0xfa, 0xc2, 0xa7, 0x45, 0x16, 0x78, 0x95, 0x9f, 0x05, 0x62, 0xd6, 0x79, 0xe8, 0xf2, 0x9e,
	0xf0, 0x3a, 0x3c, 0xa2, 0x8b, 0xc4, 0x0c, 0x46, 0xe9, 0x0b, 0x0b, 0x2f, 0xe2, 0xa7, 0x85, 0x46,
	0x16, 0x1a, 0x67, 0x38, 0x56, 0x21, 0xcf, 0x70, 0x68, 0x85, 0xfc, 0x9f, 0xb9, 0xb0, 0x6c, 0x15,
	0x15, 0x65, 0x0c, 0x1b, 0xe7, 0x54, 0x1d, 0xcb, 0xc8, 0x73, 0xaa, 0x39, 0x1d, 0x67, 0xd9, 0x9a,
	0xca, 0x73, 0x9c, 0x9c, 0xce, 0x8a, 0x63, 0x95, 0xf2, 0x9c, 0x95, 0x9c, 0x4e, 0x6d, 0xd9, 0xfa,
	0x2f, 0xcf, 0xa9, 0xe5, 0x74, 0x6a, 0x8e, 0x35, 0x3d, 0xc1, 0xc9, 0xeb, 0xd4, 0xac, 0x99, 0x09,
	0x4e, 0xad, 0xf2, 0x86, 0x4c, 0x35, 0x98, 0xe0, 0x11, 0x9d, 0x25, 0x53, 0x21, 0x13, 0xa3, 0x15,
	0xa6, 0xc9, 0x10, 0x1d, 0xae, 0x2d, 0x4d, 0xe8, 0x1c, 0x29, 0xa9, 0x63, 0x47, 0xaf, 0x4a, 0x67,
	0x95, 0x1f, 0x45, 0x62, 0x6e, 0x1e, 0x44, 0x82, 0x77, 0x37, 0x05, 0x13, 0x11, 0xb5, 0x89, 0xd1,
	0xf1, 0x59, 0x53, 0x49, 0x9a, 0xd5, 0xb2, 0x2d, 0xbd, 0xcc, 0x9c, 0xdb, 0x6f, 0x7d, 0xd6, 0x8c,
	0x64, 0xd4, 0x50, 0x3c, 0xfa, 0x9c, 0x14, 0xdd, 0xa0, 0xaf, 0x6a, 0x99, 0xd5, 0xc7, 0x13, 0xf4,
	0xf5, 0xfa, 0xb6, 0x0a, 0x1a, 0x92, 0x45, 0x5f, 0x91, 0x52, 0x97, 0x77, 0xfd, 0xf0, 0x40, 0x35,
	0x61, 0x56, 0xe7, 0x27, 0xf8, 0xef, 0xd4, 0x71, 0x7a, 0x45, 0x73, 0xcb, 0x1f, 0xc8, 0xcc, 0xa8,
	0xaa, 0x9c, 0x4e, 0xd6, 0x1d, 0xcd, 0xac, 0x92, 0x21, 0x3a, 0x9a, 0x59, 0x25, 0x72, 0x66, 0x75,
	0x3c, 0x9a, 0x39, 0xcd, 0xca, 0x9f, 0xc9, 0xf4, 0xb0, 0x2f, 0x4a, 0x89, 0xd1, 0x8f, 0x78, 0xa8,
	0xe5, 0x54, 0x2c, 0xef, 0x45, 0xaa, 0x27, 0x2d, 0xa7, 0x33, 0xc9, 0xf5, 0x9a, 0x1d, 0xae, 0xd5,
	0x54, 0x4c, 0x81, 0x10, 0x6d, 0x0e, 0x6b, 0x71, 0xfd, 0x17, 0xcb, 0x20, 0xe5, 0x6d, 0x62, 0x66,
	0x66, 0x92, 0x8d, 0x0a, 0x5f, 0xb0, 0x8e, 0xaa, 0x67, 0x34, 0xd2, 0x84, 0xce, 0x93, 0x19, 0xf6,
	0x85, 0x79, 0x1d, 0xb6, 0xdb, 0xe1, 0xaa, 0xa6, 0xd1, 0xf8, 0x03, 0xe8, 0x16, 0x9b, 0xaa, 0xac,
	0xa1, 0x5a, 0x6c, 0x56, 0x4e, 0x8a, 0xe4, 0xe1, 0xba, 0xdf, 0x0d, 0xfc, 0x1e, 0xef, 0x89, 0x54,
	0x7a, 0x8e, 0x94, 0xfa, 0x81, 0xf0, 0xba, 0x5c, 0x6b, 0xeb, 0x8c, 0xda, 0x59, 0x87, 0xd2, 0x8d,
	0x8f, 0xdf, 0xcc, 0x99, 0xb4, 0x92, 0x33, 0x69, 0xe1, 0xbe, 0x2b, 0xf7, 0xf8, 0x24, 0x57, 0xd1,
	0xf2, 0x43, 0xbf, 0x2f, 0xbc, 0x1e, 0x8f, 0xd4, 0x2a, 0x8c, 0x46, 0x06, 0xa1, 0x4f, 0xc8, 0xa3,
	0x96, 0xbb, 0xe3, 0x06, 0xfd, 0x9d, 0x4f, 0x21, 0x73, 0x85, 0xe7, 0xf7, 0xf4, 0xe7, 0xf6, 0xa0,
	0xe5, 0xae, 0x07, 0xfd, 0xd7, 0x1a, 0xfc, 0xa7, 0xf6, 0xb8, 0xe3, 0xf6, 0xcc, 0x8d, 0x66, 0xd7,
	0x3b, 0xd4, 0xa3, 0x51, 0x62, 0x44, 0xfb, 0x2c, 0xd0, 0xde, 0xa8, 0x58, 0x62, 0x6d, 0xce, 0x02,
	0x8b, 0xa4, 0x98, 0x8c, 0xa5, 0xbd, 0x91, 0x60, 0xee, 0x9e, 0x65, 0xa6, 0xf6, 0xaa, 0x64, 0xed,
	0x17, 0xbe, 0x18, 0x00, 0xbe, 0x1c, 0x00, 0xbe, 0x1a, 0x00, 0xba, 0x1e, 0x00, 0xba, 0x19, 0x00,
	0xba, 0x1d, 0x00, 0xba, 0x1b, 0x00, 0x3e, 0x8c, 0x01, 0x1f, 0xc5, 0x80, 0x8e, 0x63, 0xc0, 0xa7,
	0x31, 0xa0, 0xb3, 0x18, 0xd0, 0x79, 0x0c, 0xe8, 0x22, 0x06, 0x7c, 0x19, 0x03, 0xbe, 0x8a, 0x01,
	0x5d, 0xc7, 0x80, 0x6f, 0x62, 0x40, 0xb7, 0x31, 0xe0, 0xbb, 0x18, 0xd0, 0x61, 0x02, 0xe8, 0x28,
	0x01, 0xfc, 0x35, 0x01, 0xf4, 0x2d, 0x01, 0xfc, 0x3d, 0x01, 0x74, 0x9c, 0x00, 0x3a, 0x4d, 0x00,
	0x9f, 0x25, 0x80, 0xcf, 0x13, 0xc0, 0xc4, 0xf2, 0xc3, 0x96, 0x2d, 0xda, 0x5c, 0xa8, 0x07, 0xba,
	0x97, 0x3e, 0xd0, 0xd2, 0xcc, 0xb5, 0xe9, 0xd5, 0xfa, 0x46, 0x5d, 0x3e, 0xd0, 0x75, 0xfc, 0x71,
	0xe1, 0x2f, 0xaf, 0xf9, 0x49, 0x61, 0x36, 0x0f, 0xdb, 0xab, 0xf5, 0x8d, 0xdd, 0x92, 0x7a, 0xe1,
	0x5f, 0xfe, 0x0e, 0x00, 0x00, 0xff, 0xff, 0xad, 0xcc, 0x02, 0x4e, 0x0e, 0x06, 0x00, 0x00,
}

func (this *Percentiles) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Percentiles)
	if !ok {
		that2, ok := that.(Percentiles)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Percentile1 != that1.Percentile1 {
		return false
	}
	if this.Percentile5 != that1.Percentile5 {
		return false
	}
	if this.Percentile10 != that1.Percentile10 {
		return false
	}
	if this.Percentile25 != that1.Percentile25 {
		return false
	}
	if this.Percentile50 != that1.Percentile50 {
		return false
	}
	if this.Percentile75 != that1.Percentile75 {
		return false
	}
	if this.Percentile90 != that1.Percentile90 {
		return false
	}
	if this.Percentile95 != that1.Percentile95 {
		return false
	}
	if this.Percentile99 != that1.Percentile99 {
		return false
	}
	return true
}
func (this *Rates) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Rates)
	if !ok {
		that2, ok := that.(Rates)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Rate1 != that1.Rate1 {
		return false
	}
	if this.Rate5 != that1.Rate5 {
		return false
	}
	if this.Rate15 != that1.Rate15 {
		return false
	}
	return true
}
func (this *SystemStats) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*SystemStats)
	if !ok {
		that2, ok := that.(SystemStats)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Load.Equal(that1.Load) {
		return false
	}
	if !this.Cpu.Equal(that1.Cpu) {
		return false
	}
	if !this.Memory.Equal(that1.Memory) {
		return false
	}
	return true
}
func (this *SystemStats_Loadstats) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*SystemStats_Loadstats)
	if !ok {
		that2, ok := that.(SystemStats_Loadstats)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Load1 != that1.Load1 {
		return false
	}
	if this.Load5 != that1.Load5 {
		return false
	}
	if this.Load15 != that1.Load15 {
		return false
	}
	return true
}
func (this *SystemStats_CPUStats) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*SystemStats_CPUStats)
	if !ok {
		that2, ok := that.(SystemStats_CPUStats)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.User != that1.User {
		return false
	}
	if this.System != that1.System {
		return false
	}
	if this.Idle != that1.Idle {
		return false
	}
	if this.Percentage != that1.Percentage {
		return false
	}
	return true
}
func (this *SystemStats_MemoryStats) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*SystemStats_MemoryStats)
	if !ok {
		that2, ok := that.(SystemStats_MemoryStats)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Total != that1.Total {
		return false
	}
	if this.Available != that1.Available {
		return false
	}
	if this.Used != that1.Used {
		return false
	}
	return true
}
func (this *ComponentStats) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ComponentStats)
	if !ok {
		that2, ok := that.(ComponentStats)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Uptime != that1.Uptime {
		return false
	}
	if !this.Cpu.Equal(that1.Cpu) {
		return false
	}
	if !this.Memory.Equal(that1.Memory) {
		return false
	}
	if this.Goroutines != that1.Goroutines {
		return false
	}
	if this.GcCpuFraction != that1.GcCpuFraction {
		return false
	}
	return true
}
func (this *ComponentStats_CPUStats) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ComponentStats_CPUStats)
	if !ok {
		that2, ok := that.(ComponentStats_CPUStats)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.User != that1.User {
		return false
	}
	if this.System != that1.System {
		return false
	}
	if this.Idle != that1.Idle {
		return false
	}
	if this.Percentage != that1.Percentage {
		return false
	}
	return true
}
func (this *ComponentStats_MemoryStats) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ComponentStats_MemoryStats)
	if !ok {
		that2, ok := that.(ComponentStats_MemoryStats)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Memory != that1.Memory {
		return false
	}
	if this.Swap != that1.Swap {
		return false
	}
	if this.Heap != that1.Heap {
		return false
	}
	if this.Stack != that1.Stack {
		return false
	}
	return true
}
func (m *Percentiles) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Percentiles) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Percentiles) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Percentile99 != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Percentile99))))
		i--
		dAtA[i] = 0x4d
	}
	if m.Percentile95 != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Percentile95))))
		i--
		dAtA[i] = 0x45
	}
	if m.Percentile90 != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Percentile90))))
		i--
		dAtA[i] = 0x3d
	}
	if m.Percentile75 != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Percentile75))))
		i--
		dAtA[i] = 0x35
	}
	if m.Percentile50 != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Percentile50))))
		i--
		dAtA[i] = 0x2d
	}
	if m.Percentile25 != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Percentile25))))
		i--
		dAtA[i] = 0x25
	}
	if m.Percentile10 != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Percentile10))))
		i--
		dAtA[i] = 0x1d
	}
	if m.Percentile5 != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Percentile5))))
		i--
		dAtA[i] = 0x15
	}
	if m.Percentile1 != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Percentile1))))
		i--
		dAtA[i] = 0xd
	}
	return len(dAtA) - i, nil
}

func (m *Rates) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Rates) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Rates) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Rate15 != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Rate15))))
		i--
		dAtA[i] = 0x1d
	}
	if m.Rate5 != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Rate5))))
		i--
		dAtA[i] = 0x15
	}
	if m.Rate1 != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Rate1))))
		i--
		dAtA[i] = 0xd
	}
	return len(dAtA) - i, nil
}

func (m *SystemStats) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *SystemStats) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SystemStats) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Memory != nil {
		{
			size, err := m.Memory.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintApi(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Cpu != nil {
		{
			size, err := m.Cpu.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintApi(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Load != nil {
		{
			size, err := m.Load.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintApi(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *SystemStats_Loadstats) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *SystemStats_Loadstats) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SystemStats_Loadstats) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Load15 != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Load15))))
		i--
		dAtA[i] = 0x1d
	}
	if m.Load5 != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Load5))))
		i--
		dAtA[i] = 0x15
	}
	if m.Load1 != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Load1))))
		i--
		dAtA[i] = 0xd
	}
	return len(dAtA) - i, nil
}

func (m *SystemStats_CPUStats) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *SystemStats_CPUStats) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SystemStats_CPUStats) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Percentage != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Percentage))))
		i--
		dAtA[i] = 0x25
	}
	if m.Idle != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Idle))))
		i--
		dAtA[i] = 0x1d
	}
	if m.System != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.System))))
		i--
		dAtA[i] = 0x15
	}
	if m.User != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.User))))
		i--
		dAtA[i] = 0xd
	}
	return len(dAtA) - i, nil
}

func (m *SystemStats_MemoryStats) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *SystemStats_MemoryStats) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SystemStats_MemoryStats) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Used != 0 {
		i = encodeVarintApi(dAtA, i, uint64(m.Used))
		i--
		dAtA[i] = 0x18
	}
	if m.Available != 0 {
		i = encodeVarintApi(dAtA, i, uint64(m.Available))
		i--
		dAtA[i] = 0x10
	}
	if m.Total != 0 {
		i = encodeVarintApi(dAtA, i, uint64(m.Total))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *ComponentStats) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ComponentStats) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ComponentStats) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.GcCpuFraction != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.GcCpuFraction))))
		i--
		dAtA[i] = 0x2d
	}
	if m.Goroutines != 0 {
		i = encodeVarintApi(dAtA, i, uint64(m.Goroutines))
		i--
		dAtA[i] = 0x20
	}
	if m.Memory != nil {
		{
			size, err := m.Memory.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintApi(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Cpu != nil {
		{
			size, err := m.Cpu.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintApi(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Uptime != 0 {
		i = encodeVarintApi(dAtA, i, uint64(m.Uptime))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *ComponentStats_CPUStats) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ComponentStats_CPUStats) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ComponentStats_CPUStats) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Percentage != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Percentage))))
		i--
		dAtA[i] = 0x25
	}
	if m.Idle != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Idle))))
		i--
		dAtA[i] = 0x1d
	}
	if m.System != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.System))))
		i--
		dAtA[i] = 0x15
	}
	if m.User != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.User))))
		i--
		dAtA[i] = 0xd
	}
	return len(dAtA) - i, nil
}

func (m *ComponentStats_MemoryStats) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ComponentStats_MemoryStats) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ComponentStats_MemoryStats) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Stack != 0 {
		i = encodeVarintApi(dAtA, i, uint64(m.Stack))
		i--
		dAtA[i] = 0x58
	}
	if m.Heap != 0 {
		i = encodeVarintApi(dAtA, i, uint64(m.Heap))
		i--
		dAtA[i] = 0x50
	}
	if m.Swap != 0 {
		i = encodeVarintApi(dAtA, i, uint64(m.Swap))
		i--
		dAtA[i] = 0x10
	}
	if m.Memory != 0 {
		i = encodeVarintApi(dAtA, i, uint64(m.Memory))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func encodeVarintApi(dAtA []byte, offset int, v uint64) int {
	offset -= sovApi(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func NewPopulatedPercentiles(r randyApi, easy bool) *Percentiles {
	this := &Percentiles{}
	this.Percentile1 = float32(r.Float32())
	if r.Intn(2) == 0 {
		this.Percentile1 *= -1
	}
	this.Percentile5 = float32(r.Float32())
	if r.Intn(2) == 0 {
		this.Percentile5 *= -1
	}
	this.Percentile10 = float32(r.Float32())
	if r.Intn(2) == 0 {
		this.Percentile10 *= -1
	}
	this.Percentile25 = float32(r.Float32())
	if r.Intn(2) == 0 {
		this.Percentile25 *= -1
	}
	this.Percentile50 = float32(r.Float32())
	if r.Intn(2) == 0 {
		this.Percentile50 *= -1
	}
	this.Percentile75 = float32(r.Float32())
	if r.Intn(2) == 0 {
		this.Percentile75 *= -1
	}
	this.Percentile90 = float32(r.Float32())
	if r.Intn(2) == 0 {
		this.Percentile90 *= -1
	}
	this.Percentile95 = float32(r.Float32())
	if r.Intn(2) == 0 {
		this.Percentile95 *= -1
	}
	this.Percentile99 = float32(r.Float32())
	if r.Intn(2) == 0 {
		this.Percentile99 *= -1
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedRates(r randyApi, easy bool) *Rates {
	this := &Rates{}
	this.Rate1 = float32(r.Float32())
	if r.Intn(2) == 0 {
		this.Rate1 *= -1
	}
	this.Rate5 = float32(r.Float32())
	if r.Intn(2) == 0 {
		this.Rate5 *= -1
	}
	this.Rate15 = float32(r.Float32())
	if r.Intn(2) == 0 {
		this.Rate15 *= -1
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedSystemStats(r randyApi, easy bool) *SystemStats {
	this := &SystemStats{}
	if r.Intn(5) != 0 {
		this.Load = NewPopulatedSystemStats_Loadstats(r, easy)
	}
	if r.Intn(5) != 0 {
		this.Cpu = NewPopulatedSystemStats_CPUStats(r, easy)
	}
	if r.Intn(5) != 0 {
		this.Memory = NewPopulatedSystemStats_MemoryStats(r, easy)
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedSystemStats_Loadstats(r randyApi, easy bool) *SystemStats_Loadstats {
	this := &SystemStats_Loadstats{}
	this.Load1 = float32(r.Float32())
	if r.Intn(2) == 0 {
		this.Load1 *= -1
	}
	this.Load5 = float32(r.Float32())
	if r.Intn(2) == 0 {
		this.Load5 *= -1
	}
	this.Load15 = float32(r.Float32())
	if r.Intn(2) == 0 {
		this.Load15 *= -1
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedSystemStats_CPUStats(r randyApi, easy bool) *SystemStats_CPUStats {
	this := &SystemStats_CPUStats{}
	this.User = float32(r.Float32())
	if r.Intn(2) == 0 {
		this.User *= -1
	}
	this.System = float32(r.Float32())
	if r.Intn(2) == 0 {
		this.System *= -1
	}
	this.Idle = float32(r.Float32())
	if r.Intn(2) == 0 {
		this.Idle *= -1
	}
	this.Percentage = float32(r.Float32())
	if r.Intn(2) == 0 {
		this.Percentage *= -1
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedSystemStats_MemoryStats(r randyApi, easy bool) *SystemStats_MemoryStats {
	this := &SystemStats_MemoryStats{}
	this.Total = uint64(uint64(r.Uint32()))
	this.Available = uint64(uint64(r.Uint32()))
	this.Used = uint64(uint64(r.Uint32()))
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedComponentStats(r randyApi, easy bool) *ComponentStats {
	this := &ComponentStats{}
	this.Uptime = uint64(uint64(r.Uint32()))
	if r.Intn(5) != 0 {
		this.Cpu = NewPopulatedComponentStats_CPUStats(r, easy)
	}
	if r.Intn(5) != 0 {
		this.Memory = NewPopulatedComponentStats_MemoryStats(r, easy)
	}
	this.Goroutines = uint64(uint64(r.Uint32()))
	this.GcCpuFraction = float32(r.Float32())
	if r.Intn(2) == 0 {
		this.GcCpuFraction *= -1
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedComponentStats_CPUStats(r randyApi, easy bool) *ComponentStats_CPUStats {
	this := &ComponentStats_CPUStats{}
	this.User = float32(r.Float32())
	if r.Intn(2) == 0 {
		this.User *= -1
	}
	this.System = float32(r.Float32())
	if r.Intn(2) == 0 {
		this.System *= -1
	}
	this.Idle = float32(r.Float32())
	if r.Intn(2) == 0 {
		this.Idle *= -1
	}
	this.Percentage = float32(r.Float32())
	if r.Intn(2) == 0 {
		this.Percentage *= -1
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedComponentStats_MemoryStats(r randyApi, easy bool) *ComponentStats_MemoryStats {
	this := &ComponentStats_MemoryStats{}
	this.Memory = uint64(uint64(r.Uint32()))
	this.Swap = uint64(uint64(r.Uint32()))
	this.Heap = uint64(uint64(r.Uint32()))
	this.Stack = uint64(uint64(r.Uint32()))
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

type randyApi interface {
	Float32() float32
	Float64() float64
	Int63() int64
	Int31() int32
	Uint32() uint32
	Intn(n int) int
}

func randUTF8RuneApi(r randyApi) rune {
	ru := r.Intn(62)
	if ru < 10 {
		return rune(ru + 48)
	} else if ru < 36 {
		return rune(ru + 55)
	}
	return rune(ru + 61)
}
func randStringApi(r randyApi) string {
	v1 := r.Intn(100)
	tmps := make([]rune, v1)
	for i := 0; i < v1; i++ {
		tmps[i] = randUTF8RuneApi(r)
	}
	return string(tmps)
}
func randUnrecognizedApi(r randyApi, maxFieldNumber int) (dAtA []byte) {
	l := r.Intn(5)
	for i := 0; i < l; i++ {
		wire := r.Intn(4)
		if wire == 3 {
			wire = 5
		}
		fieldNumber := maxFieldNumber + r.Intn(100)
		dAtA = randFieldApi(dAtA, r, fieldNumber, wire)
	}
	return dAtA
}
func randFieldApi(dAtA []byte, r randyApi, fieldNumber int, wire int) []byte {
	key := uint32(fieldNumber)<<3 | uint32(wire)
	switch wire {
	case 0:
		dAtA = encodeVarintPopulateApi(dAtA, uint64(key))
		v2 := r.Int63()
		if r.Intn(2) == 0 {
			v2 *= -1
		}
		dAtA = encodeVarintPopulateApi(dAtA, uint64(v2))
	case 1:
		dAtA = encodeVarintPopulateApi(dAtA, uint64(key))
		dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
	case 2:
		dAtA = encodeVarintPopulateApi(dAtA, uint64(key))
		ll := r.Intn(100)
		dAtA = encodeVarintPopulateApi(dAtA, uint64(ll))
		for j := 0; j < ll; j++ {
			dAtA = append(dAtA, byte(r.Intn(256)))
		}
	default:
		dAtA = encodeVarintPopulateApi(dAtA, uint64(key))
		dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
	}
	return dAtA
}
func encodeVarintPopulateApi(dAtA []byte, v uint64) []byte {
	for v >= 1<<7 {
		dAtA = append(dAtA, uint8(uint64(v)&0x7f|0x80))
		v >>= 7
	}
	dAtA = append(dAtA, uint8(v))
	return dAtA
}
func (m *Percentiles) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Percentile1 != 0 {
		n += 5
	}
	if m.Percentile5 != 0 {
		n += 5
	}
	if m.Percentile10 != 0 {
		n += 5
	}
	if m.Percentile25 != 0 {
		n += 5
	}
	if m.Percentile50 != 0 {
		n += 5
	}
	if m.Percentile75 != 0 {
		n += 5
	}
	if m.Percentile90 != 0 {
		n += 5
	}
	if m.Percentile95 != 0 {
		n += 5
	}
	if m.Percentile99 != 0 {
		n += 5
	}
	return n
}

func (m *Rates) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Rate1 != 0 {
		n += 5
	}
	if m.Rate5 != 0 {
		n += 5
	}
	if m.Rate15 != 0 {
		n += 5
	}
	return n
}

func (m *SystemStats) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Load != nil {
		l = m.Load.Size()
		n += 1 + l + sovApi(uint64(l))
	}
	if m.Cpu != nil {
		l = m.Cpu.Size()
		n += 1 + l + sovApi(uint64(l))
	}
	if m.Memory != nil {
		l = m.Memory.Size()
		n += 1 + l + sovApi(uint64(l))
	}
	return n
}

func (m *SystemStats_Loadstats) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Load1 != 0 {
		n += 5
	}
	if m.Load5 != 0 {
		n += 5
	}
	if m.Load15 != 0 {
		n += 5
	}
	return n
}

func (m *SystemStats_CPUStats) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.User != 0 {
		n += 5
	}
	if m.System != 0 {
		n += 5
	}
	if m.Idle != 0 {
		n += 5
	}
	if m.Percentage != 0 {
		n += 5
	}
	return n
}

func (m *SystemStats_MemoryStats) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Total != 0 {
		n += 1 + sovApi(uint64(m.Total))
	}
	if m.Available != 0 {
		n += 1 + sovApi(uint64(m.Available))
	}
	if m.Used != 0 {
		n += 1 + sovApi(uint64(m.Used))
	}
	return n
}

func (m *ComponentStats) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Uptime != 0 {
		n += 1 + sovApi(uint64(m.Uptime))
	}
	if m.Cpu != nil {
		l = m.Cpu.Size()
		n += 1 + l + sovApi(uint64(l))
	}
	if m.Memory != nil {
		l = m.Memory.Size()
		n += 1 + l + sovApi(uint64(l))
	}
	if m.Goroutines != 0 {
		n += 1 + sovApi(uint64(m.Goroutines))
	}
	if m.GcCpuFraction != 0 {
		n += 5
	}
	return n
}

func (m *ComponentStats_CPUStats) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.User != 0 {
		n += 5
	}
	if m.System != 0 {
		n += 5
	}
	if m.Idle != 0 {
		n += 5
	}
	if m.Percentage != 0 {
		n += 5
	}
	return n
}

func (m *ComponentStats_MemoryStats) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Memory != 0 {
		n += 1 + sovApi(uint64(m.Memory))
	}
	if m.Swap != 0 {
		n += 1 + sovApi(uint64(m.Swap))
	}
	if m.Heap != 0 {
		n += 1 + sovApi(uint64(m.Heap))
	}
	if m.Stack != 0 {
		n += 1 + sovApi(uint64(m.Stack))
	}
	return n
}

func sovApi(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozApi(x uint64) (n int) {
	return sovApi(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *Percentiles) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Percentiles{`,
		`Percentile1:` + fmt.Sprintf("%v", this.Percentile1) + `,`,
		`Percentile5:` + fmt.Sprintf("%v", this.Percentile5) + `,`,
		`Percentile10:` + fmt.Sprintf("%v", this.Percentile10) + `,`,
		`Percentile25:` + fmt.Sprintf("%v", this.Percentile25) + `,`,
		`Percentile50:` + fmt.Sprintf("%v", this.Percentile50) + `,`,
		`Percentile75:` + fmt.Sprintf("%v", this.Percentile75) + `,`,
		`Percentile90:` + fmt.Sprintf("%v", this.Percentile90) + `,`,
		`Percentile95:` + fmt.Sprintf("%v", this.Percentile95) + `,`,
		`Percentile99:` + fmt.Sprintf("%v", this.Percentile99) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Rates) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Rates{`,
		`Rate1:` + fmt.Sprintf("%v", this.Rate1) + `,`,
		`Rate5:` + fmt.Sprintf("%v", this.Rate5) + `,`,
		`Rate15:` + fmt.Sprintf("%v", this.Rate15) + `,`,
		`}`,
	}, "")
	return s
}
func (this *SystemStats) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&SystemStats{`,
		`Load:` + strings.Replace(fmt.Sprintf("%v", this.Load), "SystemStats_Loadstats", "SystemStats_Loadstats", 1) + `,`,
		`Cpu:` + strings.Replace(fmt.Sprintf("%v", this.Cpu), "SystemStats_CPUStats", "SystemStats_CPUStats", 1) + `,`,
		`Memory:` + strings.Replace(fmt.Sprintf("%v", this.Memory), "SystemStats_MemoryStats", "SystemStats_MemoryStats", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *SystemStats_Loadstats) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&SystemStats_Loadstats{`,
		`Load1:` + fmt.Sprintf("%v", this.Load1) + `,`,
		`Load5:` + fmt.Sprintf("%v", this.Load5) + `,`,
		`Load15:` + fmt.Sprintf("%v", this.Load15) + `,`,
		`}`,
	}, "")
	return s
}
func (this *SystemStats_CPUStats) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&SystemStats_CPUStats{`,
		`User:` + fmt.Sprintf("%v", this.User) + `,`,
		`System:` + fmt.Sprintf("%v", this.System) + `,`,
		`Idle:` + fmt.Sprintf("%v", this.Idle) + `,`,
		`Percentage:` + fmt.Sprintf("%v", this.Percentage) + `,`,
		`}`,
	}, "")
	return s
}
func (this *SystemStats_MemoryStats) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&SystemStats_MemoryStats{`,
		`Total:` + fmt.Sprintf("%v", this.Total) + `,`,
		`Available:` + fmt.Sprintf("%v", this.Available) + `,`,
		`Used:` + fmt.Sprintf("%v", this.Used) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ComponentStats) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ComponentStats{`,
		`Uptime:` + fmt.Sprintf("%v", this.Uptime) + `,`,
		`Cpu:` + strings.Replace(fmt.Sprintf("%v", this.Cpu), "ComponentStats_CPUStats", "ComponentStats_CPUStats", 1) + `,`,
		`Memory:` + strings.Replace(fmt.Sprintf("%v", this.Memory), "ComponentStats_MemoryStats", "ComponentStats_MemoryStats", 1) + `,`,
		`Goroutines:` + fmt.Sprintf("%v", this.Goroutines) + `,`,
		`GcCpuFraction:` + fmt.Sprintf("%v", this.GcCpuFraction) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ComponentStats_CPUStats) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ComponentStats_CPUStats{`,
		`User:` + fmt.Sprintf("%v", this.User) + `,`,
		`System:` + fmt.Sprintf("%v", this.System) + `,`,
		`Idle:` + fmt.Sprintf("%v", this.Idle) + `,`,
		`Percentage:` + fmt.Sprintf("%v", this.Percentage) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ComponentStats_MemoryStats) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ComponentStats_MemoryStats{`,
		`Memory:` + fmt.Sprintf("%v", this.Memory) + `,`,
		`Swap:` + fmt.Sprintf("%v", this.Swap) + `,`,
		`Heap:` + fmt.Sprintf("%v", this.Heap) + `,`,
		`Stack:` + fmt.Sprintf("%v", this.Stack) + `,`,
		`}`,
	}, "")
	return s
}
func valueToStringApi(v interface{}) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("*%v", pv)
}
func (m *Percentiles) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowApi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Percentiles: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Percentiles: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Percentile1", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Percentile1 = float32(math.Float32frombits(v))
		case 2:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Percentile5", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Percentile5 = float32(math.Float32frombits(v))
		case 3:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Percentile10", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Percentile10 = float32(math.Float32frombits(v))
		case 4:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Percentile25", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Percentile25 = float32(math.Float32frombits(v))
		case 5:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Percentile50", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Percentile50 = float32(math.Float32frombits(v))
		case 6:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Percentile75", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Percentile75 = float32(math.Float32frombits(v))
		case 7:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Percentile90", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Percentile90 = float32(math.Float32frombits(v))
		case 8:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Percentile95", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Percentile95 = float32(math.Float32frombits(v))
		case 9:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Percentile99", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Percentile99 = float32(math.Float32frombits(v))
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Rates) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowApi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Rates: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Rates: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Rate1", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Rate1 = float32(math.Float32frombits(v))
		case 2:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Rate5", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Rate5 = float32(math.Float32frombits(v))
		case 3:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Rate15", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Rate15 = float32(math.Float32frombits(v))
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SystemStats) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowApi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: SystemStats: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SystemStats: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Load", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApi
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthApi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Load == nil {
				m.Load = &SystemStats_Loadstats{}
			}
			if err := m.Load.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cpu", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApi
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthApi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Cpu == nil {
				m.Cpu = &SystemStats_CPUStats{}
			}
			if err := m.Cpu.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Memory", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApi
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthApi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Memory == nil {
				m.Memory = &SystemStats_MemoryStats{}
			}
			if err := m.Memory.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SystemStats_Loadstats) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowApi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Loadstats: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Loadstats: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Load1", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Load1 = float32(math.Float32frombits(v))
		case 2:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Load5", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Load5 = float32(math.Float32frombits(v))
		case 3:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Load15", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Load15 = float32(math.Float32frombits(v))
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SystemStats_CPUStats) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowApi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: CPUStats: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CPUStats: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field User", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.User = float32(math.Float32frombits(v))
		case 2:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field System", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.System = float32(math.Float32frombits(v))
		case 3:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Idle", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Idle = float32(math.Float32frombits(v))
		case 4:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Percentage", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Percentage = float32(math.Float32frombits(v))
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SystemStats_MemoryStats) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowApi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MemoryStats: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MemoryStats: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Total", wireType)
			}
			m.Total = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Total |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Available", wireType)
			}
			m.Available = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Available |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Used", wireType)
			}
			m.Used = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Used |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ComponentStats) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowApi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ComponentStats: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ComponentStats: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Uptime", wireType)
			}
			m.Uptime = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Uptime |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cpu", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApi
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthApi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Cpu == nil {
				m.Cpu = &ComponentStats_CPUStats{}
			}
			if err := m.Cpu.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Memory", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApi
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthApi
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Memory == nil {
				m.Memory = &ComponentStats_MemoryStats{}
			}
			if err := m.Memory.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Goroutines", wireType)
			}
			m.Goroutines = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Goroutines |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field GcCpuFraction", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.GcCpuFraction = float32(math.Float32frombits(v))
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ComponentStats_CPUStats) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowApi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: CPUStats: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CPUStats: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field User", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.User = float32(math.Float32frombits(v))
		case 2:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field System", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.System = float32(math.Float32frombits(v))
		case 3:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Idle", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Idle = float32(math.Float32frombits(v))
		case 4:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Percentage", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Percentage = float32(math.Float32frombits(v))
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ComponentStats_MemoryStats) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowApi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MemoryStats: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MemoryStats: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Memory", wireType)
			}
			m.Memory = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Memory |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Swap", wireType)
			}
			m.Swap = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Swap |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Heap", wireType)
			}
			m.Heap = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Heap |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Stack", wireType)
			}
			m.Stack = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Stack |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipApi(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowApi
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowApi
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowApi
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthApi
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupApi
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthApi
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthApi        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowApi          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupApi = fmt.Errorf("proto: unexpected end of group")
)