example.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: example/example.proto

package example

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/gogo/protobuf/gogoproto"
import _ "github.com/gogo/protobuf/types"
import _ "github.com/micro-grpc/protoc-gen-sqlx/pb/sql"
import _ "github.com/mwitkow/go-proto-validators"

import time "time"

import bytes "bytes"

import strings "strings"
import reflect "reflect"

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

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

// Order is a sort order.
type SortCriteria_Order int32

const (
	// ascending sort order
	ASC SortCriteria_Order = 0
	// descending sort order
	DESC SortCriteria_Order = 1
)

var SortCriteria_Order_name = map[int32]string{
	0: "ASC",
	1: "DESC",
}
var SortCriteria_Order_value = map[string]int32{
	"ASC":  0,
	"DESC": 1,
}

func (x SortCriteria_Order) String() string {
	return proto.EnumName(SortCriteria_Order_name, int32(x))
}
func (SortCriteria_Order) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_example_663bc880cd358822, []int{1, 0}
}

type Filtering_Mode int32

const (
	// EQ in sql =
	EQ Filtering_Mode = 0
	// NE  in sql !=
	NE Filtering_Mode = 1
	// GT in sql >
	GT Filtering_Mode = 2
	// GE in sql >=
	GE Filtering_Mode = 3
	// LT in sql <
	LT Filtering_Mode = 4
	// LE in sql <=
	LE Filtering_Mode = 5
	// IS_NULL in sql IS NULL
	IS_NULL Filtering_Mode = 6
	// NOT_NULL in sql IS NOT NULL
	NOT_NULL Filtering_Mode = 7
)

var Filtering_Mode_name = map[int32]string{
	0: "EQ",
	1: "NE",
	2: "GT",
	3: "GE",
	4: "LT",
	5: "LE",
	6: "IS_NULL",
	7: "NOT_NULL",
}
var Filtering_Mode_value = map[string]int32{
	"EQ":       0,
	"NE":       1,
	"GT":       2,
	"GE":       3,
	"LT":       4,
	"LE":       5,
	"IS_NULL":  6,
	"NOT_NULL": 7,
}

func (x Filtering_Mode) String() string {
	return proto.EnumName(Filtering_Mode_name, int32(x))
}
func (Filtering_Mode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_example_663bc880cd358822, []int{3, 0}
}

type Empty struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Empty) Reset()      { *m = Empty{} }
func (*Empty) ProtoMessage() {}
func (*Empty) Descriptor() ([]byte, []int) {
	return fileDescriptor_example_663bc880cd358822, []int{0}
}
func (m *Empty) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Empty) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Empty.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 *Empty) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Empty.Merge(dst, src)
}
func (m *Empty) XXX_Size() int {
	return m.Size()
}
func (m *Empty) XXX_DiscardUnknown() {
	xxx_messageInfo_Empty.DiscardUnknown(m)
}

var xxx_messageInfo_Empty proto.InternalMessageInfo

// SortCriteria represents sort criteria
type SortCriteria struct {
	// Tag is a JSON tag.
	Tag                  string             `protobuf:"bytes,1,opt,name=tag,proto3" json:"tag,omitempty"`
	Order                SortCriteria_Order `protobuf:"varint,2,opt,name=order,proto3,enum=example.SortCriteria_Order" json:"order,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

func (m *SortCriteria) Reset()      { *m = SortCriteria{} }
func (*SortCriteria) ProtoMessage() {}
func (*SortCriteria) Descriptor() ([]byte, []int) {
	return fileDescriptor_example_663bc880cd358822, []int{1}
}
func (m *SortCriteria) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SortCriteria) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SortCriteria.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 *SortCriteria) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SortCriteria.Merge(dst, src)
}
func (m *SortCriteria) XXX_Size() int {
	return m.Size()
}
func (m *SortCriteria) XXX_DiscardUnknown() {
	xxx_messageInfo_SortCriteria.DiscardUnknown(m)
}

var xxx_messageInfo_SortCriteria proto.InternalMessageInfo

func (m *SortCriteria) GetTag() string {
	if m != nil {
		return m.Tag
	}
	return ""
}

func (m *SortCriteria) GetOrder() SortCriteria_Order {
	if m != nil {
		return m.Order
	}
	return ASC
}

// Sorting represents list of sort criterias.
type Sorting struct {
	Sort                 []*SortCriteria `protobuf:"bytes,1,rep,name=sort" json:"sort,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (m *Sorting) Reset()      { *m = Sorting{} }
func (*Sorting) ProtoMessage() {}
func (*Sorting) Descriptor() ([]byte, []int) {
	return fileDescriptor_example_663bc880cd358822, []int{2}
}
func (m *Sorting) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Sorting) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Sorting.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 *Sorting) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Sorting.Merge(dst, src)
}
func (m *Sorting) XXX_Size() int {
	return m.Size()
}
func (m *Sorting) XXX_DiscardUnknown() {
	xxx_messageInfo_Sorting.DiscardUnknown(m)
}

var xxx_messageInfo_Sorting proto.InternalMessageInfo

func (m *Sorting) GetSort() []*SortCriteria {
	if m != nil {
		return m.Sort
	}
	return nil
}

type Filtering struct {
	Name                 string         `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Mode                 Filtering_Mode `protobuf:"varint,2,opt,name=mode,proto3,enum=example.Filtering_Mode" json:"mode,omitempty"`
	Value                string         `protobuf:"bytes,3,opt,name=value,proto3" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

func (m *Filtering) Reset()      { *m = Filtering{} }
func (*Filtering) ProtoMessage() {}
func (*Filtering) Descriptor() ([]byte, []int) {
	return fileDescriptor_example_663bc880cd358822, []int{3}
}
func (m *Filtering) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Filtering) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Filtering.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 *Filtering) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Filtering.Merge(dst, src)
}
func (m *Filtering) XXX_Size() int {
	return m.Size()
}
func (m *Filtering) XXX_DiscardUnknown() {
	xxx_messageInfo_Filtering.DiscardUnknown(m)
}

var xxx_messageInfo_Filtering proto.InternalMessageInfo

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

func (m *Filtering) GetMode() Filtering_Mode {
	if m != nil {
		return m.Mode
	}
	return EQ
}

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

type PageInfo struct {
	Current int64 `protobuf:"varint,1,opt,name=current,proto3" json:"current,omitempty"`
	// The service may optionally include the total number of resources being paged.
	Size_ int64 `protobuf:"varint,2,opt,name=size,proto3" json:"size,omitempty"`
	// The service may optionally include the offset of the next page of resources.
	// A null value indicates no more pages.
	Offset               int64    `protobuf:"varint,3,opt,name=offset,proto3" json:"offset,omitempty"`
	Limit                int64    `protobuf:"varint,4,opt,name=limit,proto3" json:"limit,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *PageInfo) Reset()      { *m = PageInfo{} }
func (*PageInfo) ProtoMessage() {}
func (*PageInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_example_663bc880cd358822, []int{4}
}
func (m *PageInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PageInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PageInfo.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 *PageInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PageInfo.Merge(dst, src)
}
func (m *PageInfo) XXX_Size() int {
	return m.Size()
}
func (m *PageInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_PageInfo.DiscardUnknown(m)
}

var xxx_messageInfo_PageInfo proto.InternalMessageInfo

func (m *PageInfo) GetCurrent() int64 {
	if m != nil {
		return m.Current
	}
	return 0
}

func (m *PageInfo) GetSize_() int64 {
	if m != nil {
		return m.Size_
	}
	return 0
}

func (m *PageInfo) GetOffset() int64 {
	if m != nil {
		return m.Offset
	}
	return 0
}

func (m *PageInfo) GetLimit() int64 {
	if m != nil {
		return m.Limit
	}
	return 0
}

type Response struct {
	Data                 []byte   `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Response) Reset()      { *m = Response{} }
func (*Response) ProtoMessage() {}
func (*Response) Descriptor() ([]byte, []int) {
	return fileDescriptor_example_663bc880cd358822, []int{5}
}
func (m *Response) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Response) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Response.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 *Response) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Response.Merge(dst, src)
}
func (m *Response) XXX_Size() int {
	return m.Size()
}
func (m *Response) XXX_DiscardUnknown() {
	xxx_messageInfo_Response.DiscardUnknown(m)
}

var xxx_messageInfo_Response proto.InternalMessageInfo

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

