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

/*
Package profile is a generated protocol buffer package.

It is generated from these files:
	profile.proto

It has these top-level messages:
	ListMessage
	ProfileInfo
	AnalysisMessage
	Ack
	AckCheck
	ProfileLog
	CollectFlag
	TrainMessage
	DefineMessage
	ScheduleMessage
*/
package profile

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 ListMessage struct {
	WorkloadType string `protobuf:"bytes,1,opt,name=WorkloadType" json:"WorkloadType,omitempty"`
	ProfileNames string `protobuf:"bytes,2,opt,name=ProfileNames" json:"ProfileNames,omitempty"`
	Active       string `protobuf:"bytes,3,opt,name=Active" json:"Active,omitempty"`
}

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

func (m *ListMessage) GetWorkloadType() string {
	if m != nil {
		return m.WorkloadType
	}
	return ""
}

func (m *ListMessage) GetProfileNames() string {
	if m != nil {
		return m.ProfileNames
	}
	return ""
}

func (m *ListMessage) GetActive() string {
	if m != nil {
		return m.Active
	}
	return ""
}

type ProfileInfo struct {
	Name    string `protobuf:"bytes,1,opt,name=Name" json:"Name,omitempty"`
	Content []byte `protobuf:"bytes,2,opt,name=Content,proto3" json:"Content,omitempty"`
}

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

func (m *ProfileInfo) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *ProfileInfo) GetContent() []byte {
	if m != nil {
		return m.Content
	}
	return nil
}

type AnalysisMessage struct {
	Name  string `protobuf:"bytes,1,opt,name=Name" json:"Name,omitempty"`
	Model string `protobuf:"bytes,2,opt,name=Model" json:"Model,omitempty"`
}

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

func (m *AnalysisMessage) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *AnalysisMessage) GetModel() string {
	if m != nil {
		return m.Model
	}
	return ""
}

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

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

func (m *Ack) GetStatus() string {
	if m != nil {
		return m.Status
	}
	return ""
}

type AckCheck struct {
	Name        string `protobuf:"bytes,1,opt,name=Name" json:"Name,omitempty"`
	Status      string `protobuf:"bytes,2,opt,name=Status" json:"Status,omitempty"`
	Description string `protobuf:"bytes,3,opt,name=Description" json:"Description,omitempty"`
}

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

func (m *AckCheck) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *AckCheck) GetStatus() string {
	if m != nil {
		return m.Status
	}
	return ""
}

func (m *AckCheck) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

type ProfileLog struct {
	Id        int64  `protobuf:"varint,1,opt,name=Id" json:"Id,omitempty"`
	ProfileId string `protobuf:"bytes,2,opt,name=ProfileId" json:"ProfileId,omitempty"`
	Timestamp string `protobuf:"bytes,3,opt,name=Timestamp" json:"Timestamp,omitempty"`
}

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

func (m *ProfileLog) GetId() int64 {
	if m != nil {
		return m.Id
	}
	return 0
}

func (m *ProfileLog) GetProfileId() string {
	if m != nil {
		return m.ProfileId
	}
	return ""
}

func (m *ProfileLog) GetTimestamp() string {
	if m != nil {
		return m.Timestamp
	}
	return ""
}

type CollectFlag struct {
	Interval   int64  `protobuf:"varint,1,opt,name=Interval" json:"Interval,omitempty"`
	Duration   int64  `protobuf:"varint,2,opt,name=Duration" json:"Duration,omitempty"`
	Workload   string `protobuf:"bytes,3,opt,name=Workload" json:"Workload,omitempty"`
	OutputPath string `protobuf:"bytes,4,opt,name=OutputPath" json:"OutputPath,omitempty"`
	Block      string `protobuf:"bytes,5,opt,name=Block" json:"Block,omitempty"`
	Network    string `protobuf:"bytes,6,opt,name=Network" json:"Network,omitempty"`
	Type       string `protobuf:"bytes,7,opt,name=Type" json:"Type,omitempty"`
}

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

func (m *CollectFlag) GetInterval() int64 {
	if m != nil {
		return m.Interval
	}
	return 0
}

func (m *CollectFlag) GetDuration() int64 {
	if m != nil {
		return m.Duration
	}
	return 0
}

