// Code generated by protoc-gen-go. DO NOT EDIT.
// source: vmserver.proto

/*
Package common is a generated protocol buffer package.

It is generated from these files:
	vmserver.proto

It has these top-level messages:
	GetMetricsRequest
	GetMetricsResponse
	LogsRequest
	LogLine
	File
	UploadResponse
	StartProxyRequest
	StartProxyResponse
	RunCmdRequest
	RunCmdResponse
	SetIPRequest
	SetIPResponse
	GetIPRequest
	GetIPResponse
	SetSandboxConfigRequest
	SetSandboxConfigResponse
	GetSandboxConfigRequest
	GetSandboxConfigResponse
	CopyFileRequest
	CopyFileResponse
	MountFsRequest
	MountFsResponse
	UnmountFsRequest
	UnmountFsResponse
	SetHostnameRequest
	SetHostnameResponse
	AddRouteRequest
	AddRouteResponse
	AddMountRequest
	AddMountResponse
	DelMountRequest
	DelMountResponse
*/
package common

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"

import (
	context "golang.org/x/net/context"
	grpc "google.golang.org/grpc"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = 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.ProtoPackageIsVersion2 // please upgrade the proto package

type GetMetricsRequest struct {
	Count int32 `protobuf:"varint,1,opt,name=count" json:"count,omitempty"`
}

func (m *GetMetricsRequest) Reset()                    { *m = GetMetricsRequest{} }
func (m *GetMetricsRequest) String() string            { return proto.CompactTextString(m) }
func (*GetMetricsRequest) ProtoMessage()               {}
func (*GetMetricsRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }

func (m *GetMetricsRequest) GetCount() int32 {
	if m != nil {
		return m.Count
	}
	return 0
}

type GetMetricsResponse struct {
	JsonMetricResponses [][]byte `protobuf:"bytes,1,rep,name=jsonMetricResponses,proto3" json:"jsonMetricResponses,omitempty"`
}

func (m *GetMetricsResponse) Reset()                    { *m = GetMetricsResponse{} }
func (m *GetMetricsResponse) String() string            { return proto.CompactTextString(m) }
func (*GetMetricsResponse) ProtoMessage()               {}
func (*GetMetricsResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }

func (m *GetMetricsResponse) GetJsonMetricResponses() [][]byte {
	if m != nil {
		return m.JsonMetricResponses
	}
	return nil
}

type LogsRequest struct {
	ContainerID string `protobuf:"bytes,1,opt,name=containerID" json:"containerID,omitempty"`
}

func (m *LogsRequest) Reset()                    { *m = LogsRequest{} }
func (m *LogsRequest) String() string            { return proto.CompactTextString(m) }
func (*LogsRequest) ProtoMessage()               {}
func (*LogsRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }

func (m *LogsRequest) GetContainerID() string {
	if m != nil {
		return m.ContainerID
	}
	return ""
}

type LogLine struct {
	LogLine string `protobuf:"bytes,1,opt,name=logLine" json:"logLine,omitempty"`
}

func (m *LogLine) Reset()                    { *m = LogLine{} }
func (m *LogLine) String() string            { return proto.CompactTextString(m) }
func (*LogLine) ProtoMessage()               {}
func (*LogLine) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }

func (m *LogLine) GetLogLine() string {
	if m != nil {
		return m.LogLine
	}
	return ""
}

type File struct {
	Size int64  `protobuf:"varint,1,opt,name=size" json:"size,omitempty"`
	Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
}

func (m *File) Reset()                    { *m = File{} }
func (m *File) String() string            { return proto.CompactTextString(m) }
func (*File) ProtoMessage()               {}
func (*File) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} }

func (m *File) GetSize() int64 {
	if m != nil {
		return m.Size
	}
	return 0
}

func (m *File) GetData() []byte {
	if m != nil {
		return m.Data
	}
	return nil
}

type UploadResponse struct {
}

func (m *UploadResponse) Reset()                    { *m = UploadResponse{} }
func (m *UploadResponse) String() string            { return proto.CompactTextString(m) }
func (*UploadResponse) ProtoMessage()               {}
func (*UploadResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} }

type StartProxyRequest struct {
	Ip          string `protobuf:"bytes,1,opt,name=ip" json:"ip,omitempty"`
	ClusterCidr string `protobuf:"bytes,2,opt,name=clusterCidr" json:"clusterCidr,omitempty"`
	Kubeconfig  []byte `protobuf:"bytes,3,opt,name=kubeconfig,proto3" json:"kubeconfig,omitempty"`
}