type ResponseList struct {
	Data [][]byte `protobuf:"bytes,1,rep,name=data" json:"data,omitempty"`
	//    repeated Example data = 1;
	Total                int64     `protobuf:"varint,2,opt,name=total,proto3" json:"total,omitempty"`
	PageInfo             *PageInfo `protobuf:"bytes,3,opt,name=page_info,json=pageInfo" json:"page_info,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

func (m *ResponseList) Reset()      { *m = ResponseList{} }
func (*ResponseList) ProtoMessage() {}
func (*ResponseList) Descriptor() ([]byte, []int) {
	return fileDescriptor_example_663bc880cd358822, []int{6}
}
func (m *ResponseList) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ResponseList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ResponseList.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 *ResponseList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ResponseList.Merge(dst, src)
}
func (m *ResponseList) XXX_Size() int {
	return m.Size()
}
func (m *ResponseList) XXX_DiscardUnknown() {
	xxx_messageInfo_ResponseList.DiscardUnknown(m)
}

var xxx_messageInfo_ResponseList proto.InternalMessageInfo

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

func (m *ResponseList) GetTotal() int64 {
	if m != nil {
		return m.Total
	}
	return 0
}

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

type Query struct {
	Id  string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Ids []string `protobuf:"bytes,2,rep,name=ids" json:"ids,omitempty"`
	// Types that are valid to be assigned to Params:
	//	*Query_Page
	//	*Query_First
	//	*Query_Last
	Params               isQuery_Params `protobuf_oneof:"params"`
	Limit                int64          `protobuf:"varint,6,opt,name=limit,proto3" json:"limit,omitempty"`
	Filter               []*Filtering   `protobuf:"bytes,7,rep,name=filter" json:"filter,omitempty"`
	Field                []string       `protobuf:"bytes,8,rep,name=field" json:"field,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

func (m *Query) Reset()      { *m = Query{} }
func (*Query) ProtoMessage() {}
func (*Query) Descriptor() ([]byte, []int) {
	return fileDescriptor_example_663bc880cd358822, []int{7}
}
func (m *Query) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Query) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Query.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 *Query) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Query.Merge(dst, src)
}
func (m *Query) XXX_Size() int {
	return m.Size()
}
func (m *Query) XXX_DiscardUnknown() {
	xxx_messageInfo_Query.DiscardUnknown(m)
}

var xxx_messageInfo_Query proto.InternalMessageInfo

type isQuery_Params interface {
	isQuery_Params()
	Equal(interface{}) bool
	MarshalTo([]byte) (int, error)
	Size() int
}

type Query_Page struct {
	Page int64 `protobuf:"varint,3,opt,name=page,proto3,oneof"`
}
type Query_First struct {
	First int64 `protobuf:"varint,4,opt,name=first,proto3,oneof"`
}
type Query_Last struct {
	Last int64 `protobuf:"varint,5,opt,name=last,proto3,oneof"`
}

func (*Query_Page) isQuery_Params()  {}
func (*Query_First) isQuery_Params() {}
func (*Query_Last) isQuery_Params()  {}

func (m *Query) GetParams() isQuery_Params {
	if m != nil {
		return m.Params
	}
	return nil
}

func (m *Query) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

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

func (m *Query) GetPage() int64 {
	if x, ok := m.GetParams().(*Query_Page); ok {
		return x.Page
	}
	return 0
}

func (m *Query) GetFirst() int64 {
	if x, ok := m.GetParams().(*Query_First); ok {
		return x.First
	}
	return 0
}

func (m *Query) GetLast() int64 {
	if x, ok := m.GetParams().(*Query_Last); ok {
		return x.Last
	}
	return 0
}

func (m *Query) GetLimit() int64 {
	if m != nil {
		return m.Limit
	}
	return 0
}

func (m *Query) GetFilter() []*Filtering {
	if m != nil {
		return m.Filter
	}
	return nil
}

func (m *Query) GetField() []string {
	if m != nil {
		return m.Field
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*Query) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _Query_OneofMarshaler, _Query_OneofUnmarshaler, _Query_OneofSizer, []interface{}{
		(*Query_Page)(nil),
		(*Query_First)(nil),
		(*Query_Last)(nil),
	}
}

func _Query_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*Query)
	// params
	switch x := m.Params.(type) {
	case *Query_Page:
		_ = b.EncodeVarint(3<<3 | proto.WireVarint)
		_ = b.EncodeVarint(uint64(x.Page))
	case *Query_First:
		_ = b.EncodeVarint(4<<3 | proto.WireVarint)
		_ = b.EncodeVarint(uint64(x.First))
	case *Query_Last:
		_ = b.EncodeVarint(5<<3 | proto.WireVarint)
		_ = b.EncodeVarint(uint64(x.Last))
	case nil:
	default:
		return fmt.Errorf("Query.Params has unexpected type %T", x)
	}
	return nil
}

func _Query_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*Query)
	switch tag {
	case 3: // params.page
		if wire != proto.WireVarint {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeVarint()
		m.Params = &Query_Page{int64(x)}
		return true, err
	case 4: // params.first
		if wire != proto.WireVarint {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeVarint()
		m.Params = &Query_First{int64(x)}
		return true, err
	case 5: // params.last
		if wire != proto.WireVarint {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeVarint()
		m.Params = &Query_Last{int64(x)}
		return true, err
	default:
		return false, nil
	}
}

func _Query_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*Query)
	// params
	switch x := m.Params.(type) {
	case *Query_Page:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(x.Page))
	case *Query_First:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(x.First))
	case *Query_Last:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(x.Last))
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

type MutationField struct {
	Name                 string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Value                string   `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *MutationField) Reset()      { *m = MutationField{} }
func (*MutationField) ProtoMessage() {}
func (*MutationField) Descriptor() ([]byte, []int) {
	return fileDescriptor_example_663bc880cd358822, []int{8}
}
func (m *MutationField) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MutationField) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MutationField.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 *MutationField) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MutationField.Merge(dst, src)
}
func (m *MutationField) XXX_Size() int {
	return m.Size()
}
func (m *MutationField) XXX_DiscardUnknown() {
	xxx_messageInfo_MutationField.DiscardUnknown(m)
}

var xxx_messageInfo_MutationField proto.InternalMessageInfo

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

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

type MutationResponse struct {
	Id                   int64    `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *MutationResponse) Reset()      { *m = MutationResponse{} }
func (*MutationResponse) ProtoMessage() {}
func (*MutationResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_example_663bc880cd358822, []int{9}
}
func (m *MutationResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MutationResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MutationResponse.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 *MutationResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MutationResponse.Merge(dst, src)
}
func (m *MutationResponse) XXX_Size() int {
	return m.Size()
}
func (m *MutationResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_MutationResponse.DiscardUnknown(m)
}

var xxx_messageInfo_MutationResponse proto.InternalMessageInfo

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

type Mutation struct {
	Id                   string           `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Fields               []*MutationField `protobuf:"bytes,8,rep,name=fields" json:"fields,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

func (m *Mutation) Reset()      { *m = Mutation{} }
func (*Mutation) ProtoMessage() {}
func (*Mutation) Descriptor() ([]byte, []int) {
	return fileDescriptor_example_663bc880cd358822, []int{10}
}
func (m *Mutation) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Mutation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Mutation.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 *Mutation) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Mutation.Merge(dst, src)
}
func (m *Mutation) XXX_Size() int {
	return m.Size()
}
func (m *Mutation) XXX_DiscardUnknown() {
	xxx_messageInfo_Mutation.DiscardUnknown(m)
}

var xxx_messageInfo_Mutation proto.InternalMessageInfo

func (m *Mutation) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *Mutation) GetFields() []*MutationField {
	if m != nil {
		return m.Fields
	}
	return nil
}