func (m *CollectFlag) GetWorkload() string {
	if m != nil {
		return m.Workload
	}
	return ""
}

func (m *CollectFlag) GetOutputPath() string {
	if m != nil {
		return m.OutputPath
	}
	return ""
}

func (m *CollectFlag) GetBlock() string {
	if m != nil {
		return m.Block
	}
	return ""
}

func (m *CollectFlag) GetNetwork() string {
	if m != nil {
		return m.Network
	}
	return ""
}

func (m *CollectFlag) GetType() string {
	if m != nil {
		return m.Type
	}
	return ""
}

type TrainMessage struct {
	DataPath   string `protobuf:"bytes,1,opt,name=DataPath" json:"DataPath,omitempty"`
	OutputPath string `protobuf:"bytes,2,opt,name=OutputPath" json:"OutputPath,omitempty"`
}

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

func (m *TrainMessage) GetDataPath() string {
	if m != nil {
		return m.DataPath
	}
	return ""
}

func (m *TrainMessage) GetOutputPath() string {
	if m != nil {
		return m.OutputPath
	}
	return ""
}

type DefineMessage struct {
	WorkloadType string `protobuf:"bytes,1,opt,name=WorkloadType" json:"WorkloadType,omitempty"`
	ProfileName  string `protobuf:"bytes,2,opt,name=ProfileName" json:"ProfileName,omitempty"`
	Content      []byte `protobuf:"bytes,3,opt,name=Content,proto3" json:"Content,omitempty"`
}

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

func (m *DefineMessage) GetWorkloadType() string {
	if m != nil {
		return m.WorkloadType
	}
	return ""
}

func (m *DefineMessage) GetProfileName() string {
	if m != nil {
		return m.ProfileName
	}
	return ""
}

func (m *DefineMessage) GetContent() []byte {
	if m != nil {
		return m.Content
	}
	return nil
}

type ScheduleMessage struct {
	App      string `protobuf:"bytes,1,opt,name=App" json:"App,omitempty"`
	Type     string `protobuf:"bytes,2,opt,name=Type" json:"Type,omitempty"`
	Strategy string `protobuf:"bytes,3,opt,name=Strategy" json:"Strategy,omitempty"`
}

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

func (m *ScheduleMessage) GetApp() string {
	if m != nil {
		return m.App
	}
	return ""
}

func (m *ScheduleMessage) GetType() string {
	if m != nil {
		return m.Type
	}
	return ""
}

func (m *ScheduleMessage) GetStrategy() string {
	if m != nil {
		return m.Strategy
	}
	return ""
}

func init() {
	proto.RegisterType((*ListMessage)(nil), "profile.ListMessage")
	proto.RegisterType((*ProfileInfo)(nil), "profile.ProfileInfo")
	proto.RegisterType((*AnalysisMessage)(nil), "profile.AnalysisMessage")
	proto.RegisterType((*Ack)(nil), "profile.Ack")
	proto.RegisterType((*AckCheck)(nil), "profile.AckCheck")
	proto.RegisterType((*ProfileLog)(nil), "profile.ProfileLog")
	proto.RegisterType((*CollectFlag)(nil), "profile.CollectFlag")
	proto.RegisterType((*TrainMessage)(nil), "profile.TrainMessage")
	proto.RegisterType((*DefineMessage)(nil), "profile.DefineMessage")
	proto.RegisterType((*ScheduleMessage)(nil), "profile.ScheduleMessage")
}

// 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 ProfileMgr service

