generated.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: github.com/kennyzhu/go-os/dbservice/tools/example/protos/github.com/kennyzhu/go-os/dbservice/tools/example/generated.proto

package example

import (
	proto "github.com/gogo/protobuf/proto"
	categories2 "github.com/kennyzhu/go-os/src/dbservice/tools/example/categories"
)
import fmt "fmt"
import math "math"
import _ "github.com/gogo/protobuf/gogoproto"
import _ "github.com/gogo/protobuf/types"

import time "time"

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

import encoding_binary "encoding/binary"
import github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"

import io "io"

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

// 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.GoGoProtoPackageIsVersion2 // please upgrade the proto package

// Type will be transformed into an enum.
var Type_name = map[int32]string{
	0: "PUBLIC",
	1: "PRIVATE",
	2: "CUSTOM",
}
var Type_value = map[string]int32{
	"PUBLIC":  0,
	"PRIVATE": 1,
	"CUSTOM":  2,
}

func (Type) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_generated_1f3f58fde7d04323, []int{0}
}

func (m *Category) Reset()      { *m = Category{} }
func (*Category) ProtoMessage() {}
func (*Category) Descriptor() ([]byte, []int) {
	return fileDescriptor_generated_1f3f58fde7d04323, []int{0}
}
func (m *Category) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Category) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Category.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *Category) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Category.Merge(dst, src)
}
func (m *Category) XXX_Size() int {
	return m.ProtoSize()
}
func (m *Category) XXX_DiscardUnknown() {
	xxx_messageInfo_Category.DiscardUnknown(m)
}

var xxx_messageInfo_Category proto.InternalMessageInfo

func (m *MyDuration) Reset()         { *m = MyDuration{} }
func (m *MyDuration) String() string { return proto.CompactTextString(m) }
func (*MyDuration) ProtoMessage()    {}
func (*MyDuration) Descriptor() ([]byte, []int) {
	return fileDescriptor_generated_1f3f58fde7d04323, []int{1}
}
func (m *MyDuration) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MyDuration) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MyDuration.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *MyDuration) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MyDuration.Merge(dst, src)
}
func (m *MyDuration) XXX_Size() int {
	return m.ProtoSize()
}
func (m *MyDuration) XXX_DiscardUnknown() {
	xxx_messageInfo_MyDuration.DiscardUnknown(m)
}

var xxx_messageInfo_MyDuration proto.InternalMessageInfo

func (m *MyTime) Reset()         { *m = MyTime{} }
func (m *MyTime) String() string { return proto.CompactTextString(m) }
func (*MyTime) ProtoMessage()    {}
func (*MyTime) Descriptor() ([]byte, []int) {
	return fileDescriptor_generated_1f3f58fde7d04323, []int{2}
}
func (m *MyTime) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MyTime) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MyTime.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *MyTime) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MyTime.Merge(dst, src)
}
func (m *MyTime) XXX_Size() int {
	return m.ProtoSize()
}
func (m *MyTime) XXX_DiscardUnknown() {
	xxx_messageInfo_MyTime.DiscardUnknown(m)
}

var xxx_messageInfo_MyTime proto.InternalMessageInfo

func (m *Price) Reset()         { *m = Price{} }
func (m *Price) String() string { return proto.CompactTextString(m) }
func (*Price) ProtoMessage()    {}
func (*Price) Descriptor() ([]byte, []int) {
	return fileDescriptor_generated_1f3f58fde7d04323, []int{3}
}
func (m *Price) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Price) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Price.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *Price) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Price.Merge(dst, src)
}
func (m *Price) XXX_Size() int {
	return m.ProtoSize()
}
func (m *Price) XXX_DiscardUnknown() {
	xxx_messageInfo_Price.DiscardUnknown(m)
}

var xxx_messageInfo_Price proto.InternalMessageInfo

