skizze.pb.go

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

/*
Package datamodel is a generated protocol buffer package.

It is generated from these files:
	skizze.proto

It has these top-level messages:
	Empty
	Defaults
	Domain
	Sketch
	Membership
	Frequency
	Rank
	CreateSnapshotRequest
	CreateSnapshotReply
	GetSnapshotRequest
	GetSnapshotReply
	ListRequest
	ListReply
	ListDomainsReply
	AddRequest
	AddReply
	GetRequest
	GetMembershipReply
	GetFrequencyReply
	GetCardinalityReply
	GetRankReply
*/
package datamodel

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

//
// Enums
//
type SketchType int32

const (
	SketchType_UNKNOWN SketchType = 0
	SketchType_MEMB    SketchType = 1
	SketchType_FREQ    SketchType = 2
	SketchType_RANK    SketchType = 3
	SketchType_CARD    SketchType = 4
)

var SketchType_name = map[int32]string{
	0: "UNKNOWN",
	1: "MEMB",
	2: "FREQ",
	3: "RANK",
	4: "CARD",
}
var SketchType_value = map[string]int32{
	"UNKNOWN": 0,
	"MEMB":    1,
	"FREQ":    2,
	"RANK":    3,
	"CARD":    4,
}

func (x SketchType) Enum() *SketchType {
	p := new(SketchType)
	*p = x
	return p
}
func (x SketchType) String() string {
	return proto.EnumName(SketchType_name, int32(x))
}
func (x *SketchType) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(SketchType_value, data, "SketchType")
	if err != nil {
		return err
	}
	*x = SketchType(value)
	return nil
}
func (SketchType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }

type DomainType int32

const (
	DomainType_STRING DomainType = 0
)

var DomainType_name = map[int32]string{
	0: "STRING",
}
var DomainType_value = map[string]int32{
	"STRING": 0,
}

func (x DomainType) Enum() *DomainType {
	p := new(DomainType)
	*p = x
	return p
}
func (x DomainType) String() string {
	return proto.EnumName(DomainType_name, int32(x))
}
func (x *DomainType) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(DomainType_value, data, "DomainType")
	if err != nil {
		return err
	}
	*x = DomainType(value)
	return nil
}
func (DomainType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }

type SnapshotStatus int32

const (
	SnapshotStatus_PENDING     SnapshotStatus = 0
	SnapshotStatus_IN_PROGRESS SnapshotStatus = 1
	SnapshotStatus_SUCCESSFUL  SnapshotStatus = 2
	SnapshotStatus_FAILED      SnapshotStatus = 3
)

var SnapshotStatus_name = map[int32]string{
	0: "PENDING",
	1: "IN_PROGRESS",
	2: "SUCCESSFUL",
	3: "FAILED",
}
var SnapshotStatus_value = map[string]int32{
	"PENDING":     0,
	"IN_PROGRESS": 1,
	"SUCCESSFUL":  2,
	"FAILED":      3,
}

func (x SnapshotStatus) Enum() *SnapshotStatus {
	p := new(SnapshotStatus)
	*p = x
	return p
}
func (x SnapshotStatus) String() string {
	return proto.EnumName(SnapshotStatus_name, int32(x))
}
func (x *SnapshotStatus) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(SnapshotStatus_value, data, "SnapshotStatus")
	if err != nil {
		return err
	}
	*x = SnapshotStatus(value)
	return nil
}
func (SnapshotStatus) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }

//
// Generic Structures
//
type Empty struct {
	XXX_unrecognized []byte `json:"-"`
}

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