type ProfileMgrClient interface {
	Profile(ctx context.Context, in *ProfileInfo, opts ...grpc.CallOption) (ProfileMgr_ProfileClient, error)
	CheckInitProfile(ctx context.Context, in *ProfileInfo, opts ...grpc.CallOption) (ProfileMgr_CheckInitProfileClient, error)
	Analysis(ctx context.Context, in *AnalysisMessage, opts ...grpc.CallOption) (ProfileMgr_AnalysisClient, error)
	Tuning(ctx context.Context, in *ProfileInfo, opts ...grpc.CallOption) (ProfileMgr_TuningClient, error)
	ListWorkload(ctx context.Context, in *ProfileInfo, opts ...grpc.CallOption) (ProfileMgr_ListWorkloadClient, error)
	UpgradeProfile(ctx context.Context, in *ProfileInfo, opts ...grpc.CallOption) (ProfileMgr_UpgradeProfileClient, error)
	InfoProfile(ctx context.Context, in *ProfileInfo, opts ...grpc.CallOption) (ProfileMgr_InfoProfileClient, error)
	CheckActiveProfile(ctx context.Context, in *ProfileInfo, opts ...grpc.CallOption) (ProfileMgr_CheckActiveProfileClient, error)
	ProfileRollback(ctx context.Context, in *ProfileInfo, opts ...grpc.CallOption) (ProfileMgr_ProfileRollbackClient, error)
	Charaterization(ctx context.Context, in *ProfileInfo, opts ...grpc.CallOption) (ProfileMgr_CharaterizationClient, error)
	Collection(ctx context.Context, in *CollectFlag, opts ...grpc.CallOption) (ProfileMgr_CollectionClient, error)
	Training(ctx context.Context, in *TrainMessage, opts ...grpc.CallOption) (ProfileMgr_TrainingClient, error)
	Define(ctx context.Context, in *DefineMessage, opts ...grpc.CallOption) (*Ack, error)
	Delete(ctx context.Context, in *DefineMessage, opts ...grpc.CallOption) (*Ack, error)
	Update(ctx context.Context, in *DefineMessage, opts ...grpc.CallOption) (*Ack, error)
	Schedule(ctx context.Context, in *ScheduleMessage, opts ...grpc.CallOption) (ProfileMgr_ScheduleClient, error)
}

type profileMgrClient struct {
	cc *grpc.ClientConn
}

func NewProfileMgrClient(cc *grpc.ClientConn) ProfileMgrClient {
	return &profileMgrClient{cc}
}

