demo_service.pb.go

// Code generated by protoc-gen-go. DO NOT EDIT.
// source: example/feature_demo/demo_service.proto

package example

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import google_protobuf2 "github.com/golang/protobuf/ptypes/empty"
import _ "github.com/infobloxopen/protoc-gen-gorm/options"
import google_protobuf4 "google.golang.org/genproto/protobuf/field_mask"
import infoblox_api "github.com/infobloxopen/atlas-app-toolkit/query"

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

// IntPoint is a basic message type representing a single cartesian point
// that we want to store in a database
type IntPoint struct {
	Id uint32 `protobuf:"varint,1,opt,name=id" json:"id,omitempty"`
	X  int32  `protobuf:"varint,2,opt,name=x" json:"x,omitempty"`
	Y  int32  `protobuf:"varint,3,opt,name=y" json:"y,omitempty"`
}

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

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

func (m *IntPoint) GetX() int32 {
	if m != nil {
		return m.X
	}
	return 0
}

func (m *IntPoint) GetY() int32 {
	if m != nil {
		return m.Y
	}
	return 0
}

type CreateIntPointRequest struct {
	// Convention dictates that this field be of the given type, and be
	// named 'payload' in order to autogenerate the handler
	Payload *IntPoint `protobuf:"bytes,1,opt,name=payload" json:"payload,omitempty"`
}

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

func (m *CreateIntPointRequest) GetPayload() *IntPoint {
	if m != nil {
		return m.Payload
	}
	return nil
}

type CreateIntPointResponse struct {
	// Convention also requires that the return type be the same and named 'result'
	Result *IntPoint `protobuf:"bytes,1,opt,name=result" json:"result,omitempty"`
}

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

func (m *CreateIntPointResponse) GetResult() *IntPoint {
	if m != nil {
		return m.Result
	}
	return nil
}

type ReadIntPointRequest struct {
	// For a read request, the id field is the only to be specified
	Id     uint32                       `protobuf:"varint,1,opt,name=id" json:"id,omitempty"`
	Fields *infoblox_api.FieldSelection `protobuf:"bytes,2,opt,name=fields" json:"fields,omitempty"`
}

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

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

func (m *ReadIntPointRequest) GetFields() *infoblox_api.FieldSelection {
	if m != nil {
		return m.Fields
	}
	return nil
}

type ReadIntPointResponse struct {
	// Again the type with 'result' name
	Result *IntPoint `protobuf:"bytes,1,opt,name=result" json:"result,omitempty"`
}

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

func (m *ReadIntPointResponse) GetResult() *IntPoint {
	if m != nil {
		return m.Result
	}
	return nil
}

type UpdateIntPointRequest struct {
	Payload        *IntPoint                   `protobuf:"bytes,1,opt,name=payload" json:"payload,omitempty"`
	GerogeriGegege *google_protobuf4.FieldMask `protobuf:"bytes,2,opt,name=gerogeri_gegege,json=gerogeriGegege" json:"gerogeri_gegege,omitempty"`
}

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

func (m *UpdateIntPointRequest) GetPayload() *IntPoint {
	if m != nil {
		return m.Payload
	}
	return nil
}

func (m *UpdateIntPointRequest) GetGerogeriGegege() *google_protobuf4.FieldMask {
	if m != nil {
		return m.GerogeriGegege
	}
	return nil
}

type UpdateIntPointResponse struct {
	Result *IntPoint `protobuf:"bytes,1,opt,name=result" json:"result,omitempty"`
}

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

func (m *UpdateIntPointResponse) GetResult() *IntPoint {
	if m != nil {
		return m.Result
	}
	return nil
}

type DeleteIntPointRequest struct {
	// Only the id is needed for a delete request
	Id uint32 `protobuf:"varint,1,opt,name=id" json:"id,omitempty"`
}

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

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

type DeleteIntPointsRequest struct {
	// Only the id is needed for a delete request
	Ids []uint32 `protobuf:"varint,1,rep,packed,name=ids" json:"ids,omitempty"`
}

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

func (m *DeleteIntPointsRequest) GetIds() []uint32 {
	if m != nil {
		return m.Ids
	}
	return nil
}

// By convention, on DELETE no response data is given, so either a
// google.protobuf.empty, or an empty struct is sufficient
type DeleteIntPointResponse struct {
}

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

type ListIntPointResponse struct {
	// Note repeated field and plural name 'results'
	Results  []*IntPoint            `protobuf:"bytes,1,rep,name=results" json:"results,omitempty"`
	PageInfo *infoblox_api.PageInfo `protobuf:"bytes,2,opt,name=page_info,json=pageInfo" json:"page_info,omitempty"`
}

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