type ExampleItem struct {
	//    option (sql.opts).gorm = true;
	Id                   int64      `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty" db:"id"`
	CreatedAt            *time.Time `protobuf:"bytes,2,opt,name=created_at,json=createdAt,stdtime" json:"created_at,omitempty"`
	UpdatedAt            *time.Time `protobuf:"bytes,3,opt,name=updated_at,json=updatedAt,stdtime" json:"updated_at,omitempty"`
	DeletedAt            *time.Time `protobuf:"bytes,4,opt,name=deleted_at,json=deletedAt,stdtime" json:"deleted_at,omitempty" db:"deleted_at"`
	Name                 string     `protobuf:"bytes,5,opt,name=name,proto3" json:"name,omitempty"`
	Mess                 string     `protobuf:"bytes,6,opt,name=mess,proto3" json:"mess,omitempty"`
	MoveID               int64      `protobuf:"varint,7,opt,name=move_id,json=moveId,proto3" json:"move_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *ExampleItem) Reset()      { *m = ExampleItem{} }
func (*ExampleItem) ProtoMessage() {}
func (*ExampleItem) Descriptor() ([]byte, []int) {
	return fileDescriptor_example_663bc880cd358822, []int{11}
}
func (m *ExampleItem) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ExampleItem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ExampleItem.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 *ExampleItem) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ExampleItem.Merge(dst, src)
}
func (m *ExampleItem) XXX_Size() int {
	return m.Size()
}
func (m *ExampleItem) XXX_DiscardUnknown() {
	xxx_messageInfo_ExampleItem.DiscardUnknown(m)
}

var xxx_messageInfo_ExampleItem proto.InternalMessageInfo

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

func (m *ExampleItem) GetCreatedAt() *time.Time {
	if m != nil {
		return m.CreatedAt
	}
	return nil
}

func (m *ExampleItem) GetUpdatedAt() *time.Time {
	if m != nil {
		return m.UpdatedAt
	}
	return nil
}

func (m *ExampleItem) GetDeletedAt() *time.Time {
	if m != nil {
		return m.DeletedAt
	}
	return nil
}

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

func (m *ExampleItem) GetMess() string {
	if m != nil {
		return m.Mess
	}
	return ""
}

func (m *ExampleItem) GetMoveID() int64 {
	if m != nil {
		return m.MoveID
	}
	return 0
}

type Example struct {
	//    option (sql.opts).gorm = true;
	Id                   int64          `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty" db:"id"`
	CreatedAt            *time.Time     `protobuf:"bytes,2,opt,name=created_at,json=createdAt,stdtime" json:"created_at,omitempty"`
	UpdatedAt            *time.Time     `protobuf:"bytes,3,opt,name=updated_at,json=updatedAt,stdtime" json:"updated_at,omitempty"`
	DeletedAt            *time.Time     `protobuf:"bytes,4,opt,name=deleted_at,json=deletedAt,stdtime" json:"deleted_at,omitempty" db:"deleted_at"`
	Name                 string         `protobuf:"bytes,5,opt,name=name,proto3" json:"name,omitempty"`
	Mess                 string         `protobuf:"bytes,6,opt,name=mess,proto3" json:"mess,omitempty"`
	Product              string         `protobuf:"bytes,7,opt,name=product,proto3" json:"product,omitempty"`
	Organization         string         `protobuf:"bytes,8,opt,name=organization,proto3" json:"organization,omitempty"`
	State                string         `protobuf:"bytes,9,opt,name=state,proto3" json:"state,omitempty"`
	Items                []*ExampleItem `protobuf:"bytes,10,rep,name=items" json:"items,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

func (m *Example) Reset()      { *m = Example{} }
func (*Example) ProtoMessage() {}
func (*Example) Descriptor() ([]byte, []int) {
	return fileDescriptor_example_663bc880cd358822, []int{12}
}
func (m *Example) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Example) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Example.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 *Example) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Example.Merge(dst, src)
}
func (m *Example) XXX_Size() int {
	return m.Size()
}
func (m *Example) XXX_DiscardUnknown() {
	xxx_messageInfo_Example.DiscardUnknown(m)
}

var xxx_messageInfo_Example proto.InternalMessageInfo

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

func (m *Example) GetCreatedAt() *time.Time {
	if m != nil {
		return m.CreatedAt
	}
	return nil
}

func (m *Example) GetUpdatedAt() *time.Time {
	if m != nil {
		return m.UpdatedAt
	}
	return nil
}

func (m *Example) GetDeletedAt() *time.Time {
	if m != nil {
		return m.DeletedAt
	}
	return nil
}

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

func (m *Example) GetMess() string {
	if m != nil {
		return m.Mess
	}
	return ""
}

func (m *Example) GetProduct() string {
	if m != nil {
		return m.Product
	}
	return ""
}

func (m *Example) GetOrganization() string {
	if m != nil {
		return m.Organization
	}
	return ""
}

func (m *Example) GetState() string {
	if m != nil {
		return m.State
	}
	return ""
}

func (m *Example) GetItems() []*ExampleItem {
	if m != nil {
		return m.Items
	}
	return nil
}

func init() {
	proto.RegisterType((*Empty)(nil), "example.Empty")
	proto.RegisterType((*SortCriteria)(nil), "example.SortCriteria")
	proto.RegisterType((*Sorting)(nil), "example.Sorting")
	proto.RegisterType((*Filtering)(nil), "example.Filtering")
	proto.RegisterType((*PageInfo)(nil), "example.PageInfo")
	proto.RegisterType((*Response)(nil), "example.Response")
	proto.RegisterType((*ResponseList)(nil), "example.ResponseList")
	proto.RegisterType((*Query)(nil), "example.Query")
	proto.RegisterType((*MutationField)(nil), "example.MutationField")
	proto.RegisterType((*MutationResponse)(nil), "example.MutationResponse")
	proto.RegisterType((*Mutation)(nil), "example.Mutation")
	proto.RegisterType((*ExampleItem)(nil), "example.ExampleItem")
	proto.RegisterType((*Example)(nil), "example.Example")
	proto.RegisterEnum("example.SortCriteria_Order", SortCriteria_Order_name, SortCriteria_Order_value)
	proto.RegisterEnum("example.Filtering_Mode", Filtering_Mode_name, Filtering_Mode_value)
}
func (this *Empty) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Empty)
	if !ok {
		that2, ok := that.(Empty)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}
func (this *SortCriteria) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*SortCriteria)
	if !ok {
		that2, ok := that.(SortCriteria)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Tag != that1.Tag {
		return false
	}
	if this.Order != that1.Order {
		return false
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}
func (this *Sorting) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Sorting)
	if !ok {
		that2, ok := that.(Sorting)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Sort) != len(that1.Sort) {
		return false
	}
	for i := range this.Sort {
		if !this.Sort[i].Equal(that1.Sort[i]) {
			return false
		}
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}
func (this *Filtering) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Filtering)
	if !ok {
		that2, ok := that.(Filtering)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if this.Mode != that1.Mode {
		return false
	}
	if this.Value != that1.Value {
		return false
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}
func (this *PageInfo) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*PageInfo)
	if !ok {
		that2, ok := that.(PageInfo)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Current != that1.Current {
		return false
	}
	if this.Size_ != that1.Size_ {
		return false
	}
	if this.Offset != that1.Offset {
		return false
	}
	if this.Limit != that1.Limit {
		return false
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}
func (this *Response) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Response)
	if !ok {
		that2, ok := that.(Response)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !bytes.Equal(this.Data, that1.Data) {
		return false
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}
func (this *ResponseList) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ResponseList)
	if !ok {
		that2, ok := that.(ResponseList)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Data) != len(that1.Data) {
		return false
	}
	for i := range this.Data {
		if !bytes.Equal(this.Data[i], that1.Data[i]) {
			return false
		}
	}
	if this.Total != that1.Total {
		return false
	}
	if !this.PageInfo.Equal(that1.PageInfo) {
		return false
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}
func (this *Query) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Query)
	if !ok {
		that2, ok := that.(Query)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Id != that1.Id {
		return false
	}
	if len(this.Ids) != len(that1.Ids) {
		return false
	}
	for i := range this.Ids {
		if this.Ids[i] != that1.Ids[i] {
			return false
		}
	}
	if that1.Params == nil {
		if this.Params != nil {
			return false
		}
	} else if this.Params == nil {
		return false
	} else if !this.Params.Equal(that1.Params) {
		return false
	}
	if this.Limit != that1.Limit {
		return false
	}
	if len(this.Filter) != len(that1.Filter) {
		return false
	}
	for i := range this.Filter {
		if !this.Filter[i].Equal(that1.Filter[i]) {
			return false
		}
	}
	if len(this.Field) != len(that1.Field) {
		return false
	}
	for i := range this.Field {
		if this.Field[i] != that1.Field[i] {
			return false
		}
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}
func (this *Query_Page) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Query_Page)
	if !ok {
		that2, ok := that.(Query_Page)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Page != that1.Page {
		return false
	}
	return true
}
func (this *Query_First) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Query_First)
	if !ok {
		that2, ok := that.(Query_First)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.First != that1.First {
		return false
	}
	return true
}
func (this *Query_Last) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Query_Last)
	if !ok {
		that2, ok := that.(Query_Last)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Last != that1.Last {
		return false
	}
	return true
}
func (this *MutationField) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*MutationField)
	if !ok {
		that2, ok := that.(MutationField)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if this.Value != that1.Value {
		return false
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}
func (this *MutationResponse) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*MutationResponse)
	if !ok {
		that2, ok := that.(MutationResponse)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Id != that1.Id {
		return false
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}
func (this *Mutation) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Mutation)
	if !ok {
		that2, ok := that.(Mutation)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Id != that1.Id {
		return false
	}
	if len(this.Fields) != len(that1.Fields) {
		return false
	}
	for i := range this.Fields {
		if !this.Fields[i].Equal(that1.Fields[i]) {
			return false
		}
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}
func (this *ExampleItem) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ExampleItem)
	if !ok {
		that2, ok := that.(ExampleItem)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Id != that1.Id {
		return false
	}
	if that1.CreatedAt == nil {
		if this.CreatedAt != nil {
			return false
		}
	} else if !this.CreatedAt.Equal(*that1.CreatedAt) {
		return false
	}
	if that1.UpdatedAt == nil {
		if this.UpdatedAt != nil {
			return false
		}
	} else if !this.UpdatedAt.Equal(*that1.UpdatedAt) {
		return false
	}
	if that1.DeletedAt == nil {
		if this.DeletedAt != nil {
			return false
		}
	} else if !this.DeletedAt.Equal(*that1.DeletedAt) {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if this.Mess != that1.Mess {
		return false
	}
	if this.MoveID != that1.MoveID {
		return false
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}
func (this *Example) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Example)
	if !ok {
		that2, ok := that.(Example)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Id != that1.Id {
		return false
	}
	if that1.CreatedAt == nil {
		if this.CreatedAt != nil {
			return false
		}
	} else if !this.CreatedAt.Equal(*that1.CreatedAt) {
		return false
	}
	if that1.UpdatedAt == nil {
		if this.UpdatedAt != nil {
			return false
		}
	} else if !this.UpdatedAt.Equal(*that1.UpdatedAt) {
		return false
	}
	if that1.DeletedAt == nil {
		if this.DeletedAt != nil {
			return false
		}
	} else if !this.DeletedAt.Equal(*that1.DeletedAt) {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if this.Mess != that1.Mess {
		return false
	}
	if this.Product != that1.Product {
		return false
	}
	if this.Organization != that1.Organization {
		return false
	}
	if this.State != that1.State {
		return false
	}
	if len(this.Items) != len(that1.Items) {
		return false
	}
	for i := range this.Items {
		if !this.Items[i].Equal(that1.Items[i]) {
			return false
		}
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}
func (this *Empty) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 4)
	s = append(s, "&example.Empty{")
	if this.XXX_unrecognized != nil {
		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *SortCriteria) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&example.SortCriteria{")
	s = append(s, "Tag: "+fmt.Sprintf("%#v", this.Tag)+",\n")
	s = append(s, "Order: "+fmt.Sprintf("%#v", this.Order)+",\n")
	if this.XXX_unrecognized != nil {
		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Sorting) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&example.Sorting{")
	if this.Sort != nil {
		s = append(s, "Sort: "+fmt.Sprintf("%#v", this.Sort)+",\n")
	}
	if this.XXX_unrecognized != nil {
		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Filtering) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&example.Filtering{")
	s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
	s = append(s, "Mode: "+fmt.Sprintf("%#v", this.Mode)+",\n")
	s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n")
	if this.XXX_unrecognized != nil {
		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *PageInfo) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&example.PageInfo{")
	s = append(s, "Current: "+fmt.Sprintf("%#v", this.Current)+",\n")
	s = append(s, "Size_: "+fmt.Sprintf("%#v", this.Size_)+",\n")
	s = append(s, "Offset: "+fmt.Sprintf("%#v", this.Offset)+",\n")
	s = append(s, "Limit: "+fmt.Sprintf("%#v", this.Limit)+",\n")
	if this.XXX_unrecognized != nil {
		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Response) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&example.Response{")
	s = append(s, "Data: "+fmt.Sprintf("%#v", this.Data)+",\n")
	if this.XXX_unrecognized != nil {
		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *ResponseList) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&example.ResponseList{")
	s = append(s, "Data: "+fmt.Sprintf("%#v", this.Data)+",\n")
	s = append(s, "Total: "+fmt.Sprintf("%#v", this.Total)+",\n")
	if this.PageInfo != nil {
		s = append(s, "PageInfo: "+fmt.Sprintf("%#v", this.PageInfo)+",\n")
	}
	if this.XXX_unrecognized != nil {
		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Query) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 12)
	s = append(s, "&example.Query{")
	s = append(s, "Id: "+fmt.Sprintf("%#v", this.Id)+",\n")
	s = append(s, "Ids: "+fmt.Sprintf("%#v", this.Ids)+",\n")
	if this.Params != nil {
		s = append(s, "Params: "+fmt.Sprintf("%#v", this.Params)+",\n")
	}
	s = append(s, "Limit: "+fmt.Sprintf("%#v", this.Limit)+",\n")
	if this.Filter != nil {
		s = append(s, "Filter: "+fmt.Sprintf("%#v", this.Filter)+",\n")
	}
	s = append(s, "Field: "+fmt.Sprintf("%#v", this.Field)+",\n")
	if this.XXX_unrecognized != nil {
		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Query_Page) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&example.Query_Page{` +
		`Page:` + fmt.Sprintf("%#v", this.Page) + `}`}, ", ")
	return s
}
func (this *Query_First) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&example.Query_First{` +
		`First:` + fmt.Sprintf("%#v", this.First) + `}`}, ", ")
	return s
}
func (this *Query_Last) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&example.Query_Last{` +
		`Last:` + fmt.Sprintf("%#v", this.Last) + `}`}, ", ")
	return s
}
func (this *MutationField) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&example.MutationField{")
	s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
	s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n")
	if this.XXX_unrecognized != nil {
		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *MutationResponse) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&example.MutationResponse{")
	s = append(s, "Id: "+fmt.Sprintf("%#v", this.Id)+",\n")
	if this.XXX_unrecognized != nil {
		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Mutation) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&example.Mutation{")
	s = append(s, "Id: "+fmt.Sprintf("%#v", this.Id)+",\n")
	if this.Fields != nil {
		s = append(s, "Fields: "+fmt.Sprintf("%#v", this.Fields)+",\n")
	}
	if this.XXX_unrecognized != nil {
		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *ExampleItem) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 11)
	s = append(s, "&example.ExampleItem{")
	s = append(s, "Id: "+fmt.Sprintf("%#v", this.Id)+",\n")
	s = append(s, "CreatedAt: "+fmt.Sprintf("%#v", this.CreatedAt)+",\n")
	s = append(s, "UpdatedAt: "+fmt.Sprintf("%#v", this.UpdatedAt)+",\n")
	s = append(s, "DeletedAt: "+fmt.Sprintf("%#v", this.DeletedAt)+",\n")
	s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
	s = append(s, "Mess: "+fmt.Sprintf("%#v", this.Mess)+",\n")
	s = append(s, "MoveID: "+fmt.Sprintf("%#v", this.MoveID)+",\n")
	if this.XXX_unrecognized != nil {
		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Example) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 14)
	s = append(s, "&example.Example{")
	s = append(s, "Id: "+fmt.Sprintf("%#v", this.Id)+",\n")
	s = append(s, "CreatedAt: "+fmt.Sprintf("%#v", this.CreatedAt)+",\n")
	s = append(s, "UpdatedAt: "+fmt.Sprintf("%#v", this.UpdatedAt)+",\n")
	s = append(s, "DeletedAt: "+fmt.Sprintf("%#v", this.DeletedAt)+",\n")
	s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
	s = append(s, "Mess: "+fmt.Sprintf("%#v", this.Mess)+",\n")
	s = append(s, "Product: "+fmt.Sprintf("%#v", this.Product)+",\n")
	s = append(s, "Organization: "+fmt.Sprintf("%#v", this.Organization)+",\n")
	s = append(s, "State: "+fmt.Sprintf("%#v", this.State)+",\n")
	if this.Items != nil {
		s = append(s, "Items: "+fmt.Sprintf("%#v", this.Items)+",\n")
	}
	if this.XXX_unrecognized != nil {
		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func valueToGoStringExample(v interface{}, typ string) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv)
}