func (m *StartProxyRequest) Reset()                    { *m = StartProxyRequest{} }
func (m *StartProxyRequest) String() string            { return proto.CompactTextString(m) }
func (*StartProxyRequest) ProtoMessage()               {}
func (*StartProxyRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} }

func (m *StartProxyRequest) GetIp() string {
	if m != nil {
		return m.Ip
	}
	return ""
}

func (m *StartProxyRequest) GetClusterCidr() string {
	if m != nil {
		return m.ClusterCidr
	}
	return ""
}

func (m *StartProxyRequest) GetKubeconfig() []byte {
	if m != nil {
		return m.Kubeconfig
	}
	return nil
}

type StartProxyResponse struct {
}

func (m *StartProxyResponse) Reset()                    { *m = StartProxyResponse{} }
func (m *StartProxyResponse) String() string            { return proto.CompactTextString(m) }
func (*StartProxyResponse) ProtoMessage()               {}
func (*StartProxyResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} }

type RunCmdRequest struct {
	Cmd  string   `protobuf:"bytes,1,opt,name=cmd" json:"cmd,omitempty"`
	Args []string `protobuf:"bytes,2,rep,name=args" json:"args,omitempty"`
}

func (m *RunCmdRequest) Reset()                    { *m = RunCmdRequest{} }
func (m *RunCmdRequest) String() string            { return proto.CompactTextString(m) }
func (*RunCmdRequest) ProtoMessage()               {}
func (*RunCmdRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{8} }

func (m *RunCmdRequest) GetCmd() string {
	if m != nil {
		return m.Cmd
	}
	return ""
}

func (m *RunCmdRequest) GetArgs() []string {
	if m != nil {
		return m.Args
	}
	return nil
}

type RunCmdResponse struct {
}

func (m *RunCmdResponse) Reset()                    { *m = RunCmdResponse{} }
func (m *RunCmdResponse) String() string            { return proto.CompactTextString(m) }
func (*RunCmdResponse) ProtoMessage()               {}
func (*RunCmdResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{9} }

type SetIPRequest struct {
	Ip string `protobuf:"bytes,1,opt,name=ip" json:"ip,omitempty"`
}

func (m *SetIPRequest) Reset()                    { *m = SetIPRequest{} }
func (m *SetIPRequest) String() string            { return proto.CompactTextString(m) }
func (*SetIPRequest) ProtoMessage()               {}
func (*SetIPRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{10} }

func (m *SetIPRequest) GetIp() string {
	if m != nil {
		return m.Ip
	}
	return ""
}

type SetIPResponse struct {
}

func (m *SetIPResponse) Reset()                    { *m = SetIPResponse{} }
func (m *SetIPResponse) String() string            { return proto.CompactTextString(m) }
func (*SetIPResponse) ProtoMessage()               {}
func (*SetIPResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{11} }

type GetIPRequest struct {
}

func (m *GetIPRequest) Reset()                    { *m = GetIPRequest{} }
func (m *GetIPRequest) String() string            { return proto.CompactTextString(m) }
func (*GetIPRequest) ProtoMessage()               {}
func (*GetIPRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{12} }

type GetIPResponse struct {
	Ip string `protobuf:"bytes,1,opt,name=ip" json:"ip,omitempty"`
}

func (m *GetIPResponse) Reset()                    { *m = GetIPResponse{} }
func (m *GetIPResponse) String() string            { return proto.CompactTextString(m) }
func (*GetIPResponse) ProtoMessage()               {}
func (*GetIPResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{13} }

func (m *GetIPResponse) GetIp() string {
	if m != nil {
		return m.Ip
	}
	return ""
}

type SetSandboxConfigRequest struct {
	Config []byte `protobuf:"bytes,1,opt,name=config,proto3" json:"config,omitempty"`
}

func (m *SetSandboxConfigRequest) Reset()                    { *m = SetSandboxConfigRequest{} }
func (m *SetSandboxConfigRequest) String() string            { return proto.CompactTextString(m) }
func (*SetSandboxConfigRequest) ProtoMessage()               {}
func (*SetSandboxConfigRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{14} }

func (m *SetSandboxConfigRequest) GetConfig() []byte {
	if m != nil {
		return m.Config
	}
	return nil
}

type SetSandboxConfigResponse struct {
}

func (m *SetSandboxConfigResponse) Reset()                    { *m = SetSandboxConfigResponse{} }
func (m *SetSandboxConfigResponse) String() string            { return proto.CompactTextString(m) }
func (*SetSandboxConfigResponse) ProtoMessage()               {}
func (*SetSandboxConfigResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{15} }

type GetSandboxConfigRequest struct {
}