func (m *Product) Reset()         { *m = Product{} }
func (m *Product) String() string { return proto.CompactTextString(m) }
func (*Product) ProtoMessage()    {}
func (*Product) Descriptor() ([]byte, []int) {
	return fileDescriptor_generated_1f3f58fde7d04323, []int{4}
}
func (m *Product) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Product) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Product.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *Product) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Product.Merge(dst, src)
}
func (m *Product) XXX_Size() int {
	return m.ProtoSize()
}
func (m *Product) XXX_DiscardUnknown() {
	xxx_messageInfo_Product.DiscardUnknown(m)
}

var xxx_messageInfo_Product proto.InternalMessageInfo

type GetAlphaTimeRequest struct {
}

func (m *GetAlphaTimeRequest) Reset()         { *m = GetAlphaTimeRequest{} }
func (m *GetAlphaTimeRequest) String() string { return proto.CompactTextString(m) }
func (*GetAlphaTimeRequest) ProtoMessage()    {}
func (*GetAlphaTimeRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_generated_1f3f58fde7d04323, []int{5}
}
func (m *GetAlphaTimeRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetAlphaTimeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetAlphaTimeRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *GetAlphaTimeRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetAlphaTimeRequest.Merge(dst, src)
}
func (m *GetAlphaTimeRequest) XXX_Size() int {
	return m.ProtoSize()
}
func (m *GetAlphaTimeRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GetAlphaTimeRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GetAlphaTimeRequest proto.InternalMessageInfo

type GetDurationForLengthRequest struct {
	Arg1 int64 `protobuf:"varint,1,opt,name=arg1,proto3" json:"arg1,omitempty"`
}

func (m *GetDurationForLengthRequest) Reset()         { *m = GetDurationForLengthRequest{} }
func (m *GetDurationForLengthRequest) String() string { return proto.CompactTextString(m) }
func (*GetDurationForLengthRequest) ProtoMessage()    {}
func (*GetDurationForLengthRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_generated_1f3f58fde7d04323, []int{6}
}
func (m *GetDurationForLengthRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetDurationForLengthRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetDurationForLengthRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *GetDurationForLengthRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetDurationForLengthRequest.Merge(dst, src)
}
func (m *GetDurationForLengthRequest) XXX_Size() int {
	return m.ProtoSize()
}
func (m *GetDurationForLengthRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GetDurationForLengthRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GetDurationForLengthRequest proto.InternalMessageInfo

func (m *GetDurationForLengthRequest) GetArg1() int64 {
	if m != nil {
		return m.Arg1
	}
	return 0
}

type GetDurationForLengthCtxRequest struct {
	Arg1 int64 `protobuf:"varint,1,opt,name=arg1,proto3" json:"arg1,omitempty"`
}

func (m *GetDurationForLengthCtxRequest) Reset()         { *m = GetDurationForLengthCtxRequest{} }
func (m *GetDurationForLengthCtxRequest) String() string { return proto.CompactTextString(m) }
func (*GetDurationForLengthCtxRequest) ProtoMessage()    {}
func (*GetDurationForLengthCtxRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_generated_1f3f58fde7d04323, []int{7}
}
func (m *GetDurationForLengthCtxRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetDurationForLengthCtxRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetDurationForLengthCtxRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *GetDurationForLengthCtxRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetDurationForLengthCtxRequest.Merge(dst, src)
}
func (m *GetDurationForLengthCtxRequest) XXX_Size() int {
	return m.ProtoSize()
}
func (m *GetDurationForLengthCtxRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GetDurationForLengthCtxRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GetDurationForLengthCtxRequest proto.InternalMessageInfo

func (m *GetDurationForLengthCtxRequest) GetArg1() int64 {
	if m != nil {
		return m.Arg1
	}
	return 0
}

type GetOmegaTimeRequest struct {
}

func (m *GetOmegaTimeRequest) Reset()         { *m = GetOmegaTimeRequest{} }
func (m *GetOmegaTimeRequest) String() string { return proto.CompactTextString(m) }
func (*GetOmegaTimeRequest) ProtoMessage()    {}
func (*GetOmegaTimeRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_generated_1f3f58fde7d04323, []int{8}
}
func (m *GetOmegaTimeRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetOmegaTimeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetOmegaTimeRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *GetOmegaTimeRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetOmegaTimeRequest.Merge(dst, src)
}
func (m *GetOmegaTimeRequest) XXX_Size() int {
	return m.ProtoSize()
}
func (m *GetOmegaTimeRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GetOmegaTimeRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GetOmegaTimeRequest proto.InternalMessageInfo

type GetPhoneRequest struct {
}

func (m *GetPhoneRequest) Reset()         { *m = GetPhoneRequest{} }
func (m *GetPhoneRequest) String() string { return proto.CompactTextString(m) }
func (*GetPhoneRequest) ProtoMessage()    {}
func (*GetPhoneRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_generated_1f3f58fde7d04323, []int{9}
}
func (m *GetPhoneRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetPhoneRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetPhoneRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *GetPhoneRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetPhoneRequest.Merge(dst, src)
}
func (m *GetPhoneRequest) XXX_Size() int {
	return m.ProtoSize()
}
func (m *GetPhoneRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GetPhoneRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GetPhoneRequest proto.InternalMessageInfo

type RandomCategoryRequest struct {
}

func (m *RandomCategoryRequest) Reset()         { *m = RandomCategoryRequest{} }
func (m *RandomCategoryRequest) String() string { return proto.CompactTextString(m) }
func (*RandomCategoryRequest) ProtoMessage()    {}
func (*RandomCategoryRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_generated_1f3f58fde7d04323, []int{10}
}
func (m *RandomCategoryRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RandomCategoryRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RandomCategoryRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *RandomCategoryRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RandomCategoryRequest.Merge(dst, src)
}
func (m *RandomCategoryRequest) XXX_Size() int {
	return m.ProtoSize()
}
func (m *RandomCategoryRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RandomCategoryRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RandomCategoryRequest proto.InternalMessageInfo

type RandomNumberRequest struct {
	Arg1 float64 `protobuf:"fixed64,1,opt,name=arg1,proto3" json:"arg1,omitempty"`
	Arg2 float64 `protobuf:"fixed64,2,opt,name=arg2,proto3" json:"arg2,omitempty"`
}

func (m *RandomNumberRequest) Reset()         { *m = RandomNumberRequest{} }
func (m *RandomNumberRequest) String() string { return proto.CompactTextString(m) }
func (*RandomNumberRequest) ProtoMessage()    {}
func (*RandomNumberRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_generated_1f3f58fde7d04323, []int{11}
}
func (m *RandomNumberRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RandomNumberRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RandomNumberRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *RandomNumberRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RandomNumberRequest.Merge(dst, src)
}
func (m *RandomNumberRequest) XXX_Size() int {
	return m.ProtoSize()
}
func (m *RandomNumberRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RandomNumberRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RandomNumberRequest proto.InternalMessageInfo

func (m *RandomNumberRequest) GetArg1() float64 {
	if m != nil {
		return m.Arg1
	}
	return 0
}

func (m *RandomNumberRequest) GetArg2() float64 {
	if m != nil {
		return m.Arg2
	}
	return 0
}

type RandomNumberResponse struct {
	Result1 float64 `protobuf:"fixed64,1,opt,name=result1,proto3" json:"result1,omitempty"`
}

func (m *RandomNumberResponse) Reset()         { *m = RandomNumberResponse{} }
func (m *RandomNumberResponse) String() string { return proto.CompactTextString(m) }
func (*RandomNumberResponse) ProtoMessage()    {}
func (*RandomNumberResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_generated_1f3f58fde7d04323, []int{12}
}
func (m *RandomNumberResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RandomNumberResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RandomNumberResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *RandomNumberResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RandomNumberResponse.Merge(dst, src)
}
func (m *RandomNumberResponse) XXX_Size() int {
	return m.ProtoSize()
}
func (m *RandomNumberResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RandomNumberResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RandomNumberResponse proto.InternalMessageInfo

func (m *RandomNumberResponse) GetResult1() float64 {
	if m != nil {
		return m.Result1
	}
	return 0
}

func init() {
	proto.RegisterType((*Category)(nil), "github.com.kennyzhu.goos.dbservice.tools.example.Category")
	proto.RegisterType((*MyDuration)(nil), "github.com.kennyzhu.goos.dbservice.tools.example.MyDuration")
	proto.RegisterType((*MyTime)(nil), "github.com.kennyzhu.goos.dbservice.tools.example.MyTime")
	proto.RegisterType((*Price)(nil), "github.com.kennyzhu.goos.dbservice.tools.example.Price")
	proto.RegisterType((*Product)(nil), "github.com.kennyzhu.goos.dbservice.tools.example.Product")
	proto.RegisterType((*GetAlphaTimeRequest)(nil), "github.com.kennyzhu.goos.dbservice.tools.example.GetAlphaTimeRequest")
	proto.RegisterType((*GetDurationForLengthRequest)(nil), "github.com.kennyzhu.goos.dbservice.tools.example.GetDurationForLengthRequest")
	proto.RegisterType((*GetDurationForLengthCtxRequest)(nil), "github.com.kennyzhu.goos.dbservice.tools.example.GetDurationForLengthCtxRequest")
	proto.RegisterType((*GetOmegaTimeRequest)(nil), "github.com.kennyzhu.goos.dbservice.tools.example.GetOmegaTimeRequest")
	proto.RegisterType((*GetPhoneRequest)(nil), "github.com.kennyzhu.goos.dbservice.tools.example.GetPhoneRequest")
	proto.RegisterType((*RandomCategoryRequest)(nil), "github.com.kennyzhu.goos.dbservice.tools.example.RandomCategoryRequest")
	proto.RegisterType((*RandomNumberRequest)(nil), "github.com.kennyzhu.goos.dbservice.tools.example.RandomNumberRequest")
	proto.RegisterType((*RandomNumberResponse)(nil), "github.com.kennyzhu.goos.dbservice.tools.example.RandomNumberResponse")
	proto.RegisterEnum("github.com.kennyzhu.goos.dbservice.tools.example.Type", Type_name, Type_value)
}

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

// ExampleServiceClient is the client API for ExampleService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type ExampleServiceClient interface {
	GetAlphaTime(ctx context.Context, in *GetAlphaTimeRequest, opts ...grpc.CallOption) (*MyTime, error)
	GetDurationForLength(ctx context.Context, in *GetDurationForLengthRequest, opts ...grpc.CallOption) (*MyDuration, error)
	GetDurationForLengthCtx(ctx context.Context, in *GetDurationForLengthCtxRequest, opts ...grpc.CallOption) (*MyDuration, error)
	GetOmegaTime(ctx context.Context, in *GetOmegaTimeRequest, opts ...grpc.CallOption) (*MyTime, error)
	GetPhone(ctx context.Context, in *GetPhoneRequest, opts ...grpc.CallOption) (*Product, error)
	RandomCategory(ctx context.Context, in *RandomCategoryRequest, opts ...grpc.CallOption) (*categories2.CategoryOptions, error)
	RandomNumber(ctx context.Context, in *RandomNumberRequest, opts ...grpc.CallOption) (*RandomNumberResponse, error)
}

type exampleServiceClient struct {
	cc *grpc.ClientConn
}

func NewExampleServiceClient(cc *grpc.ClientConn) ExampleServiceClient {
	return &exampleServiceClient{cc}
}

func (c *exampleServiceClient) GetAlphaTime(ctx context.Context, in *GetAlphaTimeRequest, opts ...grpc.CallOption) (*MyTime, error) {
	out := new(MyTime)
	err := c.cc.Invoke(ctx, "/github.com.kennyzhu.goos.dbservice.tools.example.ExampleService/GetAlphaTime", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *exampleServiceClient) GetDurationForLength(ctx context.Context, in *GetDurationForLengthRequest, opts ...grpc.CallOption) (*MyDuration, error) {
	out := new(MyDuration)
	err := c.cc.Invoke(ctx, "/github.com.kennyzhu.goos.dbservice.tools.example.ExampleService/GetDurationForLength", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *exampleServiceClient) GetDurationForLengthCtx(ctx context.Context, in *GetDurationForLengthCtxRequest, opts ...grpc.CallOption) (*MyDuration, error) {
	out := new(MyDuration)
	err := c.cc.Invoke(ctx, "/github.com.kennyzhu.goos.dbservice.tools.example.ExampleService/GetDurationForLengthCtx", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *exampleServiceClient) GetOmegaTime(ctx context.Context, in *GetOmegaTimeRequest, opts ...grpc.CallOption) (*MyTime, error) {
	out := new(MyTime)
	err := c.cc.Invoke(ctx, "/github.com.kennyzhu.goos.dbservice.tools.example.ExampleService/GetOmegaTime", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *exampleServiceClient) GetPhone(ctx context.Context, in *GetPhoneRequest, opts ...grpc.CallOption) (*Product, error) {
	out := new(Product)
	err := c.cc.Invoke(ctx, "/github.com.kennyzhu.goos.dbservice.tools.example.ExampleService/GetPhone", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *exampleServiceClient) RandomCategory(ctx context.Context, in *RandomCategoryRequest, opts ...grpc.CallOption) (*categories2.CategoryOptions, error) {
	out := new(categories2.CategoryOptions)
	err := c.cc.Invoke(ctx, "/github.com.kennyzhu.goos.dbservice.tools.example.ExampleService/RandomCategory", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *exampleServiceClient) RandomNumber(ctx context.Context, in *RandomNumberRequest, opts ...grpc.CallOption) (*RandomNumberResponse, error) {
	out := new(RandomNumberResponse)
	err := c.cc.Invoke(ctx, "/github.com.kennyzhu.goos.dbservice.tools.example.ExampleService/RandomNumber", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ExampleServiceServer is the server API for ExampleService service.
type ExampleServiceServer interface {
	GetAlphaTime(context.Context, *GetAlphaTimeRequest) (*MyTime, error)
	GetDurationForLength(context.Context, *GetDurationForLengthRequest) (*MyDuration, error)
	GetDurationForLengthCtx(context.Context, *GetDurationForLengthCtxRequest) (*MyDuration, error)
	GetOmegaTime(context.Context, *GetOmegaTimeRequest) (*MyTime, error)
	GetPhone(context.Context, *GetPhoneRequest) (*Product, error)
	RandomCategory(context.Context, *RandomCategoryRequest) (*categories2.CategoryOptions, error)
	RandomNumber(context.Context, *RandomNumberRequest) (*RandomNumberResponse, error)
}

func RegisterExampleServiceServer(s *grpc.Server, srv ExampleServiceServer) {
	s.RegisterService(&_ExampleService_serviceDesc, srv)
}

func _ExampleService_GetAlphaTime_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetAlphaTimeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ExampleServiceServer).GetAlphaTime(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/github.com.kennyzhu.goos.dbservice.tools.example.ExampleService/GetAlphaTime",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ExampleServiceServer).GetAlphaTime(ctx, req.(*GetAlphaTimeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ExampleService_GetDurationForLength_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetDurationForLengthRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ExampleServiceServer).GetDurationForLength(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/github.com.kennyzhu.goos.dbservice.tools.example.ExampleService/GetDurationForLength",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ExampleServiceServer).GetDurationForLength(ctx, req.(*GetDurationForLengthRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ExampleService_GetDurationForLengthCtx_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetDurationForLengthCtxRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ExampleServiceServer).GetDurationForLengthCtx(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/github.com.kennyzhu.goos.dbservice.tools.example.ExampleService/GetDurationForLengthCtx",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ExampleServiceServer).GetDurationForLengthCtx(ctx, req.(*GetDurationForLengthCtxRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ExampleService_GetOmegaTime_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetOmegaTimeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ExampleServiceServer).GetOmegaTime(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/github.com.kennyzhu.goos.dbservice.tools.example.ExampleService/GetOmegaTime",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ExampleServiceServer).GetOmegaTime(ctx, req.(*GetOmegaTimeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ExampleService_GetPhone_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetPhoneRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ExampleServiceServer).GetPhone(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/github.com.kennyzhu.goos.dbservice.tools.example.ExampleService/GetPhone",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ExampleServiceServer).GetPhone(ctx, req.(*GetPhoneRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ExampleService_RandomCategory_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RandomCategoryRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ExampleServiceServer).RandomCategory(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/github.com.kennyzhu.goos.dbservice.tools.example.ExampleService/RandomCategory",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ExampleServiceServer).RandomCategory(ctx, req.(*RandomCategoryRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ExampleService_RandomNumber_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RandomNumberRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ExampleServiceServer).RandomNumber(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/github.com.kennyzhu.goos.dbservice.tools.example.ExampleService/RandomNumber",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ExampleServiceServer).RandomNumber(ctx, req.(*RandomNumberRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _ExampleService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "github.com.kennyzhu.goos.dbservice.tools.example.ExampleService",
	HandlerType: (*ExampleServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetAlphaTime",
			Handler:    _ExampleService_GetAlphaTime_Handler,
		},
		{
			MethodName: "GetDurationForLength",
			Handler:    _ExampleService_GetDurationForLength_Handler,
		},
		{
			MethodName: "GetDurationForLengthCtx",
			Handler:    _ExampleService_GetDurationForLengthCtx_Handler,
		},
		{
			MethodName: "GetOmegaTime",
			Handler:    _ExampleService_GetOmegaTime_Handler,
		},
		{
			MethodName: "GetPhone",
			Handler:    _ExampleService_GetPhone_Handler,
		},
		{
			MethodName: "RandomCategory",
			Handler:    _ExampleService_RandomCategory_Handler,
		},
		{
			MethodName: "RandomNumber",
			Handler:    _ExampleService_RandomNumber_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "github.com/kennyzhu/go-os/dbservice/tools/example/protos/github.com/kennyzhu/go-os/dbservice/tools/example/generated.proto",
}

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

func (m *Category) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.ID != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintGenerated(dAtA, i, uint64(m.ID))
	}
	dAtA[i] = 0x12
	i++
	i = encodeVarintGenerated(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(m.CreatedAt)))
	n1, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.CreatedAt, dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n1
	dAtA[i] = 0x1a
	i++
	i = encodeVarintGenerated(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(m.UpdatedAt)))
	n2, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.UpdatedAt, dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n2
	dAtA[i] = 0x22
	i++
	i = encodeVarintGenerated(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(m.DeletedAt)))
	n3, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.DeletedAt, dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n3
	if len(m.Name) > 0 {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
		i += copy(dAtA[i:], m.Name)
	}
	if m.Type != 0 {
		dAtA[i] = 0x30
		i++
		i = encodeVarintGenerated(dAtA, i, uint64(m.Type))
	}
	if len(m.Color) > 0 {
		dAtA[i] = 0x3a
		i++
		i = encodeVarintGenerated(dAtA, i, uint64(len(m.Color)))
		i += copy(dAtA[i:], m.Color)
	}
	dAtA[i] = 0x42
	i++
	i = encodeVarintGenerated(dAtA, i, uint64(m.Options.ProtoSize()))
	n4, err := m.Options.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n4
	return i, nil
}

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

func (m *MyDuration) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0xa
	i++
	i = encodeVarintGenerated(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdDuration(m.Duration)))
	n5, err := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.Duration, dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n5
	if len(m.Name) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
		i += copy(dAtA[i:], m.Name)
	}
	return i, nil
}

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

func (m *MyTime) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0xa
	i++
	i = encodeVarintGenerated(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(m.Time)))
	n6, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Time, dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n6
	if len(m.Name) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
		i += copy(dAtA[i:], m.Name)
	}
	return i, nil
}

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

func (m *Price) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Currency) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintGenerated(dAtA, i, uint64(len(m.Currency)))
		i += copy(dAtA[i:], m.Currency)
	}
	if m.Amount != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintGenerated(dAtA, i, uint64(m.Amount))
	}
	return i, nil
}

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

func (m *Product) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.ID != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintGenerated(dAtA, i, uint64(m.ID))
	}
	dAtA[i] = 0x12
	i++
	i = encodeVarintGenerated(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(m.CreatedAt)))
	n7, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.CreatedAt, dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n7
	dAtA[i] = 0x1a
	i++
	i = encodeVarintGenerated(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(m.UpdatedAt)))
	n8, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.UpdatedAt, dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n8
	dAtA[i] = 0x22
	i++
	i = encodeVarintGenerated(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(m.DeletedAt)))
	n9, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.DeletedAt, dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n9
	if len(m.Name) > 0 {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
		i += copy(dAtA[i:], m.Name)
	}
	if len(m.Price) > 0 {
		for k, _ := range m.Price {
			dAtA[i] = 0x32
			i++
			v := m.Price[k]
			msgSize := 0
			if (&v) != nil {
				msgSize = (&v).ProtoSize()
				msgSize += 1 + sovGenerated(uint64(msgSize))
			}
			mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + msgSize
			i = encodeVarintGenerated(dAtA, i, uint64(mapSize))
			dAtA[i] = 0xa
			i++
			i = encodeVarintGenerated(dAtA, i, uint64(len(k)))
			i += copy(dAtA[i:], k)
			dAtA[i] = 0x12
			i++
			i = encodeVarintGenerated(dAtA, i, uint64((&v).ProtoSize()))
			n10, err := (&v).MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n10
		}
	}
	if len(m.Tags) > 0 {
		for _, s := range m.Tags {
			dAtA[i] = 0x3a
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	if m.CategoryID != 0 {
		dAtA[i] = 0x40
		i++
		i = encodeVarintGenerated(dAtA, i, uint64(m.CategoryID))
	}
	if m.PrimaryCategoryID != 0 {
		dAtA[i] = 0x48
		i++
		i = encodeVarintGenerated(dAtA, i, uint64(m.PrimaryCategoryID))
	}
	return i, nil
}

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

func (m *GetAlphaTimeRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	return i, nil
}

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

func (m *GetDurationForLengthRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Arg1 != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintGenerated(dAtA, i, uint64(m.Arg1))
	}
	return i, nil
}

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

func (m *GetDurationForLengthCtxRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Arg1 != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintGenerated(dAtA, i, uint64(m.Arg1))
	}
	return i, nil
}

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

func (m *GetOmegaTimeRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	return i, nil
}

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

func (m *GetPhoneRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	return i, nil
}

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

func (m *RandomCategoryRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	return i, nil
}

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

func (m *RandomNumberRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Arg1 != 0 {
		dAtA[i] = 0x9
		i++
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Arg1))))
		i += 8
	}
	if m.Arg2 != 0 {
		dAtA[i] = 0x11
		i++
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Arg2))))
		i += 8
	}
	return i, nil
}

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

func (m *RandomNumberResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Result1 != 0 {
		dAtA[i] = 0x9
		i++
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Result1))))
		i += 8
	}
	return i, nil
}

func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return offset + 1
}
func (m *Category) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ID != 0 {
		n += 1 + sovGenerated(uint64(m.ID))
	}
	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.CreatedAt)
	n += 1 + l + sovGenerated(uint64(l))
	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.UpdatedAt)
	n += 1 + l + sovGenerated(uint64(l))
	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.DeletedAt)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.Type != 0 {
		n += 1 + sovGenerated(uint64(m.Type))
	}
	l = len(m.Color)
	if l > 0 {
		n += 1 + l + sovGenerated(uint64(l))
	}
	l = m.Options.ProtoSize()
	n += 1 + l + sovGenerated(uint64(l))
	return n
}