func (c *profileMgrClient) Profile(ctx context.Context, in *ProfileInfo, opts ...grpc.CallOption) (ProfileMgr_ProfileClient, error) {
	stream, err := grpc.NewClientStream(ctx, &_ProfileMgr_serviceDesc.Streams[0], c.cc, "/profile.ProfileMgr/Profile", opts...)
	if err != nil {
		return nil, err
	}
	x := &profileMgrProfileClient{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 ProfileMgr_ProfileClient interface {
	Recv() (*AckCheck, error)
	grpc.ClientStream
}

type profileMgrProfileClient struct {
	grpc.ClientStream
}

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

func (c *profileMgrClient) CheckInitProfile(ctx context.Context, in *ProfileInfo, opts ...grpc.CallOption) (ProfileMgr_CheckInitProfileClient, error) {
	stream, err := grpc.NewClientStream(ctx, &_ProfileMgr_serviceDesc.Streams[1], c.cc, "/profile.ProfileMgr/CheckInitProfile", opts...)
	if err != nil {
		return nil, err
	}
	x := &profileMgrCheckInitProfileClient{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 ProfileMgr_CheckInitProfileClient interface {
	Recv() (*AckCheck, error)
	grpc.ClientStream
}

type profileMgrCheckInitProfileClient struct {
	grpc.ClientStream
}

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

func (c *profileMgrClient) Analysis(ctx context.Context, in *AnalysisMessage, opts ...grpc.CallOption) (ProfileMgr_AnalysisClient, error) {
	stream, err := grpc.NewClientStream(ctx, &_ProfileMgr_serviceDesc.Streams[2], c.cc, "/profile.ProfileMgr/Analysis", opts...)
	if err != nil {
		return nil, err
	}
	x := &profileMgrAnalysisClient{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 ProfileMgr_AnalysisClient interface {
	Recv() (*AckCheck, error)
	grpc.ClientStream
}

type profileMgrAnalysisClient struct {
	grpc.ClientStream
}

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

func (c *profileMgrClient) Tuning(ctx context.Context, in *ProfileInfo, opts ...grpc.CallOption) (ProfileMgr_TuningClient, error) {
	stream, err := grpc.NewClientStream(ctx, &_ProfileMgr_serviceDesc.Streams[3], c.cc, "/profile.ProfileMgr/Tuning", opts...)
	if err != nil {
		return nil, err
	}
	x := &profileMgrTuningClient{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 ProfileMgr_TuningClient interface {
	Recv() (*AckCheck, error)
	grpc.ClientStream
}

type profileMgrTuningClient struct {
	grpc.ClientStream
}

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

func (c *profileMgrClient) ListWorkload(ctx context.Context, in *ProfileInfo, opts ...grpc.CallOption) (ProfileMgr_ListWorkloadClient, error) {
	stream, err := grpc.NewClientStream(ctx, &_ProfileMgr_serviceDesc.Streams[4], c.cc, "/profile.ProfileMgr/ListWorkload", opts...)
	if err != nil {
		return nil, err
	}
	x := &profileMgrListWorkloadClient{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 ProfileMgr_ListWorkloadClient interface {
	Recv() (*ListMessage, error)
	grpc.ClientStream
}

type profileMgrListWorkloadClient struct {
	grpc.ClientStream
}

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

func (c *profileMgrClient) UpgradeProfile(ctx context.Context, in *ProfileInfo, opts ...grpc.CallOption) (ProfileMgr_UpgradeProfileClient, error) {
	stream, err := grpc.NewClientStream(ctx, &_ProfileMgr_serviceDesc.Streams[5], c.cc, "/profile.ProfileMgr/UpgradeProfile", opts...)
	if err != nil {
		return nil, err
	}
	x := &profileMgrUpgradeProfileClient{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 ProfileMgr_UpgradeProfileClient interface {
	Recv() (*AckCheck, error)
	grpc.ClientStream
}

type profileMgrUpgradeProfileClient struct {
	grpc.ClientStream
}

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

func (c *profileMgrClient) InfoProfile(ctx context.Context, in *ProfileInfo, opts ...grpc.CallOption) (ProfileMgr_InfoProfileClient, error) {
	stream, err := grpc.NewClientStream(ctx, &_ProfileMgr_serviceDesc.Streams[6], c.cc, "/profile.ProfileMgr/InfoProfile", opts...)
	if err != nil {
		return nil, err
	}
	x := &profileMgrInfoProfileClient{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 ProfileMgr_InfoProfileClient interface {
	Recv() (*ProfileInfo, error)
	grpc.ClientStream
}

type profileMgrInfoProfileClient struct {
	grpc.ClientStream
}

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

func (c *profileMgrClient) CheckActiveProfile(ctx context.Context, in *ProfileInfo, opts ...grpc.CallOption) (ProfileMgr_CheckActiveProfileClient, error) {
	stream, err := grpc.NewClientStream(ctx, &_ProfileMgr_serviceDesc.Streams[7], c.cc, "/profile.ProfileMgr/CheckActiveProfile", opts...)
	if err != nil {
		return nil, err
	}
	x := &profileMgrCheckActiveProfileClient{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 ProfileMgr_CheckActiveProfileClient interface {
	Recv() (*AckCheck, error)
	grpc.ClientStream
}

type profileMgrCheckActiveProfileClient struct {
	grpc.ClientStream
}

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

func (c *profileMgrClient) ProfileRollback(ctx context.Context, in *ProfileInfo, opts ...grpc.CallOption) (ProfileMgr_ProfileRollbackClient, error) {
	stream, err := grpc.NewClientStream(ctx, &_ProfileMgr_serviceDesc.Streams[8], c.cc, "/profile.ProfileMgr/ProfileRollback", opts...)
	if err != nil {
		return nil, err
	}
	x := &profileMgrProfileRollbackClient{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 ProfileMgr_ProfileRollbackClient interface {
	Recv() (*AckCheck, error)
	grpc.ClientStream
}

type profileMgrProfileRollbackClient struct {
	grpc.ClientStream
}

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

func (c *profileMgrClient) Charaterization(ctx context.Context, in *ProfileInfo, opts ...grpc.CallOption) (ProfileMgr_CharaterizationClient, error) {
	stream, err := grpc.NewClientStream(ctx, &_ProfileMgr_serviceDesc.Streams[9], c.cc, "/profile.ProfileMgr/Charaterization", opts...)
	if err != nil {
		return nil, err
	}
	x := &profileMgrCharaterizationClient{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 ProfileMgr_CharaterizationClient interface {
	Recv() (*AckCheck, error)
	grpc.ClientStream
}

type profileMgrCharaterizationClient struct {
	grpc.ClientStream
}

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

func (c *profileMgrClient) Collection(ctx context.Context, in *CollectFlag, opts ...grpc.CallOption) (ProfileMgr_CollectionClient, error) {
	stream, err := grpc.NewClientStream(ctx, &_ProfileMgr_serviceDesc.Streams[10], c.cc, "/profile.ProfileMgr/Collection", opts...)
	if err != nil {
		return nil, err
	}
	x := &profileMgrCollectionClient{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 ProfileMgr_CollectionClient interface {
	Recv() (*AckCheck, error)
	grpc.ClientStream
}

type profileMgrCollectionClient struct {
	grpc.ClientStream
}

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

func (c *profileMgrClient) Training(ctx context.Context, in *TrainMessage, opts ...grpc.CallOption) (ProfileMgr_TrainingClient, error) {
	stream, err := grpc.NewClientStream(ctx, &_ProfileMgr_serviceDesc.Streams[11], c.cc, "/profile.ProfileMgr/Training", opts...)
	if err != nil {
		return nil, err
	}
	x := &profileMgrTrainingClient{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 ProfileMgr_TrainingClient interface {
	Recv() (*AckCheck, error)
	grpc.ClientStream
}

type profileMgrTrainingClient struct {
	grpc.ClientStream
}

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

func (c *profileMgrClient) Define(ctx context.Context, in *DefineMessage, opts ...grpc.CallOption) (*Ack, error) {
	out := new(Ack)
	err := grpc.Invoke(ctx, "/profile.ProfileMgr/Define", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *profileMgrClient) Delete(ctx context.Context, in *DefineMessage, opts ...grpc.CallOption) (*Ack, error) {
	out := new(Ack)
	err := grpc.Invoke(ctx, "/profile.ProfileMgr/Delete", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *profileMgrClient) Update(ctx context.Context, in *DefineMessage, opts ...grpc.CallOption) (*Ack, error) {
	out := new(Ack)
	err := grpc.Invoke(ctx, "/profile.ProfileMgr/Update", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *profileMgrClient) Schedule(ctx context.Context, in *ScheduleMessage, opts ...grpc.CallOption) (ProfileMgr_ScheduleClient, error) {
	stream, err := grpc.NewClientStream(ctx, &_ProfileMgr_serviceDesc.Streams[12], c.cc, "/profile.ProfileMgr/Schedule", opts...)
	if err != nil {
		return nil, err
	}
	x := &profileMgrScheduleClient{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 ProfileMgr_ScheduleClient interface {
	Recv() (*AckCheck, error)
	grpc.ClientStream
}

type profileMgrScheduleClient struct {
	grpc.ClientStream
}

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

// Server API for ProfileMgr service

type ProfileMgrServer interface {
	Profile(*ProfileInfo, ProfileMgr_ProfileServer) error
	CheckInitProfile(*ProfileInfo, ProfileMgr_CheckInitProfileServer) error
	Analysis(*AnalysisMessage, ProfileMgr_AnalysisServer) error
	Tuning(*ProfileInfo, ProfileMgr_TuningServer) error
	ListWorkload(*ProfileInfo, ProfileMgr_ListWorkloadServer) error
	UpgradeProfile(*ProfileInfo, ProfileMgr_UpgradeProfileServer) error
	InfoProfile(*ProfileInfo, ProfileMgr_InfoProfileServer) error
	CheckActiveProfile(*ProfileInfo, ProfileMgr_CheckActiveProfileServer) error
	ProfileRollback(*ProfileInfo, ProfileMgr_ProfileRollbackServer) error
	Charaterization(*ProfileInfo, ProfileMgr_CharaterizationServer) error
	Collection(*CollectFlag, ProfileMgr_CollectionServer) error
	Training(*TrainMessage, ProfileMgr_TrainingServer) error
	Define(context.Context, *DefineMessage) (*Ack, error)
	Delete(context.Context, *DefineMessage) (*Ack, error)
	Update(context.Context, *DefineMessage) (*Ack, error)
	Schedule(*ScheduleMessage, ProfileMgr_ScheduleServer) error
}

func RegisterProfileMgrServer(s *grpc.Server, srv ProfileMgrServer) {
	s.RegisterService(&_ProfileMgr_serviceDesc, srv)
}

func _ProfileMgr_Profile_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ProfileInfo)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ProfileMgrServer).Profile(m, &profileMgrProfileServer{stream})
}

type ProfileMgr_ProfileServer interface {
	Send(*AckCheck) error
	grpc.ServerStream
}

type profileMgrProfileServer struct {
	grpc.ServerStream
}

func (x *profileMgrProfileServer) Send(m *AckCheck) error {
	return x.ServerStream.SendMsg(m)
}

func _ProfileMgr_CheckInitProfile_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ProfileInfo)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ProfileMgrServer).CheckInitProfile(m, &profileMgrCheckInitProfileServer{stream})
}

type ProfileMgr_CheckInitProfileServer interface {
	Send(*AckCheck) error
	grpc.ServerStream
}

type profileMgrCheckInitProfileServer struct {
	grpc.ServerStream
}

func (x *profileMgrCheckInitProfileServer) Send(m *AckCheck) error {
	return x.ServerStream.SendMsg(m)
}

func _ProfileMgr_Analysis_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(AnalysisMessage)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ProfileMgrServer).Analysis(m, &profileMgrAnalysisServer{stream})
}

type ProfileMgr_AnalysisServer interface {
	Send(*AckCheck) error
	grpc.ServerStream
}

type profileMgrAnalysisServer struct {
	grpc.ServerStream
}

func (x *profileMgrAnalysisServer) Send(m *AckCheck) error {
	return x.ServerStream.SendMsg(m)
}

func _ProfileMgr_Tuning_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ProfileInfo)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ProfileMgrServer).Tuning(m, &profileMgrTuningServer{stream})
}

type ProfileMgr_TuningServer interface {
	Send(*AckCheck) error
	grpc.ServerStream
}

type profileMgrTuningServer struct {
	grpc.ServerStream
}

func (x *profileMgrTuningServer) Send(m *AckCheck) error {
	return x.ServerStream.SendMsg(m)
}

func _ProfileMgr_ListWorkload_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ProfileInfo)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ProfileMgrServer).ListWorkload(m, &profileMgrListWorkloadServer{stream})
}

type ProfileMgr_ListWorkloadServer interface {
	Send(*ListMessage) error
	grpc.ServerStream
}

type profileMgrListWorkloadServer struct {
	grpc.ServerStream
}

func (x *profileMgrListWorkloadServer) Send(m *ListMessage) error {
	return x.ServerStream.SendMsg(m)
}

func _ProfileMgr_UpgradeProfile_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ProfileInfo)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ProfileMgrServer).UpgradeProfile(m, &profileMgrUpgradeProfileServer{stream})
}

type ProfileMgr_UpgradeProfileServer interface {
	Send(*AckCheck) error
	grpc.ServerStream
}

type profileMgrUpgradeProfileServer struct {
	grpc.ServerStream
}

func (x *profileMgrUpgradeProfileServer) Send(m *AckCheck) error {
	return x.ServerStream.SendMsg(m)
}

func _ProfileMgr_InfoProfile_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ProfileInfo)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ProfileMgrServer).InfoProfile(m, &profileMgrInfoProfileServer{stream})
}

type ProfileMgr_InfoProfileServer interface {
	Send(*ProfileInfo) error
	grpc.ServerStream
}

type profileMgrInfoProfileServer struct {
	grpc.ServerStream
}

func (x *profileMgrInfoProfileServer) Send(m *ProfileInfo) error {
	return x.ServerStream.SendMsg(m)
}

func _ProfileMgr_CheckActiveProfile_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ProfileInfo)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ProfileMgrServer).CheckActiveProfile(m, &profileMgrCheckActiveProfileServer{stream})
}

type ProfileMgr_CheckActiveProfileServer interface {
	Send(*AckCheck) error
	grpc.ServerStream
}

type profileMgrCheckActiveProfileServer struct {
	grpc.ServerStream
}

func (x *profileMgrCheckActiveProfileServer) Send(m *AckCheck) error {
	return x.ServerStream.SendMsg(m)
}

func _ProfileMgr_ProfileRollback_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ProfileInfo)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ProfileMgrServer).ProfileRollback(m, &profileMgrProfileRollbackServer{stream})
}

type ProfileMgr_ProfileRollbackServer interface {
	Send(*AckCheck) error
	grpc.ServerStream
}

type profileMgrProfileRollbackServer struct {
	grpc.ServerStream
}

func (x *profileMgrProfileRollbackServer) Send(m *AckCheck) error {
	return x.ServerStream.SendMsg(m)
}

func _ProfileMgr_Charaterization_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ProfileInfo)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ProfileMgrServer).Charaterization(m, &profileMgrCharaterizationServer{stream})
}