func (m *GetSandboxConfigRequest) Reset()                    { *m = GetSandboxConfigRequest{} }
func (m *GetSandboxConfigRequest) String() string            { return proto.CompactTextString(m) }
func (*GetSandboxConfigRequest) ProtoMessage()               {}
func (*GetSandboxConfigRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{16} }

type GetSandboxConfigResponse struct {
	Config []byte `protobuf:"bytes,1,opt,name=config,proto3" json:"config,omitempty"`
}

func (m *GetSandboxConfigResponse) Reset()                    { *m = GetSandboxConfigResponse{} }
func (m *GetSandboxConfigResponse) String() string            { return proto.CompactTextString(m) }
func (*GetSandboxConfigResponse) ProtoMessage()               {}
func (*GetSandboxConfigResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{17} }

func (m *GetSandboxConfigResponse) GetConfig() []byte {
	if m != nil {
		return m.Config
	}
	return nil
}

type CopyFileRequest struct {
	File     string `protobuf:"bytes,1,opt,name=file" json:"file,omitempty"`
	FileData []byte `protobuf:"bytes,2,opt,name=fileData,proto3" json:"fileData,omitempty"`
}

func (m *CopyFileRequest) Reset()                    { *m = CopyFileRequest{} }
func (m *CopyFileRequest) String() string            { return proto.CompactTextString(m) }
func (*CopyFileRequest) ProtoMessage()               {}
func (*CopyFileRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{18} }

func (m *CopyFileRequest) GetFile() string {
	if m != nil {
		return m.File
	}
	return ""
}

func (m *CopyFileRequest) GetFileData() []byte {
	if m != nil {
		return m.FileData
	}
	return nil
}

type CopyFileResponse struct {
}

func (m *CopyFileResponse) Reset()                    { *m = CopyFileResponse{} }
func (m *CopyFileResponse) String() string            { return proto.CompactTextString(m) }
func (*CopyFileResponse) ProtoMessage()               {}
func (*CopyFileResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{19} }

type MountFsRequest struct {
	Source   string `protobuf:"bytes,1,opt,name=source" json:"source,omitempty"`
	Target   string `protobuf:"bytes,2,opt,name=target" json:"target,omitempty"`
	Fstype   string `protobuf:"bytes,3,opt,name=fstype" json:"fstype,omitempty"`
	ReadOnly bool   `protobuf:"varint,4,opt,name=readOnly" json:"readOnly,omitempty"`
}

func (m *MountFsRequest) Reset()                    { *m = MountFsRequest{} }
func (m *MountFsRequest) String() string            { return proto.CompactTextString(m) }
func (*MountFsRequest) ProtoMessage()               {}
func (*MountFsRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{20} }

func (m *MountFsRequest) GetSource() string {
	if m != nil {
		return m.Source
	}
	return ""
}

func (m *MountFsRequest) GetTarget() string {
	if m != nil {
		return m.Target
	}
	return ""
}

func (m *MountFsRequest) GetFstype() string {
	if m != nil {
		return m.Fstype
	}
	return ""
}

func (m *MountFsRequest) GetReadOnly() bool {
	if m != nil {
		return m.ReadOnly
	}
	return false
}

type MountFsResponse struct {
}

func (m *MountFsResponse) Reset()                    { *m = MountFsResponse{} }
func (m *MountFsResponse) String() string            { return proto.CompactTextString(m) }
func (*MountFsResponse) ProtoMessage()               {}
func (*MountFsResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{21} }

type UnmountFsRequest struct {
	Target string `protobuf:"bytes,1,opt,name=target" json:"target,omitempty"`
}

func (m *UnmountFsRequest) Reset()                    { *m = UnmountFsRequest{} }
func (m *UnmountFsRequest) String() string            { return proto.CompactTextString(m) }
func (*UnmountFsRequest) ProtoMessage()               {}
func (*UnmountFsRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{22} }

func (m *UnmountFsRequest) GetTarget() string {
	if m != nil {
		return m.Target
	}
	return ""
}

type UnmountFsResponse struct {
}

func (m *UnmountFsResponse) Reset()                    { *m = UnmountFsResponse{} }
func (m *UnmountFsResponse) String() string            { return proto.CompactTextString(m) }
func (*UnmountFsResponse) ProtoMessage()               {}
func (*UnmountFsResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{23} }

type SetHostnameRequest struct {
	Hostname string `protobuf:"bytes,1,opt,name=hostname" json:"hostname,omitempty"`
}

func (m *SetHostnameRequest) Reset()                    { *m = SetHostnameRequest{} }
func (m *SetHostnameRequest) String() string            { return proto.CompactTextString(m) }
func (*SetHostnameRequest) ProtoMessage()               {}
func (*SetHostnameRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{24} }