// 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 {
	Read(ctx context.Context, in *Query, opts ...grpc.CallOption) (*Response, error)
	List(ctx context.Context, in *Query, opts ...grpc.CallOption) (*ResponseList, error)
	Create(ctx context.Context, in *Mutation, opts ...grpc.CallOption) (*MutationResponse, error)
	Update(ctx context.Context, in *Mutation, opts ...grpc.CallOption) (*Empty, error)
}

type exampleServiceClient struct {
	cc *grpc.ClientConn
}

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

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

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

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

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

// ExampleServiceServer is the server API for ExampleService service.
type ExampleServiceServer interface {
	Read(context.Context, *Query) (*Response, error)
	List(context.Context, *Query) (*ResponseList, error)
	Create(context.Context, *Mutation) (*MutationResponse, error)
	Update(context.Context, *Mutation) (*Empty, error)
}

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

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

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

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

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

var _ExampleService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "example.ExampleService",
	HandlerType: (*ExampleServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Read",
			Handler:    _ExampleService_Read_Handler,
		},
		{
			MethodName: "List",
			Handler:    _ExampleService_List_Handler,
		},
		{
			MethodName: "Create",
			Handler:    _ExampleService_Create_Handler,
		},
		{
			MethodName: "Update",
			Handler:    _ExampleService_Update_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "example/example.proto",
}

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