type ProfileMgr_CharaterizationServer interface {
	Send(*AckCheck) error
	grpc.ServerStream
}

type profileMgrCharaterizationServer struct {
	grpc.ServerStream
}

func (x *profileMgrCharaterizationServer) Send(m *AckCheck) error {
	return x.ServerStream.SendMsg(m)
}

func _ProfileMgr_Collection_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(CollectFlag)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ProfileMgrServer).Collection(m, &profileMgrCollectionServer{stream})
}

type ProfileMgr_CollectionServer interface {
	Send(*AckCheck) error
	grpc.ServerStream
}

type profileMgrCollectionServer struct {
	grpc.ServerStream
}

func (x *profileMgrCollectionServer) Send(m *AckCheck) error {
	return x.ServerStream.SendMsg(m)
}

func _ProfileMgr_Training_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(TrainMessage)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ProfileMgrServer).Training(m, &profileMgrTrainingServer{stream})
}

type ProfileMgr_TrainingServer interface {
	Send(*AckCheck) error
	grpc.ServerStream
}

type profileMgrTrainingServer struct {
	grpc.ServerStream
}

func (x *profileMgrTrainingServer) Send(m *AckCheck) error {
	return x.ServerStream.SendMsg(m)
}

func _ProfileMgr_Define_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DefineMessage)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ProfileMgrServer).Define(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/profile.ProfileMgr/Define",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ProfileMgrServer).Define(ctx, req.(*DefineMessage))
	}
	return interceptor(ctx, in, info, handler)
}