func (m *SetHostnameRequest) GetHostname() string {
	if m != nil {
		return m.Hostname
	}
	return ""
}

type SetHostnameResponse struct {
}

func (m *SetHostnameResponse) Reset()                    { *m = SetHostnameResponse{} }
func (m *SetHostnameResponse) String() string            { return proto.CompactTextString(m) }
func (*SetHostnameResponse) ProtoMessage()               {}
func (*SetHostnameResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{25} }

type AddRouteRequest struct {
	Target  string `protobuf:"bytes,1,opt,name=target" json:"target,omitempty"`
	Gateway string `protobuf:"bytes,2,opt,name=gateway" json:"gateway,omitempty"`
}

func (m *AddRouteRequest) Reset()                    { *m = AddRouteRequest{} }
func (m *AddRouteRequest) String() string            { return proto.CompactTextString(m) }
func (*AddRouteRequest) ProtoMessage()               {}
func (*AddRouteRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{26} }

func (m *AddRouteRequest) GetTarget() string {
	if m != nil {
		return m.Target
	}
	return ""
}

func (m *AddRouteRequest) GetGateway() string {
	if m != nil {
		return m.Gateway
	}
	return ""
}

type AddRouteResponse struct {
}

func (m *AddRouteResponse) Reset()                    { *m = AddRouteResponse{} }
func (m *AddRouteResponse) String() string            { return proto.CompactTextString(m) }
func (*AddRouteResponse) ProtoMessage()               {}
func (*AddRouteResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{27} }

type AddMountRequest struct {
	Volume     string `protobuf:"bytes,1,opt,name=volume" json:"volume,omitempty"`
	MountPoint string `protobuf:"bytes,2,opt,name=mountPoint" json:"mountPoint,omitempty"`
	FsType     string `protobuf:"bytes,3,opt,name=fsType" json:"fsType,omitempty"`
	Device     string `protobuf:"bytes,4,opt,name=device" json:"device,omitempty"`
	ReadOnly   bool   `protobuf:"varint,5,opt,name=readOnly" json:"readOnly,omitempty"`
	PodUUID    string `protobuf:"bytes,6,opt,name=podUUID" json:"podUUID,omitempty"`
}

func (m *AddMountRequest) Reset()                    { *m = AddMountRequest{} }
func (m *AddMountRequest) String() string            { return proto.CompactTextString(m) }
func (*AddMountRequest) ProtoMessage()               {}
func (*AddMountRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{28} }

func (m *AddMountRequest) GetVolume() string {
	if m != nil {
		return m.Volume
	}
	return ""
}

func (m *AddMountRequest) GetMountPoint() string {
	if m != nil {
		return m.MountPoint
	}
	return ""
}

func (m *AddMountRequest) GetFsType() string {
	if m != nil {
		return m.FsType
	}
	return ""
}

func (m *AddMountRequest) GetDevice() string {
	if m != nil {
		return m.Device
	}
	return ""
}

func (m *AddMountRequest) GetReadOnly() bool {
	if m != nil {
		return m.ReadOnly
	}
	return false
}

func (m *AddMountRequest) GetPodUUID() string {
	if m != nil {
		return m.PodUUID
	}
	return ""
}

type AddMountResponse struct {
}

func (m *AddMountResponse) Reset()                    { *m = AddMountResponse{} }
func (m *AddMountResponse) String() string            { return proto.CompactTextString(m) }
func (*AddMountResponse) ProtoMessage()               {}
func (*AddMountResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{29} }

type DelMountRequest struct {
	MountPoint string `protobuf:"bytes,1,opt,name=mountPoint" json:"mountPoint,omitempty"`
}

func (m *DelMountRequest) Reset()                    { *m = DelMountRequest{} }
func (m *DelMountRequest) String() string            { return proto.CompactTextString(m) }
func (*DelMountRequest) ProtoMessage()               {}
func (*DelMountRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{30} }

func (m *DelMountRequest) GetMountPoint() string {
	if m != nil {
		return m.MountPoint
	}
	return ""
}

type DelMountResponse struct {
}

func (m *DelMountResponse) Reset()                    { *m = DelMountResponse{} }
func (m *DelMountResponse) String() string            { return proto.CompactTextString(m) }
func (*DelMountResponse) ProtoMessage()               {}
func (*DelMountResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{31} }