func (m *ListIntPointResponse) GetResults() []*IntPoint {
	if m != nil {
		return m.Results
	}
	return nil
}

func (m *ListIntPointResponse) GetPageInfo() *infoblox_api.PageInfo {
	if m != nil {
		return m.PageInfo
	}
	return nil
}

type ListSomethingResponse struct {
	// Note repeated field and plural name 'results'
	Results  []*Something           `protobuf:"bytes,1,rep,name=results" json:"results,omitempty"`
	PageInfo *infoblox_api.PageInfo `protobuf:"bytes,2,opt,name=page_info,json=pageInfo" json:"page_info,omitempty"`
}

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

func (m *ListSomethingResponse) GetResults() []*Something {
	if m != nil {
		return m.Results
	}
	return nil
}

func (m *ListSomethingResponse) GetPageInfo() *infoblox_api.PageInfo {
	if m != nil {
		return m.PageInfo
	}
	return nil
}

// A dummy type to demo an rpc that can't be autogenerated
type Something struct {
	Field string `protobuf:"bytes,1,opt,name=field" json:"field,omitempty"`
}

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

func (m *Something) GetField() string {
	if m != nil {
		return m.Field
	}
	return ""
}

type ListIntPointRequest struct {
	Filter  *infoblox_api.Filtering      `protobuf:"bytes,1,opt,name=filter" json:"filter,omitempty"`
	OrderBy *infoblox_api.Sorting        `protobuf:"bytes,2,opt,name=order_by,json=orderBy" json:"order_by,omitempty"`
	Fields  *infoblox_api.FieldSelection `protobuf:"bytes,3,opt,name=fields" json:"fields,omitempty"`
	Paging  *infoblox_api.Pagination     `protobuf:"bytes,4,opt,name=paging" json:"paging,omitempty"`
}

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

func (m *ListIntPointRequest) GetFilter() *infoblox_api.Filtering {
	if m != nil {
		return m.Filter
	}
	return nil
}

func (m *ListIntPointRequest) GetOrderBy() *infoblox_api.Sorting {
	if m != nil {
		return m.OrderBy
	}
	return nil
}

func (m *ListIntPointRequest) GetFields() *infoblox_api.FieldSelection {
	if m != nil {
		return m.Fields
	}
	return nil
}

func (m *ListIntPointRequest) GetPaging() *infoblox_api.Pagination {
	if m != nil {
		return m.Paging
	}
	return nil
}

type Circle struct {
	R uint32 `protobuf:"varint,1,opt,name=r" json:"r,omitempty"`
}

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

func (m *Circle) GetR() uint32 {
	if m != nil {
		return m.R
	}
	return 0
}

type ListCircleRequest struct {
}

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

type ListCircleResponse struct {
	Results []*Circle `protobuf:"bytes,1,rep,name=results" json:"results,omitempty"`
}

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

func (m *ListCircleResponse) GetResults() []*Circle {
	if m != nil {
		return m.Results
	}
	return nil
}

func init() {
	proto.RegisterType((*IntPoint)(nil), "example.IntPoint")
	proto.RegisterType((*CreateIntPointRequest)(nil), "example.CreateIntPointRequest")
	proto.RegisterType((*CreateIntPointResponse)(nil), "example.CreateIntPointResponse")
	proto.RegisterType((*ReadIntPointRequest)(nil), "example.ReadIntPointRequest")
	proto.RegisterType((*ReadIntPointResponse)(nil), "example.ReadIntPointResponse")
	proto.RegisterType((*UpdateIntPointRequest)(nil), "example.UpdateIntPointRequest")
	proto.RegisterType((*UpdateIntPointResponse)(nil), "example.UpdateIntPointResponse")
	proto.RegisterType((*DeleteIntPointRequest)(nil), "example.DeleteIntPointRequest")
	proto.RegisterType((*DeleteIntPointsRequest)(nil), "example.DeleteIntPointsRequest")
	proto.RegisterType((*DeleteIntPointResponse)(nil), "example.DeleteIntPointResponse")
	proto.RegisterType((*ListIntPointResponse)(nil), "example.ListIntPointResponse")
	proto.RegisterType((*ListSomethingResponse)(nil), "example.ListSomethingResponse")
	proto.RegisterType((*Something)(nil), "example.Something")
	proto.RegisterType((*ListIntPointRequest)(nil), "example.ListIntPointRequest")
	proto.RegisterType((*Circle)(nil), "example.Circle")
	proto.RegisterType((*ListCircleRequest)(nil), "example.ListCircleRequest")
	proto.RegisterType((*ListCircleResponse)(nil), "example.ListCircleResponse")
}

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