func _ProfileMgr_Delete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DefineMessage)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ProfileMgrServer).Delete(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/profile.ProfileMgr/Delete",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ProfileMgrServer).Delete(ctx, req.(*DefineMessage))
	}
	return interceptor(ctx, in, info, handler)
}

func _ProfileMgr_Update_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DefineMessage)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ProfileMgrServer).Update(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/profile.ProfileMgr/Update",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ProfileMgrServer).Update(ctx, req.(*DefineMessage))
	}
	return interceptor(ctx, in, info, handler)
}

func _ProfileMgr_Schedule_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ScheduleMessage)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ProfileMgrServer).Schedule(m, &profileMgrScheduleServer{stream})
}

type ProfileMgr_ScheduleServer interface {
	Send(*AckCheck) error
	grpc.ServerStream
}

type profileMgrScheduleServer struct {
	grpc.ServerStream
}

func (x *profileMgrScheduleServer) Send(m *AckCheck) error {
	return x.ServerStream.SendMsg(m)
}

var _ProfileMgr_serviceDesc = grpc.ServiceDesc{
	ServiceName: "profile.ProfileMgr",
	HandlerType: (*ProfileMgrServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Define",
			Handler:    _ProfileMgr_Define_Handler,
		},
		{
			MethodName: "Delete",
			Handler:    _ProfileMgr_Delete_Handler,
		},
		{
			MethodName: "Update",
			Handler:    _ProfileMgr_Update_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "Profile",
			Handler:       _ProfileMgr_Profile_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "CheckInitProfile",
			Handler:       _ProfileMgr_CheckInitProfile_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Analysis",
			Handler:       _ProfileMgr_Analysis_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Tuning",
			Handler:       _ProfileMgr_Tuning_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ListWorkload",
			Handler:       _ProfileMgr_ListWorkload_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "UpgradeProfile",
			Handler:       _ProfileMgr_UpgradeProfile_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "InfoProfile",
			Handler:       _ProfileMgr_InfoProfile_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "CheckActiveProfile",
			Handler:       _ProfileMgr_CheckActiveProfile_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ProfileRollback",
			Handler:       _ProfileMgr_ProfileRollback_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Charaterization",
			Handler:       _ProfileMgr_Charaterization_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Collection",
			Handler:       _ProfileMgr_Collection_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Training",
			Handler:       _ProfileMgr_Training_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Schedule",
			Handler:       _ProfileMgr_Schedule_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "profile.proto",
}

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

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