func (m *Empty) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *SortCriteria) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Tag) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintExample(dAtA, i, uint64(len(m.Tag)))
		i += copy(dAtA[i:], m.Tag)
	}
	if m.Order != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintExample(dAtA, i, uint64(m.Order))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *Sorting) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Sort) > 0 {
		for _, msg := range m.Sort {
			dAtA[i] = 0xa
			i++
			i = encodeVarintExample(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *Filtering) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Name) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintExample(dAtA, i, uint64(len(m.Name)))
		i += copy(dAtA[i:], m.Name)
	}
	if m.Mode != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintExample(dAtA, i, uint64(m.Mode))
	}
	if len(m.Value) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintExample(dAtA, i, uint64(len(m.Value)))
		i += copy(dAtA[i:], m.Value)
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *PageInfo) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Current != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintExample(dAtA, i, uint64(m.Current))
	}
	if m.Size_ != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintExample(dAtA, i, uint64(m.Size_))
	}
	if m.Offset != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintExample(dAtA, i, uint64(m.Offset))
	}
	if m.Limit != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintExample(dAtA, i, uint64(m.Limit))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *Response) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Data) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintExample(dAtA, i, uint64(len(m.Data)))
		i += copy(dAtA[i:], m.Data)
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *ResponseList) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Data) > 0 {
		for _, b := range m.Data {
			dAtA[i] = 0xa
			i++
			i = encodeVarintExample(dAtA, i, uint64(len(b)))
			i += copy(dAtA[i:], b)
		}
	}
	if m.Total != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintExample(dAtA, i, uint64(m.Total))
	}
	if m.PageInfo != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintExample(dAtA, i, uint64(m.PageInfo.Size()))
		n1, err := m.PageInfo.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n1
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *Query) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Id) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintExample(dAtA, i, uint64(len(m.Id)))
		i += copy(dAtA[i:], m.Id)
	}
	if len(m.Ids) > 0 {
		for _, s := range m.Ids {
			dAtA[i] = 0x12
			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.Params != nil {
		nn2, err := m.Params.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += nn2
	}
	if m.Limit != 0 {
		dAtA[i] = 0x30
		i++
		i = encodeVarintExample(dAtA, i, uint64(m.Limit))
	}
	if len(m.Filter) > 0 {
		for _, msg := range m.Filter {
			dAtA[i] = 0x3a
			i++
			i = encodeVarintExample(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if len(m.Field) > 0 {
		for _, s := range m.Field {
			dAtA[i] = 0x42
			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.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *Query_Page) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	dAtA[i] = 0x18
	i++
	i = encodeVarintExample(dAtA, i, uint64(m.Page))
	return i, nil
}
func (m *Query_First) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	dAtA[i] = 0x20
	i++
	i = encodeVarintExample(dAtA, i, uint64(m.First))
	return i, nil
}
func (m *Query_Last) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	dAtA[i] = 0x28
	i++
	i = encodeVarintExample(dAtA, i, uint64(m.Last))
	return i, nil
}
func (m *MutationField) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MutationField) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Name) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintExample(dAtA, i, uint64(len(m.Name)))
		i += copy(dAtA[i:], m.Name)
	}
	if len(m.Value) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintExample(dAtA, i, uint64(len(m.Value)))
		i += copy(dAtA[i:], m.Value)
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *MutationResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Id != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintExample(dAtA, i, uint64(m.Id))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *Mutation) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Id) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintExample(dAtA, i, uint64(len(m.Id)))
		i += copy(dAtA[i:], m.Id)
	}
	if len(m.Fields) > 0 {
		for _, msg := range m.Fields {
			dAtA[i] = 0x42
			i++
			i = encodeVarintExample(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *ExampleItem) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Id != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintExample(dAtA, i, uint64(m.Id))
	}
	if m.CreatedAt != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintExample(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(*m.CreatedAt)))
		n3, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.CreatedAt, dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n3
	}
	if m.UpdatedAt != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintExample(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(*m.UpdatedAt)))
		n4, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.UpdatedAt, dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n4
	}
	if m.DeletedAt != nil {
		dAtA[i] = 0x22
		i++
		i = encodeVarintExample(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(*m.DeletedAt)))
		n5, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.DeletedAt, dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n5
	}
	if len(m.Name) > 0 {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintExample(dAtA, i, uint64(len(m.Name)))
		i += copy(dAtA[i:], m.Name)
	}
	if len(m.Mess) > 0 {
		dAtA[i] = 0x32
		i++
		i = encodeVarintExample(dAtA, i, uint64(len(m.Mess)))
		i += copy(dAtA[i:], m.Mess)
	}
	if m.MoveID != 0 {
		dAtA[i] = 0x38
		i++
		i = encodeVarintExample(dAtA, i, uint64(m.MoveID))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *Example) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Id != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintExample(dAtA, i, uint64(m.Id))
	}
	if m.CreatedAt != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintExample(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(*m.CreatedAt)))
		n6, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.CreatedAt, dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n6
	}
	if m.UpdatedAt != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintExample(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(*m.UpdatedAt)))
		n7, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.UpdatedAt, dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n7
	}
	if m.DeletedAt != nil {
		dAtA[i] = 0x22
		i++
		i = encodeVarintExample(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(*m.DeletedAt)))
		n8, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.DeletedAt, dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n8
	}
	if len(m.Name) > 0 {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintExample(dAtA, i, uint64(len(m.Name)))
		i += copy(dAtA[i:], m.Name)
	}
	if len(m.Mess) > 0 {
		dAtA[i] = 0x32
		i++
		i = encodeVarintExample(dAtA, i, uint64(len(m.Mess)))
		i += copy(dAtA[i:], m.Mess)
	}
	if len(m.Product) > 0 {
		dAtA[i] = 0x3a
		i++
		i = encodeVarintExample(dAtA, i, uint64(len(m.Product)))
		i += copy(dAtA[i:], m.Product)
	}
	if len(m.Organization) > 0 {
		dAtA[i] = 0x42
		i++
		i = encodeVarintExample(dAtA, i, uint64(len(m.Organization)))
		i += copy(dAtA[i:], m.Organization)
	}
	if len(m.State) > 0 {
		dAtA[i] = 0x4a
		i++
		i = encodeVarintExample(dAtA, i, uint64(len(m.State)))
		i += copy(dAtA[i:], m.State)
	}
	if len(m.Items) > 0 {
		for _, msg := range m.Items {
			dAtA[i] = 0x52
			i++
			i = encodeVarintExample(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func encodeVarintExample(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 NewPopulatedEmpty(r randyExample, easy bool) *Empty {
	this := &Empty{}
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedExample(r, 1)
	}
	return this
}

func NewPopulatedSortCriteria(r randyExample, easy bool) *SortCriteria {
	this := &SortCriteria{}
	this.Tag = string(randStringExample(r))
	this.Order = SortCriteria_Order([]int32{0, 1}[r.Intn(2)])
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedExample(r, 3)
	}
	return this
}

func NewPopulatedSorting(r randyExample, easy bool) *Sorting {
	this := &Sorting{}
	if r.Intn(10) != 0 {
		v1 := r.Intn(5)
		this.Sort = make([]*SortCriteria, v1)
		for i := 0; i < v1; i++ {
			this.Sort[i] = NewPopulatedSortCriteria(r, easy)
		}
	}
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedExample(r, 2)
	}
	return this
}

func NewPopulatedFiltering(r randyExample, easy bool) *Filtering {
	this := &Filtering{}
	this.Name = string(randStringExample(r))
	this.Mode = Filtering_Mode([]int32{0, 1, 2, 3, 4, 5, 6, 7}[r.Intn(8)])
	this.Value = string(randStringExample(r))
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedExample(r, 4)
	}
	return this
}