type IntPointServiceClient interface {
	// The convention requires the rpc names have Create/Read/Update/List/Delete
	// as a prefix. The type is inferred from the response (except for delete),
	// so multiple objects can have CURDL handlers in the same service, provided
	// they are given unique suffixes
	Create(ctx context.Context, in *CreateIntPointRequest, opts ...grpc.CallOption) (*CreateIntPointResponse, error)
	Read(ctx context.Context, in *ReadIntPointRequest, opts ...grpc.CallOption) (*ReadIntPointResponse, error)
	Update(ctx context.Context, in *UpdateIntPointRequest, opts ...grpc.CallOption) (*UpdateIntPointResponse, error)
	List(ctx context.Context, in *ListIntPointRequest, opts ...grpc.CallOption) (*ListIntPointResponse, error)
	ListSomething(ctx context.Context, in *google_protobuf2.Empty, opts ...grpc.CallOption) (*ListSomethingResponse, error)
	Delete(ctx context.Context, in *DeleteIntPointRequest, opts ...grpc.CallOption) (*DeleteIntPointResponse, error)
	// CustomMethod can't be autogenerated as it matches no conventions, it will
	// become a stub
	CustomMethod(ctx context.Context, in *google_protobuf2.Empty, opts ...grpc.CallOption) (*google_protobuf2.Empty, error)
	// CreateSomething also doesn't match conventions and will become a stub
	CreateSomething(ctx context.Context, in *Something, opts ...grpc.CallOption) (*Something, error)
}

type intPointServiceClient struct {
	cc *grpc.ClientConn
}

func NewIntPointServiceClient(cc *grpc.ClientConn) IntPointServiceClient {
	return &intPointServiceClient{cc}
}