func (m *MyDuration) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = github_com_gogo_protobuf_types.SizeOfStdDuration(m.Duration)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovGenerated(uint64(l))
	}
	return n
}

func (m *MyTime) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.Time)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovGenerated(uint64(l))
	}
	return n
}

func (m *Price) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Currency)
	if l > 0 {
		n += 1 + l + sovGenerated(uint64(l))
	}
	if m.Amount != 0 {
		n += 1 + sovGenerated(uint64(m.Amount))
	}
	return n
}

func (m *Product) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ID != 0 {
		n += 1 + sovGenerated(uint64(m.ID))
	}
	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.CreatedAt)
	n += 1 + l + sovGenerated(uint64(l))
	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.UpdatedAt)
	n += 1 + l + sovGenerated(uint64(l))
	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.DeletedAt)
	n += 1 + l + sovGenerated(uint64(l))
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovGenerated(uint64(l))
	}
	if len(m.Price) > 0 {
		for k, v := range m.Price {
			_ = k
			_ = v
			l = v.ProtoSize()
			mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + l + sovGenerated(uint64(l))
			n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
		}
	}
	if len(m.Tags) > 0 {
		for _, s := range m.Tags {
			l = len(s)
			n += 1 + l + sovGenerated(uint64(l))
		}
	}
	if m.CategoryID != 0 {
		n += 1 + sovGenerated(uint64(m.CategoryID))
	}
	if m.PrimaryCategoryID != 0 {
		n += 1 + sovGenerated(uint64(m.PrimaryCategoryID))
	}
	return n
}