func init() {
	proto.RegisterType((*GetMetricsRequest)(nil), "common.GetMetricsRequest")
	proto.RegisterType((*GetMetricsResponse)(nil), "common.GetMetricsResponse")
	proto.RegisterType((*LogsRequest)(nil), "common.LogsRequest")
	proto.RegisterType((*LogLine)(nil), "common.LogLine")
	proto.RegisterType((*File)(nil), "common.File")
	proto.RegisterType((*UploadResponse)(nil), "common.UploadResponse")
	proto.RegisterType((*StartProxyRequest)(nil), "common.StartProxyRequest")
	proto.RegisterType((*StartProxyResponse)(nil), "common.StartProxyResponse")
	proto.RegisterType((*RunCmdRequest)(nil), "common.RunCmdRequest")
	proto.RegisterType((*RunCmdResponse)(nil), "common.RunCmdResponse")
	proto.RegisterType((*SetIPRequest)(nil), "common.SetIPRequest")
	proto.RegisterType((*SetIPResponse)(nil), "common.SetIPResponse")
	proto.RegisterType((*GetIPRequest)(nil), "common.GetIPRequest")
	proto.RegisterType((*GetIPResponse)(nil), "common.GetIPResponse")
	proto.RegisterType((*SetSandboxConfigRequest)(nil), "common.SetSandboxConfigRequest")
	proto.RegisterType((*SetSandboxConfigResponse)(nil), "common.SetSandboxConfigResponse")
	proto.RegisterType((*GetSandboxConfigRequest)(nil), "common.GetSandboxConfigRequest")
	proto.RegisterType((*GetSandboxConfigResponse)(nil), "common.GetSandboxConfigResponse")
	proto.RegisterType((*CopyFileRequest)(nil), "common.CopyFileRequest")
	proto.RegisterType((*CopyFileResponse)(nil), "common.CopyFileResponse")
	proto.RegisterType((*MountFsRequest)(nil), "common.MountFsRequest")
	proto.RegisterType((*MountFsResponse)(nil), "common.MountFsResponse")
	proto.RegisterType((*UnmountFsRequest)(nil), "common.UnmountFsRequest")
	proto.RegisterType((*UnmountFsResponse)(nil), "common.UnmountFsResponse")
	proto.RegisterType((*SetHostnameRequest)(nil), "common.SetHostnameRequest")
	proto.RegisterType((*SetHostnameResponse)(nil), "common.SetHostnameResponse")
	proto.RegisterType((*AddRouteRequest)(nil), "common.AddRouteRequest")
	proto.RegisterType((*AddRouteResponse)(nil), "common.AddRouteResponse")
	proto.RegisterType((*AddMountRequest)(nil), "common.AddMountRequest")
	proto.RegisterType((*AddMountResponse)(nil), "common.AddMountResponse")
	proto.RegisterType((*DelMountRequest)(nil), "common.DelMountRequest")
	proto.RegisterType((*DelMountResponse)(nil), "common.DelMountResponse")
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// Client API for Metrics service

type MetricsClient interface {
	GetMetrics(ctx context.Context, in *GetMetricsRequest, opts ...grpc.CallOption) (*GetMetricsResponse, error)
}

type metricsClient struct {
	cc *grpc.ClientConn
}

func NewMetricsClient(cc *grpc.ClientConn) MetricsClient {
	return &metricsClient{cc}
}

func (c *metricsClient) GetMetrics(ctx context.Context, in *GetMetricsRequest, opts ...grpc.CallOption) (*GetMetricsResponse, error) {
	out := new(GetMetricsResponse)
	err := grpc.Invoke(ctx, "/common.Metrics/GetMetrics", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// Server API for Metrics service

type MetricsServer interface {
	GetMetrics(context.Context, *GetMetricsRequest) (*GetMetricsResponse, error)
}

func RegisterMetricsServer(s *grpc.Server, srv MetricsServer) {
	s.RegisterService(&_Metrics_serviceDesc, srv)
}

func _Metrics_GetMetrics_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetMetricsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MetricsServer).GetMetrics(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/common.Metrics/GetMetrics",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MetricsServer).GetMetrics(ctx, req.(*GetMetricsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _Metrics_serviceDesc = grpc.ServiceDesc{
	ServiceName: "common.Metrics",
	HandlerType: (*MetricsServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetMetrics",
			Handler:    _Metrics_GetMetrics_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "vmserver.proto",
}

// Client API for Mounts service

type MountsClient interface {
	AddMount(ctx context.Context, in *AddMountRequest, opts ...grpc.CallOption) (*AddMountResponse, error)
	DelMount(ctx context.Context, in *DelMountRequest, opts ...grpc.CallOption) (*DelMountResponse, error)
}

type mountsClient struct {
	cc *grpc.ClientConn
}

func NewMountsClient(cc *grpc.ClientConn) MountsClient {
	return &mountsClient{cc}
}

func (c *mountsClient) AddMount(ctx context.Context, in *AddMountRequest, opts ...grpc.CallOption) (*AddMountResponse, error) {
	out := new(AddMountResponse)
	err := grpc.Invoke(ctx, "/common.Mounts/AddMount", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *mountsClient) DelMount(ctx context.Context, in *DelMountRequest, opts ...grpc.CallOption) (*DelMountResponse, error) {
	out := new(DelMountResponse)
	err := grpc.Invoke(ctx, "/common.Mounts/DelMount", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// Server API for Mounts service

type MountsServer interface {
	AddMount(context.Context, *AddMountRequest) (*AddMountResponse, error)
	DelMount(context.Context, *DelMountRequest) (*DelMountResponse, error)
}

func RegisterMountsServer(s *grpc.Server, srv MountsServer) {
	s.RegisterService(&_Mounts_serviceDesc, srv)
}

func _Mounts_AddMount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddMountRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MountsServer).AddMount(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/common.Mounts/AddMount",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MountsServer).AddMount(ctx, req.(*AddMountRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Mounts_DelMount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DelMountRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MountsServer).DelMount(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/common.Mounts/DelMount",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MountsServer).DelMount(ctx, req.(*DelMountRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _Mounts_serviceDesc = grpc.ServiceDesc{
	ServiceName: "common.Mounts",
	HandlerType: (*MountsServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "AddMount",
			Handler:    _Mounts_AddMount_Handler,
		},
		{
			MethodName: "DelMount",
			Handler:    _Mounts_DelMount_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "vmserver.proto",
}

// Client API for VMServer service

type VMServerClient interface {
	// rpc UploadFiles(File) returns (UploadResponse) {}
	StartProxy(ctx context.Context, in *StartProxyRequest, opts ...grpc.CallOption) (*StartProxyResponse, error)
	RunCmd(ctx context.Context, in *RunCmdRequest, opts ...grpc.CallOption) (*RunCmdResponse, error)
	SetPodIP(ctx context.Context, in *SetIPRequest, opts ...grpc.CallOption) (*SetIPResponse, error)
	GetPodIP(ctx context.Context, in *GetIPRequest, opts ...grpc.CallOption) (*GetIPResponse, error)
	SetSandboxConfig(ctx context.Context, in *SetSandboxConfigRequest, opts ...grpc.CallOption) (*SetSandboxConfigResponse, error)
	GetSandboxConfig(ctx context.Context, in *GetSandboxConfigRequest, opts ...grpc.CallOption) (*GetSandboxConfigResponse, error)
	CopyFile(ctx context.Context, in *CopyFileRequest, opts ...grpc.CallOption) (*CopyFileResponse, error)
	MountFs(ctx context.Context, in *MountFsRequest, opts ...grpc.CallOption) (*MountFsResponse, error)
	UnmountFs(ctx context.Context, in *UnmountFsRequest, opts ...grpc.CallOption) (*UnmountFsResponse, error)
	SetHostname(ctx context.Context, in *SetHostnameRequest, opts ...grpc.CallOption) (*SetHostnameResponse, error)
	Logs(ctx context.Context, in *LogsRequest, opts ...grpc.CallOption) (VMServer_LogsClient, error)
	GetMetrics(ctx context.Context, in *GetMetricsRequest, opts ...grpc.CallOption) (*GetMetricsResponse, error)
	AddRoute(ctx context.Context, in *AddRouteRequest, opts ...grpc.CallOption) (*AddRouteResponse, error)
}

type vMServerClient struct {
	cc *grpc.ClientConn
}

func NewVMServerClient(cc *grpc.ClientConn) VMServerClient {
	return &vMServerClient{cc}
}

func (c *vMServerClient) StartProxy(ctx context.Context, in *StartProxyRequest, opts ...grpc.CallOption) (*StartProxyResponse, error) {
	out := new(StartProxyResponse)
	err := grpc.Invoke(ctx, "/common.VMServer/StartProxy", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *vMServerClient) RunCmd(ctx context.Context, in *RunCmdRequest, opts ...grpc.CallOption) (*RunCmdResponse, error) {
	out := new(RunCmdResponse)
	err := grpc.Invoke(ctx, "/common.VMServer/RunCmd", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *vMServerClient) SetPodIP(ctx context.Context, in *SetIPRequest, opts ...grpc.CallOption) (*SetIPResponse, error) {
	out := new(SetIPResponse)
	err := grpc.Invoke(ctx, "/common.VMServer/SetPodIP", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *vMServerClient) GetPodIP(ctx context.Context, in *GetIPRequest, opts ...grpc.CallOption) (*GetIPResponse, error) {
	out := new(GetIPResponse)
	err := grpc.Invoke(ctx, "/common.VMServer/GetPodIP", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *vMServerClient) SetSandboxConfig(ctx context.Context, in *SetSandboxConfigRequest, opts ...grpc.CallOption) (*SetSandboxConfigResponse, error) {
	out := new(SetSandboxConfigResponse)
	err := grpc.Invoke(ctx, "/common.VMServer/SetSandboxConfig", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *vMServerClient) GetSandboxConfig(ctx context.Context, in *GetSandboxConfigRequest, opts ...grpc.CallOption) (*GetSandboxConfigResponse, error) {
	out := new(GetSandboxConfigResponse)
	err := grpc.Invoke(ctx, "/common.VMServer/GetSandboxConfig", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *vMServerClient) CopyFile(ctx context.Context, in *CopyFileRequest, opts ...grpc.CallOption) (*CopyFileResponse, error) {
	out := new(CopyFileResponse)
	err := grpc.Invoke(ctx, "/common.VMServer/CopyFile", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *vMServerClient) MountFs(ctx context.Context, in *MountFsRequest, opts ...grpc.CallOption) (*MountFsResponse, error) {
	out := new(MountFsResponse)
	err := grpc.Invoke(ctx, "/common.VMServer/MountFs", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *vMServerClient) UnmountFs(ctx context.Context, in *UnmountFsRequest, opts ...grpc.CallOption) (*UnmountFsResponse, error) {
	out := new(UnmountFsResponse)
	err := grpc.Invoke(ctx, "/common.VMServer/UnmountFs", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *vMServerClient) SetHostname(ctx context.Context, in *SetHostnameRequest, opts ...grpc.CallOption) (*SetHostnameResponse, error) {
	out := new(SetHostnameResponse)
	err := grpc.Invoke(ctx, "/common.VMServer/SetHostname", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *vMServerClient) Logs(ctx context.Context, in *LogsRequest, opts ...grpc.CallOption) (VMServer_LogsClient, error) {
	stream, err := grpc.NewClientStream(ctx, &_VMServer_serviceDesc.Streams[0], c.cc, "/common.VMServer/Logs", opts...)
	if err != nil {
		return nil, err
	}
	x := &vMServerLogsClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type VMServer_LogsClient interface {
	Recv() (*LogLine, error)
	grpc.ClientStream
}

type vMServerLogsClient struct {
	grpc.ClientStream
}

func (x *vMServerLogsClient) Recv() (*LogLine, error) {
	m := new(LogLine)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *vMServerClient) GetMetrics(ctx context.Context, in *GetMetricsRequest, opts ...grpc.CallOption) (*GetMetricsResponse, error) {
	out := new(GetMetricsResponse)
	err := grpc.Invoke(ctx, "/common.VMServer/GetMetrics", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *vMServerClient) AddRoute(ctx context.Context, in *AddRouteRequest, opts ...grpc.CallOption) (*AddRouteResponse, error) {
	out := new(AddRouteResponse)
	err := grpc.Invoke(ctx, "/common.VMServer/AddRoute", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// Server API for VMServer service

type VMServerServer interface {
	// rpc UploadFiles(File) returns (UploadResponse) {}
	StartProxy(context.Context, *StartProxyRequest) (*StartProxyResponse, error)
	RunCmd(context.Context, *RunCmdRequest) (*RunCmdResponse, error)
	SetPodIP(context.Context, *SetIPRequest) (*SetIPResponse, error)
	GetPodIP(context.Context, *GetIPRequest) (*GetIPResponse, error)
	SetSandboxConfig(context.Context, *SetSandboxConfigRequest) (*SetSandboxConfigResponse, error)
	GetSandboxConfig(context.Context, *GetSandboxConfigRequest) (*GetSandboxConfigResponse, error)
	CopyFile(context.Context, *CopyFileRequest) (*CopyFileResponse, error)
	MountFs(context.Context, *MountFsRequest) (*MountFsResponse, error)
	UnmountFs(context.Context, *UnmountFsRequest) (*UnmountFsResponse, error)
	SetHostname(context.Context, *SetHostnameRequest) (*SetHostnameResponse, error)
	Logs(*LogsRequest, VMServer_LogsServer) error
	GetMetrics(context.Context, *GetMetricsRequest) (*GetMetricsResponse, error)
	AddRoute(context.Context, *AddRouteRequest) (*AddRouteResponse, error)
}

func RegisterVMServerServer(s *grpc.Server, srv VMServerServer) {
	s.RegisterService(&_VMServer_serviceDesc, srv)
}

func _VMServer_StartProxy_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StartProxyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VMServerServer).StartProxy(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/common.VMServer/StartProxy",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VMServerServer).StartProxy(ctx, req.(*StartProxyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _VMServer_RunCmd_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RunCmdRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VMServerServer).RunCmd(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/common.VMServer/RunCmd",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VMServerServer).RunCmd(ctx, req.(*RunCmdRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _VMServer_SetPodIP_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetIPRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VMServerServer).SetPodIP(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/common.VMServer/SetPodIP",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VMServerServer).SetPodIP(ctx, req.(*SetIPRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _VMServer_GetPodIP_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetIPRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VMServerServer).GetPodIP(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/common.VMServer/GetPodIP",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VMServerServer).GetPodIP(ctx, req.(*GetIPRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _VMServer_SetSandboxConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetSandboxConfigRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VMServerServer).SetSandboxConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/common.VMServer/SetSandboxConfig",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VMServerServer).SetSandboxConfig(ctx, req.(*SetSandboxConfigRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _VMServer_GetSandboxConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetSandboxConfigRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VMServerServer).GetSandboxConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/common.VMServer/GetSandboxConfig",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VMServerServer).GetSandboxConfig(ctx, req.(*GetSandboxConfigRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _VMServer_CopyFile_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CopyFileRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VMServerServer).CopyFile(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/common.VMServer/CopyFile",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VMServerServer).CopyFile(ctx, req.(*CopyFileRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _VMServer_MountFs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MountFsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VMServerServer).MountFs(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/common.VMServer/MountFs",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VMServerServer).MountFs(ctx, req.(*MountFsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _VMServer_UnmountFs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UnmountFsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VMServerServer).UnmountFs(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/common.VMServer/UnmountFs",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VMServerServer).UnmountFs(ctx, req.(*UnmountFsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _VMServer_SetHostname_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetHostnameRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VMServerServer).SetHostname(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/common.VMServer/SetHostname",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VMServerServer).SetHostname(ctx, req.(*SetHostnameRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _VMServer_Logs_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(LogsRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(VMServerServer).Logs(m, &vMServerLogsServer{stream})
}

type VMServer_LogsServer interface {
	Send(*LogLine) error
	grpc.ServerStream
}

type vMServerLogsServer struct {
	grpc.ServerStream
}

func (x *vMServerLogsServer) Send(m *LogLine) error {
	return x.ServerStream.SendMsg(m)
}

func _VMServer_GetMetrics_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetMetricsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VMServerServer).GetMetrics(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/common.VMServer/GetMetrics",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VMServerServer).GetMetrics(ctx, req.(*GetMetricsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _VMServer_AddRoute_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddRouteRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VMServerServer).AddRoute(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/common.VMServer/AddRoute",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VMServerServer).AddRoute(ctx, req.(*AddRouteRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _VMServer_serviceDesc = grpc.ServiceDesc{
	ServiceName: "common.VMServer",
	HandlerType: (*VMServerServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "StartProxy",
			Handler:    _VMServer_StartProxy_Handler,
		},
		{
			MethodName: "RunCmd",
			Handler:    _VMServer_RunCmd_Handler,
		},
		{
			MethodName: "SetPodIP",
			Handler:    _VMServer_SetPodIP_Handler,
		},
		{
			MethodName: "GetPodIP",
			Handler:    _VMServer_GetPodIP_Handler,
		},
		{
			MethodName: "SetSandboxConfig",
			Handler:    _VMServer_SetSandboxConfig_Handler,
		},
		{
			MethodName: "GetSandboxConfig",
			Handler:    _VMServer_GetSandboxConfig_Handler,
		},
		{
			MethodName: "CopyFile",
			Handler:    _VMServer_CopyFile_Handler,
		},
		{
			MethodName: "MountFs",
			Handler:    _VMServer_MountFs_Handler,
		},
		{
			MethodName: "UnmountFs",
			Handler:    _VMServer_UnmountFs_Handler,
		},
		{
			MethodName: "SetHostname",
			Handler:    _VMServer_SetHostname_Handler,
		},
		{
			MethodName: "GetMetrics",
			Handler:    _VMServer_GetMetrics_Handler,
		},
		{
			MethodName: "AddRoute",
			Handler:    _VMServer_AddRoute_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "Logs",
			Handler:       _VMServer_Logs_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "vmserver.proto",
}

func init() { proto.RegisterFile("vmserver.proto", fileDescriptor0) }

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