func (c *intPointServiceClient) Create(ctx context.Context, in *CreateIntPointRequest, opts ...grpc.CallOption) (*CreateIntPointResponse, error) {
	out := new(CreateIntPointResponse)
	err := grpc.Invoke(ctx, "/example.IntPointService/Create", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *intPointServiceClient) Read(ctx context.Context, in *ReadIntPointRequest, opts ...grpc.CallOption) (*ReadIntPointResponse, error) {
	out := new(ReadIntPointResponse)
	err := grpc.Invoke(ctx, "/example.IntPointService/Read", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *intPointServiceClient) Update(ctx context.Context, in *UpdateIntPointRequest, opts ...grpc.CallOption) (*UpdateIntPointResponse, error) {
	out := new(UpdateIntPointResponse)
	err := grpc.Invoke(ctx, "/example.IntPointService/Update", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *intPointServiceClient) List(ctx context.Context, in *ListIntPointRequest, opts ...grpc.CallOption) (*ListIntPointResponse, error) {
	out := new(ListIntPointResponse)
	err := grpc.Invoke(ctx, "/example.IntPointService/List", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *intPointServiceClient) ListSomething(ctx context.Context, in *google_protobuf2.Empty, opts ...grpc.CallOption) (*ListSomethingResponse, error) {
	out := new(ListSomethingResponse)
	err := grpc.Invoke(ctx, "/example.IntPointService/ListSomething", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *intPointServiceClient) Delete(ctx context.Context, in *DeleteIntPointRequest, opts ...grpc.CallOption) (*DeleteIntPointResponse, error) {
	out := new(DeleteIntPointResponse)
	err := grpc.Invoke(ctx, "/example.IntPointService/Delete", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *intPointServiceClient) CustomMethod(ctx context.Context, in *google_protobuf2.Empty, opts ...grpc.CallOption) (*google_protobuf2.Empty, error) {
	out := new(google_protobuf2.Empty)
	err := grpc.Invoke(ctx, "/example.IntPointService/CustomMethod", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *intPointServiceClient) CreateSomething(ctx context.Context, in *Something, opts ...grpc.CallOption) (*Something, error) {
	out := new(Something)
	err := grpc.Invoke(ctx, "/example.IntPointService/CreateSomething", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// Server API for IntPointService service

type IntPointServiceServer interface {
	// The convention requires the rpc names have Create/Read/Update/List/Delete
	// as a prefix. The type is inferred from the response (except for delete),
	// so multiple objects can have CURDL handlers in the same service, provided
	// they are given unique suffixes
	Create(context.Context, *CreateIntPointRequest) (*CreateIntPointResponse, error)
	Read(context.Context, *ReadIntPointRequest) (*ReadIntPointResponse, error)
	Update(context.Context, *UpdateIntPointRequest) (*UpdateIntPointResponse, error)
	List(context.Context, *ListIntPointRequest) (*ListIntPointResponse, error)
	ListSomething(context.Context, *google_protobuf2.Empty) (*ListSomethingResponse, error)
	Delete(context.Context, *DeleteIntPointRequest) (*DeleteIntPointResponse, error)
	// CustomMethod can't be autogenerated as it matches no conventions, it will
	// become a stub
	CustomMethod(context.Context, *google_protobuf2.Empty) (*google_protobuf2.Empty, error)
	// CreateSomething also doesn't match conventions and will become a stub
	CreateSomething(context.Context, *Something) (*Something, error)
}

func RegisterIntPointServiceServer(s *grpc.Server, srv IntPointServiceServer) {
	s.RegisterService(&_IntPointService_serviceDesc, srv)
}

func _IntPointService_Create_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateIntPointRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(IntPointServiceServer).Create(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/example.IntPointService/Create",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(IntPointServiceServer).Create(ctx, req.(*CreateIntPointRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _IntPointService_Read_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReadIntPointRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(IntPointServiceServer).Read(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/example.IntPointService/Read",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(IntPointServiceServer).Read(ctx, req.(*ReadIntPointRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _IntPointService_Update_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateIntPointRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(IntPointServiceServer).Update(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/example.IntPointService/Update",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(IntPointServiceServer).Update(ctx, req.(*UpdateIntPointRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _IntPointService_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListIntPointRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(IntPointServiceServer).List(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/example.IntPointService/List",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(IntPointServiceServer).List(ctx, req.(*ListIntPointRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _IntPointService_ListSomething_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(google_protobuf2.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(IntPointServiceServer).ListSomething(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/example.IntPointService/ListSomething",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(IntPointServiceServer).ListSomething(ctx, req.(*google_protobuf2.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _IntPointService_Delete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteIntPointRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(IntPointServiceServer).Delete(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/example.IntPointService/Delete",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(IntPointServiceServer).Delete(ctx, req.(*DeleteIntPointRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _IntPointService_CustomMethod_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(google_protobuf2.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(IntPointServiceServer).CustomMethod(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/example.IntPointService/CustomMethod",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(IntPointServiceServer).CustomMethod(ctx, req.(*google_protobuf2.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _IntPointService_CreateSomething_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Something)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(IntPointServiceServer).CreateSomething(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/example.IntPointService/CreateSomething",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(IntPointServiceServer).CreateSomething(ctx, req.(*Something))
	}
	return interceptor(ctx, in, info, handler)
}

var _IntPointService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "example.IntPointService",
	HandlerType: (*IntPointServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Create",
			Handler:    _IntPointService_Create_Handler,
		},
		{
			MethodName: "Read",
			Handler:    _IntPointService_Read_Handler,
		},
		{
			MethodName: "Update",
			Handler:    _IntPointService_Update_Handler,
		},
		{
			MethodName: "List",
			Handler:    _IntPointService_List_Handler,
		},
		{
			MethodName: "ListSomething",
			Handler:    _IntPointService_ListSomething_Handler,
		},
		{
			MethodName: "Delete",
			Handler:    _IntPointService_Delete_Handler,
		},
		{
			MethodName: "CustomMethod",
			Handler:    _IntPointService_CustomMethod_Handler,
		},
		{
			MethodName: "CreateSomething",
			Handler:    _IntPointService_CreateSomething_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "example/feature_demo/demo_service.proto",
}

// Client API for IntPointTxn service

type IntPointTxnClient interface {
	// The convention requires the rpc names have Create/Read/Update/List/Delete
	// as a prefix. The type is inferred from the response (except for delete),
	// so multiple objects can have CURDL handlers in the same service, provided
	// they are given unique suffixes
	Create(ctx context.Context, in *CreateIntPointRequest, opts ...grpc.CallOption) (*CreateIntPointResponse, error)
	Read(ctx context.Context, in *ReadIntPointRequest, opts ...grpc.CallOption) (*ReadIntPointResponse, error)
	Update(ctx context.Context, in *UpdateIntPointRequest, opts ...grpc.CallOption) (*UpdateIntPointResponse, error)
	List(ctx context.Context, in *ListIntPointRequest, opts ...grpc.CallOption) (*ListIntPointResponse, error)
	Delete(ctx context.Context, in *DeleteIntPointRequest, opts ...grpc.CallOption) (*DeleteIntPointResponse, error)
	DeleteSet(ctx context.Context, in *DeleteIntPointsRequest, opts ...grpc.CallOption) (*DeleteIntPointResponse, error)
	// CustomMethod can't be autogenerated as it matches no conventions, it will
	// become a stub
	CustomMethod(ctx context.Context, in *google_protobuf2.Empty, opts ...grpc.CallOption) (*google_protobuf2.Empty, error)
	// CreateSomething also doesn't match conventions and will become a stub
	CreateSomething(ctx context.Context, in *Something, opts ...grpc.CallOption) (*Something, error)
}

type intPointTxnClient struct {
	cc *grpc.ClientConn
}

func NewIntPointTxnClient(cc *grpc.ClientConn) IntPointTxnClient {
	return &intPointTxnClient{cc}
}

func (c *intPointTxnClient) Create(ctx context.Context, in *CreateIntPointRequest, opts ...grpc.CallOption) (*CreateIntPointResponse, error) {
	out := new(CreateIntPointResponse)
	err := grpc.Invoke(ctx, "/example.IntPointTxn/Create", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *intPointTxnClient) Read(ctx context.Context, in *ReadIntPointRequest, opts ...grpc.CallOption) (*ReadIntPointResponse, error) {
	out := new(ReadIntPointResponse)
	err := grpc.Invoke(ctx, "/example.IntPointTxn/Read", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *intPointTxnClient) Update(ctx context.Context, in *UpdateIntPointRequest, opts ...grpc.CallOption) (*UpdateIntPointResponse, error) {
	out := new(UpdateIntPointResponse)
	err := grpc.Invoke(ctx, "/example.IntPointTxn/Update", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *intPointTxnClient) List(ctx context.Context, in *ListIntPointRequest, opts ...grpc.CallOption) (*ListIntPointResponse, error) {
	out := new(ListIntPointResponse)
	err := grpc.Invoke(ctx, "/example.IntPointTxn/List", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *intPointTxnClient) Delete(ctx context.Context, in *DeleteIntPointRequest, opts ...grpc.CallOption) (*DeleteIntPointResponse, error) {
	out := new(DeleteIntPointResponse)
	err := grpc.Invoke(ctx, "/example.IntPointTxn/Delete", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *intPointTxnClient) DeleteSet(ctx context.Context, in *DeleteIntPointsRequest, opts ...grpc.CallOption) (*DeleteIntPointResponse, error) {
	out := new(DeleteIntPointResponse)
	err := grpc.Invoke(ctx, "/example.IntPointTxn/DeleteSet", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *intPointTxnClient) CustomMethod(ctx context.Context, in *google_protobuf2.Empty, opts ...grpc.CallOption) (*google_protobuf2.Empty, error) {
	out := new(google_protobuf2.Empty)
	err := grpc.Invoke(ctx, "/example.IntPointTxn/CustomMethod", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *intPointTxnClient) CreateSomething(ctx context.Context, in *Something, opts ...grpc.CallOption) (*Something, error) {
	out := new(Something)
	err := grpc.Invoke(ctx, "/example.IntPointTxn/CreateSomething", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// Server API for IntPointTxn service

type IntPointTxnServer interface {
	// The convention requires the rpc names have Create/Read/Update/List/Delete
	// as a prefix. The type is inferred from the response (except for delete),
	// so multiple objects can have CURDL handlers in the same service, provided
	// they are given unique suffixes
	Create(context.Context, *CreateIntPointRequest) (*CreateIntPointResponse, error)
	Read(context.Context, *ReadIntPointRequest) (*ReadIntPointResponse, error)
	Update(context.Context, *UpdateIntPointRequest) (*UpdateIntPointResponse, error)
	List(context.Context, *ListIntPointRequest) (*ListIntPointResponse, error)
	Delete(context.Context, *DeleteIntPointRequest) (*DeleteIntPointResponse, error)
	DeleteSet(context.Context, *DeleteIntPointsRequest) (*DeleteIntPointResponse, error)
	// CustomMethod can't be autogenerated as it matches no conventions, it will
	// become a stub
	CustomMethod(context.Context, *google_protobuf2.Empty) (*google_protobuf2.Empty, error)
	// CreateSomething also doesn't match conventions and will become a stub
	CreateSomething(context.Context, *Something) (*Something, error)
}

func RegisterIntPointTxnServer(s *grpc.Server, srv IntPointTxnServer) {
	s.RegisterService(&_IntPointTxn_serviceDesc, srv)
}

func _IntPointTxn_Create_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateIntPointRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(IntPointTxnServer).Create(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/example.IntPointTxn/Create",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(IntPointTxnServer).Create(ctx, req.(*CreateIntPointRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _IntPointTxn_Read_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReadIntPointRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(IntPointTxnServer).Read(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/example.IntPointTxn/Read",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(IntPointTxnServer).Read(ctx, req.(*ReadIntPointRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _IntPointTxn_Update_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateIntPointRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(IntPointTxnServer).Update(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/example.IntPointTxn/Update",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(IntPointTxnServer).Update(ctx, req.(*UpdateIntPointRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _IntPointTxn_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListIntPointRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(IntPointTxnServer).List(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/example.IntPointTxn/List",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(IntPointTxnServer).List(ctx, req.(*ListIntPointRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _IntPointTxn_Delete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteIntPointRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(IntPointTxnServer).Delete(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/example.IntPointTxn/Delete",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(IntPointTxnServer).Delete(ctx, req.(*DeleteIntPointRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _IntPointTxn_DeleteSet_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteIntPointsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(IntPointTxnServer).DeleteSet(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/example.IntPointTxn/DeleteSet",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(IntPointTxnServer).DeleteSet(ctx, req.(*DeleteIntPointsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _IntPointTxn_CustomMethod_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(google_protobuf2.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(IntPointTxnServer).CustomMethod(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/example.IntPointTxn/CustomMethod",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(IntPointTxnServer).CustomMethod(ctx, req.(*google_protobuf2.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _IntPointTxn_CreateSomething_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Something)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(IntPointTxnServer).CreateSomething(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/example.IntPointTxn/CreateSomething",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(IntPointTxnServer).CreateSomething(ctx, req.(*Something))
	}
	return interceptor(ctx, in, info, handler)
}

var _IntPointTxn_serviceDesc = grpc.ServiceDesc{
	ServiceName: "example.IntPointTxn",
	HandlerType: (*IntPointTxnServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Create",
			Handler:    _IntPointTxn_Create_Handler,
		},
		{
			MethodName: "Read",
			Handler:    _IntPointTxn_Read_Handler,
		},
		{
			MethodName: "Update",
			Handler:    _IntPointTxn_Update_Handler,
		},
		{
			MethodName: "List",
			Handler:    _IntPointTxn_List_Handler,
		},
		{
			MethodName: "Delete",
			Handler:    _IntPointTxn_Delete_Handler,
		},
		{
			MethodName: "DeleteSet",
			Handler:    _IntPointTxn_DeleteSet_Handler,
		},
		{
			MethodName: "CustomMethod",
			Handler:    _IntPointTxn_CustomMethod_Handler,
		},
		{
			MethodName: "CreateSomething",
			Handler:    _IntPointTxn_CreateSomething_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "example/feature_demo/demo_service.proto",
}

// Client API for CircleService service

type CircleServiceClient interface {
	List(ctx context.Context, in *ListCircleRequest, opts ...grpc.CallOption) (*ListCircleResponse, error)
}

type circleServiceClient struct {
	cc *grpc.ClientConn
}

func NewCircleServiceClient(cc *grpc.ClientConn) CircleServiceClient {
	return &circleServiceClient{cc}
}

func (c *circleServiceClient) List(ctx context.Context, in *ListCircleRequest, opts ...grpc.CallOption) (*ListCircleResponse, error) {
	out := new(ListCircleResponse)
	err := grpc.Invoke(ctx, "/example.CircleService/List", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// Server API for CircleService service

type CircleServiceServer interface {
	List(context.Context, *ListCircleRequest) (*ListCircleResponse, error)
}

func RegisterCircleServiceServer(s *grpc.Server, srv CircleServiceServer) {
	s.RegisterService(&_CircleService_serviceDesc, srv)
}

func _CircleService_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListCircleRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CircleServiceServer).List(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/example.CircleService/List",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CircleServiceServer).List(ctx, req.(*ListCircleRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _CircleService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "example.CircleService",
	HandlerType: (*CircleServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "List",
			Handler:    _CircleService_List_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "example/feature_demo/demo_service.proto",
}

func init() { proto.RegisterFile("example/feature_demo/demo_service.proto", fileDescriptor2) }

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