func NewPopulatedPageInfo(r randyExample, easy bool) *PageInfo {
	this := &PageInfo{}
	this.Current = int64(r.Int63())
	if r.Intn(2) == 0 {
		this.Current *= -1
	}
	this.Size_ = int64(r.Int63())
	if r.Intn(2) == 0 {
		this.Size_ *= -1
	}
	this.Offset = int64(r.Int63())
	if r.Intn(2) == 0 {
		this.Offset *= -1
	}
	this.Limit = int64(r.Int63())
	if r.Intn(2) == 0 {
		this.Limit *= -1
	}
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedExample(r, 5)
	}
	return this
}

func NewPopulatedResponse(r randyExample, easy bool) *Response {
	this := &Response{}
	v2 := r.Intn(100)
	this.Data = make([]byte, v2)
	for i := 0; i < v2; i++ {
		this.Data[i] = byte(r.Intn(256))
	}
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedExample(r, 2)
	}
	return this
}

func NewPopulatedResponseList(r randyExample, easy bool) *ResponseList {
	this := &ResponseList{}
	v3 := r.Intn(10)
	this.Data = make([][]byte, v3)
	for i := 0; i < v3; i++ {
		v4 := r.Intn(100)
		this.Data[i] = make([]byte, v4)
		for j := 0; j < v4; j++ {
			this.Data[i][j] = byte(r.Intn(256))
		}
	}
	this.Total = int64(r.Int63())
	if r.Intn(2) == 0 {
		this.Total *= -1
	}
	if r.Intn(10) != 0 {
		this.PageInfo = NewPopulatedPageInfo(r, easy)
	}
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedExample(r, 4)
	}
	return this
}

func NewPopulatedQuery(r randyExample, easy bool) *Query {
	this := &Query{}
	this.Id = string(randStringExample(r))
	v5 := r.Intn(10)
	this.Ids = make([]string, v5)
	for i := 0; i < v5; i++ {
		this.Ids[i] = string(randStringExample(r))
	}
	oneofNumber_Params := []int32{3, 4, 5}[r.Intn(3)]
	switch oneofNumber_Params {
	case 3:
		this.Params = NewPopulatedQuery_Page(r, easy)
	case 4:
		this.Params = NewPopulatedQuery_First(r, easy)
	case 5:
		this.Params = NewPopulatedQuery_Last(r, easy)
	}
	this.Limit = int64(r.Int63())
	if r.Intn(2) == 0 {
		this.Limit *= -1
	}
	if r.Intn(10) != 0 {
		v6 := r.Intn(5)
		this.Filter = make([]*Filtering, v6)
		for i := 0; i < v6; i++ {
			this.Filter[i] = NewPopulatedFiltering(r, easy)
		}
	}
	v7 := r.Intn(10)
	this.Field = make([]string, v7)
	for i := 0; i < v7; i++ {
		this.Field[i] = string(randStringExample(r))
	}
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedExample(r, 9)
	}
	return this
}

func NewPopulatedQuery_Page(r randyExample, easy bool) *Query_Page {
	this := &Query_Page{}
	this.Page = int64(r.Int63())
	if r.Intn(2) == 0 {
		this.Page *= -1
	}
	return this
}
func NewPopulatedQuery_First(r randyExample, easy bool) *Query_First {
	this := &Query_First{}
	this.First = int64(r.Int63())
	if r.Intn(2) == 0 {
		this.First *= -1
	}
	return this
}
func NewPopulatedQuery_Last(r randyExample, easy bool) *Query_Last {
	this := &Query_Last{}
	this.Last = int64(r.Int63())
	if r.Intn(2) == 0 {
		this.Last *= -1
	}
	return this
}
func NewPopulatedMutationField(r randyExample, easy bool) *MutationField {
	this := &MutationField{}
	this.Name = string(randStringExample(r))
	this.Value = string(randStringExample(r))
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedExample(r, 3)
	}
	return this
}

func NewPopulatedMutationResponse(r randyExample, easy bool) *MutationResponse {
	this := &MutationResponse{}
	this.Id = int64(r.Int63())
	if r.Intn(2) == 0 {
		this.Id *= -1
	}
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedExample(r, 2)
	}
	return this
}

func NewPopulatedMutation(r randyExample, easy bool) *Mutation {
	this := &Mutation{}
	this.Id = string(randStringExample(r))
	if r.Intn(10) != 0 {
		v8 := r.Intn(5)
		this.Fields = make([]*MutationField, v8)
		for i := 0; i < v8; i++ {
			this.Fields[i] = NewPopulatedMutationField(r, easy)
		}
	}
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedExample(r, 9)
	}
	return this
}

func NewPopulatedExampleItem(r randyExample, easy bool) *ExampleItem {
	this := &ExampleItem{}
	this.Id = int64(r.Int63())
	if r.Intn(2) == 0 {
		this.Id *= -1
	}
	if r.Intn(10) != 0 {
		this.CreatedAt = github_com_gogo_protobuf_types.NewPopulatedStdTime(r, easy)
	}
	if r.Intn(10) != 0 {
		this.UpdatedAt = github_com_gogo_protobuf_types.NewPopulatedStdTime(r, easy)
	}
	if r.Intn(10) != 0 {
		this.DeletedAt = github_com_gogo_protobuf_types.NewPopulatedStdTime(r, easy)
	}
	this.Name = string(randStringExample(r))
	this.Mess = string(randStringExample(r))
	this.MoveID = int64(r.Int63())
	if r.Intn(2) == 0 {
		this.MoveID *= -1
	}
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedExample(r, 8)
	}
	return this
}

func NewPopulatedExample(r randyExample, easy bool) *Example {
	this := &Example{}
	this.Id = int64(r.Int63())
	if r.Intn(2) == 0 {
		this.Id *= -1
	}
	if r.Intn(10) != 0 {
		this.CreatedAt = github_com_gogo_protobuf_types.NewPopulatedStdTime(r, easy)
	}
	if r.Intn(10) != 0 {
		this.UpdatedAt = github_com_gogo_protobuf_types.NewPopulatedStdTime(r, easy)
	}
	if r.Intn(10) != 0 {
		this.DeletedAt = github_com_gogo_protobuf_types.NewPopulatedStdTime(r, easy)
	}
	this.Name = string(randStringExample(r))
	this.Mess = string(randStringExample(r))
	this.Product = string(randStringExample(r))
	this.Organization = string(randStringExample(r))
	this.State = string(randStringExample(r))
	if r.Intn(10) != 0 {
		v9 := r.Intn(5)
		this.Items = make([]*ExampleItem, v9)
		for i := 0; i < v9; i++ {
			this.Items[i] = NewPopulatedExampleItem(r, easy)
		}
	}
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedExample(r, 11)
	}
	return this
}

type randyExample interface {
	Float32() float32
	Float64() float64
	Int63() int64
	Int31() int32
	Uint32() uint32
	Intn(n int) int
}