type Defaults struct {
	Rank             *int64 `protobuf:"varint,1,req,name=rank" json:"rank,omitempty"`
	Capacity         *int64 `protobuf:"varint,2,req,name=capacity" json:"capacity,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

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

func (m *Defaults) GetRank() int64 {
	if m != nil && m.Rank != nil {
		return *m.Rank
	}
	return 0
}

func (m *Defaults) GetCapacity() int64 {
	if m != nil && m.Capacity != nil {
		return *m.Capacity
	}
	return 0
}

type Domain struct {
	Name             *string     `protobuf:"bytes,1,req,name=name" json:"name,omitempty"`
	Type             *DomainType `protobuf:"varint,2,req,name=type,enum=datamodel.DomainType" json:"type,omitempty"`
	Sketches         []*Sketch   `protobuf:"bytes,3,rep,name=sketches" json:"sketches,omitempty"`
	XXX_unrecognized []byte      `json:"-"`
}

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

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

func (m *Domain) GetType() DomainType {
	if m != nil && m.Type != nil {
		return *m.Type
	}
	return DomainType_STRING
}

func (m *Domain) GetSketches() []*Sketch {
	if m != nil {
		return m.Sketches
	}
	return nil
}

type Sketch struct {
	Name             *string     `protobuf:"bytes,1,req,name=name" json:"name,omitempty"`
	Type             *SketchType `protobuf:"varint,2,req,name=type,enum=datamodel.SketchType" json:"type,omitempty"`
	Defaults         *Defaults   `protobuf:"bytes,3,opt,name=defaults" json:"defaults,omitempty"`
	XXX_unrecognized []byte      `json:"-"`
}

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

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

func (m *Sketch) GetType() SketchType {
	if m != nil && m.Type != nil {
		return *m.Type
	}
	return SketchType_UNKNOWN
}

func (m *Sketch) GetDefaults() *Defaults {
	if m != nil {
		return m.Defaults
	}
	return nil
}

type Membership struct {
	Value            *string `protobuf:"bytes,1,req,name=value" json:"value,omitempty"`
	IsMember         *bool   `protobuf:"varint,2,req,name=isMember" json:"isMember,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

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

func (m *Membership) GetValue() string {
	if m != nil && m.Value != nil {
		return *m.Value
	}
	return ""
}

func (m *Membership) GetIsMember() bool {
	if m != nil && m.IsMember != nil {
		return *m.IsMember
	}
	return false
}

type Frequency struct {
	Value            *string `protobuf:"bytes,1,req,name=value" json:"value,omitempty"`
	Count            *int64  `protobuf:"varint,2,req,name=count" json:"count,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

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

func (m *Frequency) GetValue() string {
	if m != nil && m.Value != nil {
		return *m.Value
	}
	return ""
}

func (m *Frequency) GetCount() int64 {
	if m != nil && m.Count != nil {
		return *m.Count
	}
	return 0
}

type Rank struct {
	Value            *string `protobuf:"bytes,1,req,name=value" json:"value,omitempty"`
	Count            *int64  `protobuf:"varint,2,req,name=count" json:"count,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

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

func (m *Rank) GetValue() string {
	if m != nil && m.Value != nil {
		return *m.Value
	}
	return ""
}

func (m *Rank) GetCount() int64 {
	if m != nil && m.Count != nil {
		return *m.Count
	}
	return 0
}

// Right now empty but in the future can request specific snapshot location
// (e.g. S3 or disk) and snapshot options
type CreateSnapshotRequest struct {
	XXX_unrecognized []byte `json:"-"`
}

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

type CreateSnapshotReply struct {
	Status           *SnapshotStatus `protobuf:"varint,1,req,name=status,enum=datamodel.SnapshotStatus" json:"status,omitempty"`
	StatusMessage    *string         `protobuf:"bytes,2,opt,name=statusMessage" json:"statusMessage,omitempty"`
	XXX_unrecognized []byte          `json:"-"`
}

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

func (m *CreateSnapshotReply) GetStatus() SnapshotStatus {
	if m != nil && m.Status != nil {
		return *m.Status
	}
	return SnapshotStatus_PENDING
}

func (m *CreateSnapshotReply) GetStatusMessage() string {
	if m != nil && m.StatusMessage != nil {
		return *m.StatusMessage
	}
	return ""
}

// Empty for now, future can send in id of specific snapshot
type GetSnapshotRequest struct {
	XXX_unrecognized []byte `json:"-"`
}

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

type GetSnapshotReply struct {
	Status           *SnapshotStatus `protobuf:"varint,1,req,name=status,enum=datamodel.SnapshotStatus" json:"status,omitempty"`
	StatusMessage    *string         `protobuf:"bytes,2,opt,name=statusMessage" json:"statusMessage,omitempty"`
	Timestamp        *int64          `protobuf:"varint,3,opt,name=timestamp" json:"timestamp,omitempty"`
	XXX_unrecognized []byte          `json:"-"`
}

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

func (m *GetSnapshotReply) GetStatus() SnapshotStatus {
	if m != nil && m.Status != nil {
		return *m.Status
	}
	return SnapshotStatus_PENDING
}

func (m *GetSnapshotReply) GetStatusMessage() string {
	if m != nil && m.StatusMessage != nil {
		return *m.StatusMessage
	}
	return ""
}

func (m *GetSnapshotReply) GetTimestamp() int64 {
	if m != nil && m.Timestamp != nil {
		return *m.Timestamp
	}
	return 0
}

type ListRequest struct {
	Type             *SketchType `protobuf:"varint,1,req,name=type,enum=datamodel.SketchType" json:"type,omitempty"`
	XXX_unrecognized []byte      `json:"-"`
}

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

func (m *ListRequest) GetType() SketchType {
	if m != nil && m.Type != nil {
		return *m.Type
	}
	return SketchType_UNKNOWN
}

type ListReply struct {
	Sketches         []*Sketch `protobuf:"bytes,1,rep,name=sketches" json:"sketches,omitempty"`
	XXX_unrecognized []byte    `json:"-"`
}

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

func (m *ListReply) GetSketches() []*Sketch {
	if m != nil {
		return m.Sketches
	}
	return nil
}

type ListDomainsReply struct {
	Name             []string `protobuf:"bytes,1,rep,name=name" json:"name,omitempty"`
	XXX_unrecognized []byte   `json:"-"`
}

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

func (m *ListDomainsReply) GetName() []string {
	if m != nil {
		return m.Name
	}
	return nil
}

type AddRequest struct {
	Domain           *Domain  `protobuf:"bytes,1,opt,name=domain" json:"domain,omitempty"`
	Sketch           *Sketch  `protobuf:"bytes,2,opt,name=sketch" json:"sketch,omitempty"`
	Values           []string `protobuf:"bytes,3,rep,name=values" json:"values,omitempty"`
	XXX_unrecognized []byte   `json:"-"`
}

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

func (m *AddRequest) GetDomain() *Domain {
	if m != nil {
		return m.Domain
	}
	return nil
}

func (m *AddRequest) GetSketch() *Sketch {
	if m != nil {
		return m.Sketch
	}
	return nil
}

func (m *AddRequest) GetValues() []string {
	if m != nil {
		return m.Values
	}
	return nil
}

type AddReply struct {
	XXX_unrecognized []byte `json:"-"`
}

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

type GetRequest struct {
	Sketch           *Sketch  `protobuf:"bytes,1,req,name=sketch" json:"sketch,omitempty"`
	Values           []string `protobuf:"bytes,2,rep,name=values" json:"values,omitempty"`
	XXX_unrecognized []byte   `json:"-"`
}

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

func (m *GetRequest) GetSketch() *Sketch {
	if m != nil {
		return m.Sketch
	}
	return nil
}

func (m *GetRequest) GetValues() []string {
	if m != nil {
		return m.Values
	}
	return nil
}

type GetMembershipReply struct {
	Memberships      []*Membership `protobuf:"bytes,1,rep,name=memberships" json:"memberships,omitempty"`
	XXX_unrecognized []byte        `json:"-"`
}

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

func (m *GetMembershipReply) GetMemberships() []*Membership {
	if m != nil {
		return m.Memberships
	}
	return nil
}

type GetFrequencyReply struct {
	Frequencies      []*Frequency `protobuf:"bytes,2,rep,name=frequencies" json:"frequencies,omitempty"`
	XXX_unrecognized []byte       `json:"-"`
}

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

func (m *GetFrequencyReply) GetFrequencies() []*Frequency {
	if m != nil {
		return m.Frequencies
	}
	return nil
}

type GetCardinalityReply struct {
	Cardinality      *int64 `protobuf:"varint,1,req,name=cardinality" json:"cardinality,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

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

func (m *GetCardinalityReply) GetCardinality() int64 {
	if m != nil && m.Cardinality != nil {
		return *m.Cardinality
	}
	return 0
}

type GetRankReply struct {
	Ranks            []*Rank `protobuf:"bytes,1,rep,name=ranks" json:"ranks,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

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

func (m *GetRankReply) GetRanks() []*Rank {
	if m != nil {
		return m.Ranks
	}
	return nil
}

func init() {
	proto.RegisterType((*Empty)(nil), "datamodel.Empty")
	proto.RegisterType((*Defaults)(nil), "datamodel.Defaults")
	proto.RegisterType((*Domain)(nil), "datamodel.Domain")
	proto.RegisterType((*Sketch)(nil), "datamodel.Sketch")
	proto.RegisterType((*Membership)(nil), "datamodel.Membership")
	proto.RegisterType((*Frequency)(nil), "datamodel.Frequency")
	proto.RegisterType((*Rank)(nil), "datamodel.Rank")
	proto.RegisterType((*CreateSnapshotRequest)(nil), "datamodel.CreateSnapshotRequest")
	proto.RegisterType((*CreateSnapshotReply)(nil), "datamodel.CreateSnapshotReply")
	proto.RegisterType((*GetSnapshotRequest)(nil), "datamodel.GetSnapshotRequest")
	proto.RegisterType((*GetSnapshotReply)(nil), "datamodel.GetSnapshotReply")
	proto.RegisterType((*ListRequest)(nil), "datamodel.ListRequest")
	proto.RegisterType((*ListReply)(nil), "datamodel.ListReply")
	proto.RegisterType((*ListDomainsReply)(nil), "datamodel.ListDomainsReply")
	proto.RegisterType((*AddRequest)(nil), "datamodel.AddRequest")
	proto.RegisterType((*AddReply)(nil), "datamodel.AddReply")
	proto.RegisterType((*GetRequest)(nil), "datamodel.GetRequest")
	proto.RegisterType((*GetMembershipReply)(nil), "datamodel.GetMembershipReply")
	proto.RegisterType((*GetFrequencyReply)(nil), "datamodel.GetFrequencyReply")
	proto.RegisterType((*GetCardinalityReply)(nil), "datamodel.GetCardinalityReply")
	proto.RegisterType((*GetRankReply)(nil), "datamodel.GetRankReply")
	proto.RegisterEnum("datamodel.SketchType", SketchType_name, SketchType_value)
	proto.RegisterEnum("datamodel.DomainType", DomainType_name, DomainType_value)
	proto.RegisterEnum("datamodel.SnapshotStatus", SnapshotStatus_name, SnapshotStatus_value)
}

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

// Client API for Skizze service

type SkizzeClient interface {
	CreateSnapshot(ctx context.Context, in *CreateSnapshotRequest, opts ...grpc.CallOption) (*CreateSnapshotReply, error)
	GetSnapshot(ctx context.Context, in *GetSnapshotRequest, opts ...grpc.CallOption) (*GetSnapshotReply, error)
	List(ctx context.Context, in *ListRequest, opts ...grpc.CallOption) (*ListReply, error)
	ListAll(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*ListReply, error)
	ListDomains(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*ListDomainsReply, error)
	SetDefaults(ctx context.Context, in *Defaults, opts ...grpc.CallOption) (*Defaults, error)
	GetDefaults(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*Defaults, error)
	CreateDomain(ctx context.Context, in *Domain, opts ...grpc.CallOption) (*Domain, error)
	DeleteDomain(ctx context.Context, in *Domain, opts ...grpc.CallOption) (*Empty, error)
	GetDomain(ctx context.Context, in *Domain, opts ...grpc.CallOption) (*Domain, error)
	CreateSketch(ctx context.Context, in *Sketch, opts ...grpc.CallOption) (*Sketch, error)
	DeleteSketch(ctx context.Context, in *Sketch, opts ...grpc.CallOption) (*Empty, error)
	GetSketch(ctx context.Context, in *Sketch, opts ...grpc.CallOption) (*Sketch, error)
	Add(ctx context.Context, in *AddRequest, opts ...grpc.CallOption) (*AddReply, error)
	GetMembership(ctx context.Context, in *GetRequest, opts ...grpc.CallOption) (*GetMembershipReply, error)
	GetFrequency(ctx context.Context, in *GetRequest, opts ...grpc.CallOption) (*GetFrequencyReply, error)
	GetCardinality(ctx context.Context, in *GetRequest, opts ...grpc.CallOption) (*GetCardinalityReply, error)
	GetRank(ctx context.Context, in *GetRequest, opts ...grpc.CallOption) (*GetRankReply, error)
}

type skizzeClient struct {
	cc *grpc.ClientConn
}

func NewSkizzeClient(cc *grpc.ClientConn) SkizzeClient {
	return &skizzeClient{cc}
}

func (c *skizzeClient) CreateSnapshot(ctx context.Context, in *CreateSnapshotRequest, opts ...grpc.CallOption) (*CreateSnapshotReply, error) {
	out := new(CreateSnapshotReply)
	err := grpc.Invoke(ctx, "/datamodel.Skizze/CreateSnapshot", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *skizzeClient) GetSnapshot(ctx context.Context, in *GetSnapshotRequest, opts ...grpc.CallOption) (*GetSnapshotReply, error) {
	out := new(GetSnapshotReply)
	err := grpc.Invoke(ctx, "/datamodel.Skizze/GetSnapshot", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *skizzeClient) List(ctx context.Context, in *ListRequest, opts ...grpc.CallOption) (*ListReply, error) {
	out := new(ListReply)
	err := grpc.Invoke(ctx, "/datamodel.Skizze/List", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *skizzeClient) ListAll(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*ListReply, error) {
	out := new(ListReply)
	err := grpc.Invoke(ctx, "/datamodel.Skizze/ListAll", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *skizzeClient) ListDomains(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*ListDomainsReply, error) {
	out := new(ListDomainsReply)
	err := grpc.Invoke(ctx, "/datamodel.Skizze/ListDomains", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *skizzeClient) SetDefaults(ctx context.Context, in *Defaults, opts ...grpc.CallOption) (*Defaults, error) {
	out := new(Defaults)
	err := grpc.Invoke(ctx, "/datamodel.Skizze/SetDefaults", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *skizzeClient) GetDefaults(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*Defaults, error) {
	out := new(Defaults)
	err := grpc.Invoke(ctx, "/datamodel.Skizze/GetDefaults", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *skizzeClient) CreateDomain(ctx context.Context, in *Domain, opts ...grpc.CallOption) (*Domain, error) {
	out := new(Domain)
	err := grpc.Invoke(ctx, "/datamodel.Skizze/CreateDomain", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *skizzeClient) DeleteDomain(ctx context.Context, in *Domain, opts ...grpc.CallOption) (*Empty, error) {
	out := new(Empty)
	err := grpc.Invoke(ctx, "/datamodel.Skizze/DeleteDomain", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *skizzeClient) GetDomain(ctx context.Context, in *Domain, opts ...grpc.CallOption) (*Domain, error) {
	out := new(Domain)
	err := grpc.Invoke(ctx, "/datamodel.Skizze/GetDomain", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *skizzeClient) CreateSketch(ctx context.Context, in *Sketch, opts ...grpc.CallOption) (*Sketch, error) {
	out := new(Sketch)
	err := grpc.Invoke(ctx, "/datamodel.Skizze/CreateSketch", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *skizzeClient) DeleteSketch(ctx context.Context, in *Sketch, opts ...grpc.CallOption) (*Empty, error) {
	out := new(Empty)
	err := grpc.Invoke(ctx, "/datamodel.Skizze/DeleteSketch", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *skizzeClient) GetSketch(ctx context.Context, in *Sketch, opts ...grpc.CallOption) (*Sketch, error) {
	out := new(Sketch)
	err := grpc.Invoke(ctx, "/datamodel.Skizze/GetSketch", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *skizzeClient) Add(ctx context.Context, in *AddRequest, opts ...grpc.CallOption) (*AddReply, error) {
	out := new(AddReply)
	err := grpc.Invoke(ctx, "/datamodel.Skizze/Add", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *skizzeClient) GetMembership(ctx context.Context, in *GetRequest, opts ...grpc.CallOption) (*GetMembershipReply, error) {
	out := new(GetMembershipReply)
	err := grpc.Invoke(ctx, "/datamodel.Skizze/GetMembership", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *skizzeClient) GetFrequency(ctx context.Context, in *GetRequest, opts ...grpc.CallOption) (*GetFrequencyReply, error) {
	out := new(GetFrequencyReply)
	err := grpc.Invoke(ctx, "/datamodel.Skizze/GetFrequency", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *skizzeClient) GetCardinality(ctx context.Context, in *GetRequest, opts ...grpc.CallOption) (*GetCardinalityReply, error) {
	out := new(GetCardinalityReply)
	err := grpc.Invoke(ctx, "/datamodel.Skizze/GetCardinality", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *skizzeClient) GetRank(ctx context.Context, in *GetRequest, opts ...grpc.CallOption) (*GetRankReply, error) {
	out := new(GetRankReply)
	err := grpc.Invoke(ctx, "/datamodel.Skizze/GetRank", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// Server API for Skizze service

type SkizzeServer interface {
	CreateSnapshot(context.Context, *CreateSnapshotRequest) (*CreateSnapshotReply, error)
	GetSnapshot(context.Context, *GetSnapshotRequest) (*GetSnapshotReply, error)
	List(context.Context, *ListRequest) (*ListReply, error)
	ListAll(context.Context, *Empty) (*ListReply, error)
	ListDomains(context.Context, *Empty) (*ListDomainsReply, error)
	SetDefaults(context.Context, *Defaults) (*Defaults, error)
	GetDefaults(context.Context, *Empty) (*Defaults, error)
	CreateDomain(context.Context, *Domain) (*Domain, error)
	DeleteDomain(context.Context, *Domain) (*Empty, error)
	GetDomain(context.Context, *Domain) (*Domain, error)
	CreateSketch(context.Context, *Sketch) (*Sketch, error)
	DeleteSketch(context.Context, *Sketch) (*Empty, error)
	GetSketch(context.Context, *Sketch) (*Sketch, error)
	Add(context.Context, *AddRequest) (*AddReply, error)
	GetMembership(context.Context, *GetRequest) (*GetMembershipReply, error)
	GetFrequency(context.Context, *GetRequest) (*GetFrequencyReply, error)
	GetCardinality(context.Context, *GetRequest) (*GetCardinalityReply, error)
	GetRank(context.Context, *GetRequest) (*GetRankReply, error)
}

func RegisterSkizzeServer(s *grpc.Server, srv SkizzeServer) {
	s.RegisterService(&_Skizze_serviceDesc, srv)
}

func _Skizze_CreateSnapshot_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) {
	in := new(CreateSnapshotRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	out, err := srv.(SkizzeServer).CreateSnapshot(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func _Skizze_GetSnapshot_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) {
	in := new(GetSnapshotRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	out, err := srv.(SkizzeServer).GetSnapshot(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func _Skizze_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) {
	in := new(ListRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	out, err := srv.(SkizzeServer).List(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func _Skizze_ListAll_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) {
	in := new(Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	out, err := srv.(SkizzeServer).ListAll(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func _Skizze_ListDomains_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) {
	in := new(Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	out, err := srv.(SkizzeServer).ListDomains(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func _Skizze_SetDefaults_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) {
	in := new(Defaults)
	if err := dec(in); err != nil {
		return nil, err
	}
	out, err := srv.(SkizzeServer).SetDefaults(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func _Skizze_GetDefaults_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) {
	in := new(Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	out, err := srv.(SkizzeServer).GetDefaults(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func _Skizze_CreateDomain_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) {
	in := new(Domain)
	if err := dec(in); err != nil {
		return nil, err
	}
	out, err := srv.(SkizzeServer).CreateDomain(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func _Skizze_DeleteDomain_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) {
	in := new(Domain)
	if err := dec(in); err != nil {
		return nil, err
	}
	out, err := srv.(SkizzeServer).DeleteDomain(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func _Skizze_GetDomain_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) {
	in := new(Domain)
	if err := dec(in); err != nil {
		return nil, err
	}
	out, err := srv.(SkizzeServer).GetDomain(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func _Skizze_CreateSketch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) {
	in := new(Sketch)
	if err := dec(in); err != nil {
		return nil, err
	}
	out, err := srv.(SkizzeServer).CreateSketch(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func _Skizze_DeleteSketch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) {
	in := new(Sketch)
	if err := dec(in); err != nil {
		return nil, err
	}
	out, err := srv.(SkizzeServer).DeleteSketch(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func _Skizze_GetSketch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) {
	in := new(Sketch)
	if err := dec(in); err != nil {
		return nil, err
	}
	out, err := srv.(SkizzeServer).GetSketch(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func _Skizze_Add_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) {
	in := new(AddRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	out, err := srv.(SkizzeServer).Add(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func _Skizze_GetMembership_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) {
	in := new(GetRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	out, err := srv.(SkizzeServer).GetMembership(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func _Skizze_GetFrequency_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) {
	in := new(GetRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	out, err := srv.(SkizzeServer).GetFrequency(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func _Skizze_GetCardinality_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) {
	in := new(GetRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	out, err := srv.(SkizzeServer).GetCardinality(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func _Skizze_GetRank_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) {
	in := new(GetRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	out, err := srv.(SkizzeServer).GetRank(ctx, in)
	if err != nil {
		return nil, err
	}
	return out, nil
}

var _Skizze_serviceDesc = grpc.ServiceDesc{
	ServiceName: "datamodel.Skizze",
	HandlerType: (*SkizzeServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CreateSnapshot",
			Handler:    _Skizze_CreateSnapshot_Handler,
		},
		{
			MethodName: "GetSnapshot",
			Handler:    _Skizze_GetSnapshot_Handler,
		},
		{
			MethodName: "List",
			Handler:    _Skizze_List_Handler,
		},
		{
			MethodName: "ListAll",
			Handler:    _Skizze_ListAll_Handler,
		},
		{
			MethodName: "ListDomains",
			Handler:    _Skizze_ListDomains_Handler,
		},
		{
			MethodName: "SetDefaults",
			Handler:    _Skizze_SetDefaults_Handler,
		},
		{
			MethodName: "GetDefaults",
			Handler:    _Skizze_GetDefaults_Handler,
		},
		{
			MethodName: "CreateDomain",
			Handler:    _Skizze_CreateDomain_Handler,
		},
		{
			MethodName: "DeleteDomain",
			Handler:    _Skizze_DeleteDomain_Handler,
		},
		{
			MethodName: "GetDomain",
			Handler:    _Skizze_GetDomain_Handler,
		},
		{
			MethodName: "CreateSketch",
			Handler:    _Skizze_CreateSketch_Handler,
		},
		{
			MethodName: "DeleteSketch",
			Handler:    _Skizze_DeleteSketch_Handler,
		},
		{
			MethodName: "GetSketch",
			Handler:    _Skizze_GetSketch_Handler,
		},
		{
			MethodName: "Add",
			Handler:    _Skizze_Add_Handler,
		},
		{
			MethodName: "GetMembership",
			Handler:    _Skizze_GetMembership_Handler,
		},
		{
			MethodName: "GetFrequency",
			Handler:    _Skizze_GetFrequency_Handler,
		},
		{
			MethodName: "GetCardinality",
			Handler:    _Skizze_GetCardinality_Handler,
		},
		{
			MethodName: "GetRank",
			Handler:    _Skizze_GetRank_Handler,
		},
	},
	Streams: []grpc.StreamDesc{},
}

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