func (m *GetAlphaTimeRequest) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *GetDurationForLengthRequest) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Arg1 != 0 {
		n += 1 + sovGenerated(uint64(m.Arg1))
	}
	return n
}

func (m *GetDurationForLengthCtxRequest) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Arg1 != 0 {
		n += 1 + sovGenerated(uint64(m.Arg1))
	}
	return n
}

func (m *GetOmegaTimeRequest) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *GetPhoneRequest) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RandomCategoryRequest) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *RandomNumberRequest) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Arg1 != 0 {
		n += 9
	}
	if m.Arg2 != 0 {
		n += 9
	}
	return n
}

func (m *RandomNumberResponse) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Result1 != 0 {
		n += 9
	}
	return n
}

func sovGenerated(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozGenerated(x uint64) (n int) {
	return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *Category) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowGenerated
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Category: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Category: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			m.ID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ID |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreatedAt", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.CreatedAt, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UpdatedAt", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.UpdatedAt, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DeletedAt", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.DeletedAt, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= (Type(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Color", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Color = Color(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Options", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Options.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MyDuration) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowGenerated
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MyDuration: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MyDuration: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Duration", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(&m.Duration, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MyTime) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowGenerated
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MyTime: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MyTime: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Time", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.Time, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Product) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowGenerated
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Product: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Product: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			m.ID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ID |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreatedAt", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.CreatedAt, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UpdatedAt", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.UpdatedAt, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DeletedAt", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.DeletedAt, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Price", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Price == nil {
				m.Price = make(Prices)
			}
			var mapkey string
			mapvalue := &Price{}
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowGenerated
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowGenerated
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= (uint64(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthGenerated
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowGenerated
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= (int(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthGenerated
					}
					postmsgIndex := iNdEx + mapmsglen
					if mapmsglen < 0 {
						return ErrInvalidLengthGenerated
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &Price{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipGenerated(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthGenerated
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Price[mapkey] = *mapvalue
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tags", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Tags = append(m.Tags, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CategoryID", wireType)
			}
			m.CategoryID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CategoryID |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PrimaryCategoryID", wireType)
			}
			m.PrimaryCategoryID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PrimaryCategoryID |= (int8(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RandomNumberRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowGenerated
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RandomNumberRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RandomNumberRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field Arg1", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.Arg1 = float64(math.Float64frombits(v))
		case 2:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field Arg2", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.Arg2 = float64(math.Float64frombits(v))
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RandomNumberResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowGenerated
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RandomNumberResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RandomNumberResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field Result1", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.Result1 = float64(math.Float64frombits(v))
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

var (
	ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowGenerated   = fmt.Errorf("proto: integer overflow")
)

func init() {
	proto.RegisterFile("github.com/kennyzhu/go-os/dbservice/tools/example/protos/github.com/kennyzhu/go-os/dbservice/tools/example/generated.proto", fileDescriptor_generated_1f3f58fde7d04323)
}

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