func randUTF8RuneExample(r randyExample) rune {
	ru := r.Intn(62)
	if ru < 10 {
		return rune(ru + 48)
	} else if ru < 36 {
		return rune(ru + 55)
	}
	return rune(ru + 61)
}
func randStringExample(r randyExample) string {
	v10 := r.Intn(100)
	tmps := make([]rune, v10)
	for i := 0; i < v10; i++ {
		tmps[i] = randUTF8RuneExample(r)
	}
	return string(tmps)
}
func randUnrecognizedExample(r randyExample, maxFieldNumber int) (dAtA []byte) {
	l := r.Intn(5)
	for i := 0; i < l; i++ {
		wire := r.Intn(4)
		if wire == 3 {
			wire = 5
		}
		fieldNumber := maxFieldNumber + r.Intn(100)
		dAtA = randFieldExample(dAtA, r, fieldNumber, wire)
	}
	return dAtA
}
func randFieldExample(dAtA []byte, r randyExample, fieldNumber int, wire int) []byte {
	key := uint32(fieldNumber)<<3 | uint32(wire)
	switch wire {
	case 0:
		dAtA = encodeVarintPopulateExample(dAtA, uint64(key))
		v11 := r.Int63()
		if r.Intn(2) == 0 {
			v11 *= -1
		}
		dAtA = encodeVarintPopulateExample(dAtA, uint64(v11))
	case 1:
		dAtA = encodeVarintPopulateExample(dAtA, uint64(key))
		dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
	case 2:
		dAtA = encodeVarintPopulateExample(dAtA, uint64(key))
		ll := r.Intn(100)
		dAtA = encodeVarintPopulateExample(dAtA, uint64(ll))
		for j := 0; j < ll; j++ {
			dAtA = append(dAtA, byte(r.Intn(256)))
		}
	default:
		dAtA = encodeVarintPopulateExample(dAtA, uint64(key))
		dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
	}
	return dAtA
}
func encodeVarintPopulateExample(dAtA []byte, v uint64) []byte {
	for v >= 1<<7 {
		dAtA = append(dAtA, uint8(uint64(v)&0x7f|0x80))
		v >>= 7
	}
	dAtA = append(dAtA, uint8(v))
	return dAtA
}
func (m *Empty) Size() (n int) {
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *SortCriteria) Size() (n int) {
	var l int
	_ = l
	l = len(m.Tag)
	if l > 0 {
		n += 1 + l + sovExample(uint64(l))
	}
	if m.Order != 0 {
		n += 1 + sovExample(uint64(m.Order))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Sorting) Size() (n int) {
	var l int
	_ = l
	if len(m.Sort) > 0 {
		for _, e := range m.Sort {
			l = e.Size()
			n += 1 + l + sovExample(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Filtering) Size() (n int) {
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovExample(uint64(l))
	}
	if m.Mode != 0 {
		n += 1 + sovExample(uint64(m.Mode))
	}
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovExample(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *PageInfo) Size() (n int) {
	var l int
	_ = l
	if m.Current != 0 {
		n += 1 + sovExample(uint64(m.Current))
	}
	if m.Size_ != 0 {
		n += 1 + sovExample(uint64(m.Size_))
	}
	if m.Offset != 0 {
		n += 1 + sovExample(uint64(m.Offset))
	}
	if m.Limit != 0 {
		n += 1 + sovExample(uint64(m.Limit))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Response) Size() (n int) {
	var l int
	_ = l
	l = len(m.Data)
	if l > 0 {
		n += 1 + l + sovExample(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ResponseList) Size() (n int) {
	var l int
	_ = l
	if len(m.Data) > 0 {
		for _, b := range m.Data {
			l = len(b)
			n += 1 + l + sovExample(uint64(l))
		}
	}
	if m.Total != 0 {
		n += 1 + sovExample(uint64(m.Total))
	}
	if m.PageInfo != nil {
		l = m.PageInfo.Size()
		n += 1 + l + sovExample(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Query) Size() (n int) {
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovExample(uint64(l))
	}
	if len(m.Ids) > 0 {
		for _, s := range m.Ids {
			l = len(s)
			n += 1 + l + sovExample(uint64(l))
		}
	}
	if m.Params != nil {
		n += m.Params.Size()
	}
	if m.Limit != 0 {
		n += 1 + sovExample(uint64(m.Limit))
	}
	if len(m.Filter) > 0 {
		for _, e := range m.Filter {
			l = e.Size()
			n += 1 + l + sovExample(uint64(l))
		}
	}
	if len(m.Field) > 0 {
		for _, s := range m.Field {
			l = len(s)
			n += 1 + l + sovExample(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Query_Page) Size() (n int) {
	var l int
	_ = l
	n += 1 + sovExample(uint64(m.Page))
	return n
}
func (m *Query_First) Size() (n int) {
	var l int
	_ = l
	n += 1 + sovExample(uint64(m.First))
	return n
}
func (m *Query_Last) Size() (n int) {
	var l int
	_ = l
	n += 1 + sovExample(uint64(m.Last))
	return n
}
func (m *MutationField) Size() (n int) {
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovExample(uint64(l))
	}
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovExample(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *MutationResponse) Size() (n int) {
	var l int
	_ = l
	if m.Id != 0 {
		n += 1 + sovExample(uint64(m.Id))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Mutation) Size() (n int) {
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovExample(uint64(l))
	}
	if len(m.Fields) > 0 {
		for _, e := range m.Fields {
			l = e.Size()
			n += 1 + l + sovExample(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ExampleItem) Size() (n int) {
	var l int
	_ = l
	if m.Id != 0 {
		n += 1 + sovExample(uint64(m.Id))
	}
	if m.CreatedAt != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.CreatedAt)
		n += 1 + l + sovExample(uint64(l))
	}
	if m.UpdatedAt != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.UpdatedAt)
		n += 1 + l + sovExample(uint64(l))
	}
	if m.DeletedAt != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.DeletedAt)
		n += 1 + l + sovExample(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovExample(uint64(l))
	}
	l = len(m.Mess)
	if l > 0 {
		n += 1 + l + sovExample(uint64(l))
	}
	if m.MoveID != 0 {
		n += 1 + sovExample(uint64(m.MoveID))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Example) Size() (n int) {
	var l int
	_ = l
	if m.Id != 0 {
		n += 1 + sovExample(uint64(m.Id))
	}
	if m.CreatedAt != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.CreatedAt)
		n += 1 + l + sovExample(uint64(l))
	}
	if m.UpdatedAt != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.UpdatedAt)
		n += 1 + l + sovExample(uint64(l))
	}
	if m.DeletedAt != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.DeletedAt)
		n += 1 + l + sovExample(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovExample(uint64(l))
	}
	l = len(m.Mess)
	if l > 0 {
		n += 1 + l + sovExample(uint64(l))
	}
	l = len(m.Product)
	if l > 0 {
		n += 1 + l + sovExample(uint64(l))
	}
	l = len(m.Organization)
	if l > 0 {
		n += 1 + l + sovExample(uint64(l))
	}
	l = len(m.State)
	if l > 0 {
		n += 1 + l + sovExample(uint64(l))
	}
	if len(m.Items) > 0 {
		for _, e := range m.Items {
			l = e.Size()
			n += 1 + l + sovExample(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func sovExample(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozExample(x uint64) (n int) {
	return sovExample(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *Empty) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Empty{`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *SortCriteria) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&SortCriteria{`,
		`Tag:` + fmt.Sprintf("%v", this.Tag) + `,`,
		`Order:` + fmt.Sprintf("%v", this.Order) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Sorting) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Sorting{`,
		`Sort:` + strings.Replace(fmt.Sprintf("%v", this.Sort), "SortCriteria", "SortCriteria", 1) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Filtering) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Filtering{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`Mode:` + fmt.Sprintf("%v", this.Mode) + `,`,
		`Value:` + fmt.Sprintf("%v", this.Value) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *PageInfo) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&PageInfo{`,
		`Current:` + fmt.Sprintf("%v", this.Current) + `,`,
		`Size_:` + fmt.Sprintf("%v", this.Size_) + `,`,
		`Offset:` + fmt.Sprintf("%v", this.Offset) + `,`,
		`Limit:` + fmt.Sprintf("%v", this.Limit) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Response) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Response{`,
		`Data:` + fmt.Sprintf("%v", this.Data) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ResponseList) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ResponseList{`,
		`Data:` + fmt.Sprintf("%v", this.Data) + `,`,
		`Total:` + fmt.Sprintf("%v", this.Total) + `,`,
		`PageInfo:` + strings.Replace(fmt.Sprintf("%v", this.PageInfo), "PageInfo", "PageInfo", 1) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Query) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Query{`,
		`Id:` + fmt.Sprintf("%v", this.Id) + `,`,
		`Ids:` + fmt.Sprintf("%v", this.Ids) + `,`,
		`Params:` + fmt.Sprintf("%v", this.Params) + `,`,
		`Limit:` + fmt.Sprintf("%v", this.Limit) + `,`,
		`Filter:` + strings.Replace(fmt.Sprintf("%v", this.Filter), "Filtering", "Filtering", 1) + `,`,
		`Field:` + fmt.Sprintf("%v", this.Field) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Query_Page) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Query_Page{`,
		`Page:` + fmt.Sprintf("%v", this.Page) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Query_First) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Query_First{`,
		`First:` + fmt.Sprintf("%v", this.First) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Query_Last) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Query_Last{`,
		`Last:` + fmt.Sprintf("%v", this.Last) + `,`,
		`}`,
	}, "")
	return s
}
func (this *MutationField) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&MutationField{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`Value:` + fmt.Sprintf("%v", this.Value) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *MutationResponse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&MutationResponse{`,
		`Id:` + fmt.Sprintf("%v", this.Id) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Mutation) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Mutation{`,
		`Id:` + fmt.Sprintf("%v", this.Id) + `,`,
		`Fields:` + strings.Replace(fmt.Sprintf("%v", this.Fields), "MutationField", "MutationField", 1) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ExampleItem) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ExampleItem{`,
		`Id:` + fmt.Sprintf("%v", this.Id) + `,`,
		`CreatedAt:` + strings.Replace(fmt.Sprintf("%v", this.CreatedAt), "Timestamp", "types.Timestamp", 1) + `,`,
		`UpdatedAt:` + strings.Replace(fmt.Sprintf("%v", this.UpdatedAt), "Timestamp", "types.Timestamp", 1) + `,`,
		`DeletedAt:` + strings.Replace(fmt.Sprintf("%v", this.DeletedAt), "Timestamp", "types.Timestamp", 1) + `,`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`Mess:` + fmt.Sprintf("%v", this.Mess) + `,`,
		`MoveID:` + fmt.Sprintf("%v", this.MoveID) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Example) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Example{`,
		`Id:` + fmt.Sprintf("%v", this.Id) + `,`,
		`CreatedAt:` + strings.Replace(fmt.Sprintf("%v", this.CreatedAt), "Timestamp", "types.Timestamp", 1) + `,`,
		`UpdatedAt:` + strings.Replace(fmt.Sprintf("%v", this.UpdatedAt), "Timestamp", "types.Timestamp", 1) + `,`,
		`DeletedAt:` + strings.Replace(fmt.Sprintf("%v", this.DeletedAt), "Timestamp", "types.Timestamp", 1) + `,`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`Mess:` + fmt.Sprintf("%v", this.Mess) + `,`,
		`Product:` + fmt.Sprintf("%v", this.Product) + `,`,
		`Organization:` + fmt.Sprintf("%v", this.Organization) + `,`,
		`State:` + fmt.Sprintf("%v", this.State) + `,`,
		`Items:` + strings.Replace(fmt.Sprintf("%v", this.Items), "ExampleItem", "ExampleItem", 1) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func valueToStringExample(v interface{}) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("*%v", pv)
}
func (m *Empty) 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 ErrIntOverflowExample
			}
			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: Empty: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Empty: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipExample(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthExample
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SortCriteria) 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 ErrIntOverflowExample
			}
			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: SortCriteria: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SortCriteria: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tag", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExample
				}
				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 ErrInvalidLengthExample
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Tag = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Order", wireType)
			}
			m.Order = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExample
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Order |= (SortCriteria_Order(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipExample(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthExample
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Sorting) 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 ErrIntOverflowExample
			}
			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: Sorting: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Sorting: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sort", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExample
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExample
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sort = append(m.Sort, &SortCriteria{})
			if err := m.Sort[len(m.Sort)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipExample(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthExample
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Filtering) 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 ErrIntOverflowExample
			}
			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: Filtering: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Filtering: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 ErrIntOverflowExample
				}
				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 ErrInvalidLengthExample
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mode", wireType)
			}
			m.Mode = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExample
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Mode |= (Filtering_Mode(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExample
				}
				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 ErrInvalidLengthExample
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Value = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipExample(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthExample
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PageInfo) 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 ErrIntOverflowExample
			}
			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: PageInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PageInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Current", wireType)
			}
			m.Current = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExample
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Current |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Size_", wireType)
			}
			m.Size_ = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExample
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Size_ |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Offset", wireType)
			}
			m.Offset = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExample
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Offset |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType)
			}
			m.Limit = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExample
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Limit |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipExample(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthExample
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Response) 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 ErrIntOverflowExample
			}
			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: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExample
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthExample
			}
			postIndex := iNdEx + byteLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...)
			if m.Data == nil {
				m.Data = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipExample(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthExample
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ResponseList) 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 ErrIntOverflowExample
			}
			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: ResponseList: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ResponseList: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExample
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthExample
			}
			postIndex := iNdEx + byteLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Data = append(m.Data, make([]byte, postIndex-iNdEx))
			copy(m.Data[len(m.Data)-1], dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Total", wireType)
			}
			m.Total = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExample
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Total |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PageInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExample
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExample
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.PageInfo == nil {
				m.PageInfo = &PageInfo{}
			}
			if err := m.PageInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipExample(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthExample
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Query) 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 ErrIntOverflowExample
			}
			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: Query: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Query: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExample
				}
				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 ErrInvalidLengthExample
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Id = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ids", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExample
				}
				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 ErrInvalidLengthExample
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Ids = append(m.Ids, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Page", wireType)
			}
			var v int64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExample
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Params = &Query_Page{v}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field First", wireType)
			}
			var v int64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExample
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Params = &Query_First{v}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Last", wireType)
			}
			var v int64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExample
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Params = &Query_Last{v}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType)
			}
			m.Limit = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExample
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Limit |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Filter", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExample
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExample
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Filter = append(m.Filter, &Filtering{})
			if err := m.Filter[len(m.Filter)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Field", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExample
				}
				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 ErrInvalidLengthExample
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Field = append(m.Field, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipExample(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthExample
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MutationField) 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 ErrIntOverflowExample
			}
			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: MutationField: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MutationField: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 ErrIntOverflowExample
				}
				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 ErrInvalidLengthExample
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExample
				}
				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 ErrInvalidLengthExample
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Value = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipExample(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthExample
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MutationResponse) 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 ErrIntOverflowExample
			}
			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: MutationResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MutationResponse: 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 ErrIntOverflowExample
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Id |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipExample(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthExample
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Mutation) 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 ErrIntOverflowExample
			}
			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: Mutation: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Mutation: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExample
				}
				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 ErrInvalidLengthExample
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Id = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Fields", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExample
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExample
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Fields = append(m.Fields, &MutationField{})
			if err := m.Fields[len(m.Fields)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipExample(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthExample
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ExampleItem) 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 ErrIntOverflowExample
			}
			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: ExampleItem: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ExampleItem: 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 ErrIntOverflowExample
				}
				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 ErrIntOverflowExample
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExample
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.CreatedAt == nil {
				m.CreatedAt = new(time.Time)
			}
			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 ErrIntOverflowExample
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExample
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.UpdatedAt == nil {
				m.UpdatedAt = new(time.Time)
			}
			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 ErrIntOverflowExample
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExample
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.DeletedAt == nil {
				m.DeletedAt = new(time.Time)
			}
			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 ErrIntOverflowExample
				}
				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 ErrInvalidLengthExample
			}
			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 Mess", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExample
				}
				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 ErrInvalidLengthExample
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Mess = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MoveID", wireType)
			}
			m.MoveID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExample
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MoveID |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipExample(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthExample
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Example) 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 ErrIntOverflowExample
			}
			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: Example: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Example: 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 ErrIntOverflowExample
				}
				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 ErrIntOverflowExample
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExample
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.CreatedAt == nil {
				m.CreatedAt = new(time.Time)
			}
			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 ErrIntOverflowExample
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExample
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.UpdatedAt == nil {
				m.UpdatedAt = new(time.Time)
			}
			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 ErrIntOverflowExample
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExample
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.DeletedAt == nil {
				m.DeletedAt = new(time.Time)
			}
			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 ErrIntOverflowExample
				}
				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 ErrInvalidLengthExample
			}
			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 Mess", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExample
				}
				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 ErrInvalidLengthExample
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Mess = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Product", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExample
				}
				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 ErrInvalidLengthExample
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Product = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Organization", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExample
				}
				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 ErrInvalidLengthExample
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Organization = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExample
				}
				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 ErrInvalidLengthExample
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.State = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExample
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExample
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Items = append(m.Items, &ExampleItem{})
			if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipExample(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthExample
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipExample(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, ErrIntOverflowExample
			}
			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, ErrIntOverflowExample
				}
				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, ErrIntOverflowExample
				}
				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, ErrInvalidLengthExample
			}
			return iNdEx, nil
		case 3:
			for {
				var innerWire uint64
				var start int = iNdEx
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return 0, ErrIntOverflowExample
					}
					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 := skipExample(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 (
	ErrInvalidLengthExample = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowExample   = fmt.Errorf("proto: integer overflow")
)

func init() { proto.RegisterFile("example/example.proto", fileDescriptor_example_663bc880cd358822) }

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