message.pb.go

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

package example

import (
	fmt "fmt"
	_ "github.com/alexander-sapozhnikov/protoc-gen-struct-transformer/options"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
	_ "github.com/golang/protobuf/ptypes/timestamp"
	io "io"
	math "math"
	math_bits "math/bits"
	time "time"
)

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

type TheOne struct {
	// Types that are valid to be assigned to TheDecl:
	//	*TheOne_StringValue
	//	*TheOne_Int64Value
	TheDecl isTheOne_TheDecl `protobuf_oneof:"the_decl"`
}

func (m *TheOne) Reset()         { *m = TheOne{} }
func (m *TheOne) String() string { return proto.CompactTextString(m) }
func (*TheOne) ProtoMessage()    {}
func (*TheOne) Descriptor() ([]byte, []int) {
	return fileDescriptor_c1ffb7dddb00b34f, []int{0}
}
func (m *TheOne) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TheOne) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TheOne.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TheOne) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TheOne.Merge(m, src)
}
func (m *TheOne) XXX_Size() int {
	return m.Size()
}
func (m *TheOne) XXX_DiscardUnknown() {
	xxx_messageInfo_TheOne.DiscardUnknown(m)
}

var xxx_messageInfo_TheOne proto.InternalMessageInfo

type isTheOne_TheDecl interface {
	isTheOne_TheDecl()
	MarshalTo([]byte) (int, error)
	Size() int
}

type TheOne_StringValue struct {
	StringValue string `protobuf:"bytes,1,opt,name=string_value,json=stringValue,proto3,oneof" json:"string_value,omitempty"`
}
type TheOne_Int64Value struct {
	Int64Value int64 `protobuf:"varint,2,opt,name=int64_value,json=int64Value,proto3,oneof" json:"int64_value,omitempty"`
}

func (*TheOne_StringValue) isTheOne_TheDecl() {}
func (*TheOne_Int64Value) isTheOne_TheDecl()  {}

func (m *TheOne) GetTheDecl() isTheOne_TheDecl {
	if m != nil {
		return m.TheDecl
	}
	return nil
}

func (m *TheOne) GetStringValue() string {
	if x, ok := m.GetTheDecl().(*TheOne_StringValue); ok {
		return x.StringValue
	}
	return ""
}

func (m *TheOne) GetInt64Value() int64 {
	if x, ok := m.GetTheDecl().(*TheOne_Int64Value); ok {
		return x.Int64Value
	}
	return 0
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*TheOne) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*TheOne_StringValue)(nil),
		(*TheOne_Int64Value)(nil),
	}
}

type NotSupportedOneOf struct {
	// Types that are valid to be assigned to TheDecl:
	//	*NotSupportedOneOf_BoolValue
	//	*NotSupportedOneOf_StringValue
	TheDecl isNotSupportedOneOf_TheDecl `protobuf_oneof:"the_decl"`
}

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

var xxx_messageInfo_NotSupportedOneOf proto.InternalMessageInfo

type isNotSupportedOneOf_TheDecl interface {
	isNotSupportedOneOf_TheDecl()
	MarshalTo([]byte) (int, error)
	Size() int
}

type NotSupportedOneOf_BoolValue struct {
	BoolValue bool `protobuf:"varint,1,opt,name=bool_value,json=boolValue,proto3,oneof" json:"bool_value,omitempty"`
}
type NotSupportedOneOf_StringValue struct {
	StringValue string `protobuf:"bytes,2,opt,name=string_value,json=stringValue,proto3,oneof" json:"string_value,omitempty"`
}

func (*NotSupportedOneOf_BoolValue) isNotSupportedOneOf_TheDecl()   {}
func (*NotSupportedOneOf_StringValue) isNotSupportedOneOf_TheDecl() {}

func (m *NotSupportedOneOf) GetTheDecl() isNotSupportedOneOf_TheDecl {
	if m != nil {
		return m.TheDecl
	}
	return nil
}

func (m *NotSupportedOneOf) GetBoolValue() bool {
	if x, ok := m.GetTheDecl().(*NotSupportedOneOf_BoolValue); ok {
		return x.BoolValue
	}
	return false
}

func (m *NotSupportedOneOf) GetStringValue() string {
	if x, ok := m.GetTheDecl().(*NotSupportedOneOf_StringValue); ok {
		return x.StringValue
	}
	return ""
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*NotSupportedOneOf) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*NotSupportedOneOf_BoolValue)(nil),
		(*NotSupportedOneOf_StringValue)(nil),
	}
}

type CustomOneof struct {
	// Types that are valid to be assigned to Value:
	//	*CustomOneof_StringValue
	//	*CustomOneof_Int64Value
	Value isCustomOneof_Value `protobuf_oneof:"value"`
}

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

var xxx_messageInfo_CustomOneof proto.InternalMessageInfo

type isCustomOneof_Value interface {
	isCustomOneof_Value()
	MarshalTo([]byte) (int, error)
	Size() int
}

type CustomOneof_StringValue struct {
	StringValue string `protobuf:"bytes,1,opt,name=string_value,json=stringValue,proto3,oneof" json:"string_value,omitempty"`
}
type CustomOneof_Int64Value struct {
	Int64Value int64 `protobuf:"varint,2,opt,name=int64_value,json=int64Value,proto3,oneof" json:"int64_value,omitempty"`
}

func (*CustomOneof_StringValue) isCustomOneof_Value() {}
func (*CustomOneof_Int64Value) isCustomOneof_Value()  {}

func (m *CustomOneof) GetValue() isCustomOneof_Value {
	if m != nil {
		return m.Value
	}
	return nil
}

func (m *CustomOneof) GetStringValue() string {
	if x, ok := m.GetValue().(*CustomOneof_StringValue); ok {
		return x.StringValue
	}
	return ""
}

func (m *CustomOneof) GetInt64Value() int64 {
	if x, ok := m.GetValue().(*CustomOneof_Int64Value); ok {
		return x.Int64Value
	}
	return 0
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*CustomOneof) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*CustomOneof_StringValue)(nil),
		(*CustomOneof_Int64Value)(nil),
	}
}

type CustomType struct {
	Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
}

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

var xxx_messageInfo_CustomType proto.InternalMessageInfo

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

type Product struct {
	Id       int32   `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	Name     string  `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	One      *TheOne `protobuf:"bytes,3,opt,name=one,proto3" json:"one,omitempty"`
	SecondId *TheOne `protobuf:"bytes,4,opt,name=second_id,json=secondId,proto3" json:"second_id,omitempty"`
	// Example of the custom transformer for the struct
	CustomField *CustomType `protobuf:"bytes,5,opt,name=custom_field,json=customField,proto3" json:"custom_field,omitempty"`
	// Example of the custom transformer for the struct with oneof type in it
	CustomOneof *CustomOneof `protobuf:"bytes,6,opt,name=custom_oneof,json=customOneof,proto3" json:"custom_oneof,omitempty"`
	// Currently the plugin does not support oneof types rather than the specific example with `int64_value` and `string_value`
	NotsupportedOneof *NotSupportedOneOf `protobuf:"bytes,7,opt,name=notsupported_oneof,json=notsupportedOneof,proto3" json:"notsupported_oneof,omitempty"`
}

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

var xxx_messageInfo_Product proto.InternalMessageInfo

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

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

func (m *Product) GetOne() *TheOne {
	if m != nil {
		return m.One
	}
	return nil
}

func (m *Product) GetSecondId() *TheOne {
	if m != nil {
		return m.SecondId
	}
	return nil
}

func (m *Product) GetCustomField() *CustomType {
	if m != nil {
		return m.CustomField
	}
	return nil
}

func (m *Product) GetCustomOneof() *CustomOneof {
	if m != nil {
		return m.CustomOneof
	}
	return nil
}

func (m *Product) GetNotsupportedOneof() *NotSupportedOneOf {
	if m != nil {
		return m.NotsupportedOneof
	}
	return nil
}

type Order struct {
	Id       int64   `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	FirstId  *TheOne `protobuf:"bytes,2,opt,name=first_id,json=firstId,proto3" json:"first_id,omitempty"`
	SecondId *TheOne `protobuf:"bytes,3,opt,name=second_id,json=secondId,proto3" json:"second_id,omitempty"`
	ThirdUrl *TheOne `protobuf:"bytes,4,opt,name=third_url,json=thirdUrl,proto3" json:"third_url,omitempty"`
}

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

var xxx_messageInfo_Order proto.InternalMessageInfo

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

func (m *Order) GetFirstId() *TheOne {
	if m != nil {
		return m.FirstId
	}
	return nil
}

func (m *Order) GetSecondId() *TheOne {
	if m != nil {
		return m.SecondId
	}
	return nil
}

func (m *Order) GetThirdUrl() *TheOne {
	if m != nil {
		return m.ThirdUrl
	}
	return nil
}

type Address struct {
	Id   int64  `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	Type string `protobuf:"bytes,2,opt,name=type,proto3" json:"type,omitempty"`
}

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

var xxx_messageInfo_Address proto.InternalMessageInfo

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

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

type Customer struct {
	Id                      int64      `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	Name                    string     `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	Addresses               []*Address `protobuf:"bytes,3,rep,name=addresses,proto3" json:"addresses,omitempty"`
	DefaultAddress          *Address   `protobuf:"bytes,4,opt,name=default_address,json=defaultAddress,proto3" json:"default_address,omitempty"`
	BillingAddress          Address    `protobuf:"bytes,5,opt,name=billing_address,json=billingAddress,proto3" json:"billing_address"`
	MapField_1              string     `protobuf:"bytes,6,opt,name=map_field_1,json=mapField1,proto3" json:"map_field_1,omitempty"`
	MapFieldToWithoutDigits string     `protobuf:"bytes,7,opt,name=map_field_to_without_digits,json=mapFieldToWithoutDigits,proto3" json:"map_field_to_without_digits,omitempty"`
}

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

var xxx_messageInfo_Customer proto.InternalMessageInfo

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

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

func (m *Customer) GetAddresses() []*Address {
	if m != nil {
		return m.Addresses
	}
	return nil
}

func (m *Customer) GetDefaultAddress() *Address {
	if m != nil {
		return m.DefaultAddress
	}
	return nil
}

func (m *Customer) GetBillingAddress() Address {
	if m != nil {
		return m.BillingAddress
	}
	return Address{}
}

func (m *Customer) GetMapField_1() string {
	if m != nil {
		return m.MapField_1
	}
	return ""
}

func (m *Customer) GetMapFieldToWithoutDigits() string {
	if m != nil {
		return m.MapFieldToWithoutDigits
	}
	return ""
}

// opposite message order, usage of LineItem is earlier than message is defined.
type LineItemUsage struct {
	Item *LineItem   `protobuf:"bytes,1,opt,name=Item,proto3" json:"Item,omitempty"`
	List []*LineItem `protobuf:"bytes,2,rep,name=List,proto3" json:"List,omitempty"`
}

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

var xxx_messageInfo_LineItemUsage proto.InternalMessageInfo

func (m *LineItemUsage) GetItem() *LineItem {
	if m != nil {
		return m.Item
	}
	return nil
}

func (m *LineItemUsage) GetList() []*LineItem {
	if m != nil {
		return m.List
	}
	return nil
}

type LineItem struct {
	// Capitalized ID. It's not by protobuf style guide, but supported too.
	ID   int64  `protobuf:"varint,1,opt,name=ID,proto3" json:"ID,omitempty"`
	Type string `protobuf:"bytes,2,opt,name=Type,proto3" json:"Type,omitempty"`
	// SomeField will not be added to transformation function.
	SomeField string `protobuf:"bytes,3,opt,name=some_field,json=someField,proto3" json:"some_field,omitempty"`
	URL       string `protobuf:"bytes,4,opt,name=URL,proto3" json:"URL,omitempty"`
	SKU       int64  `protobuf:"varint,5,opt,name=SKU,proto3" json:"SKU,omitempty"`
}

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

var xxx_messageInfo_LineItem proto.InternalMessageInfo

func (m *LineItem) GetID() int64 {
	if m != nil {
		return m.ID
	}
	return 0
}

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

func (m *LineItem) GetSomeField() string {
	if m != nil {
		return m.SomeField
	}
	return ""
}

func (m *LineItem) GetURL() string {
	if m != nil {
		return m.URL
	}
	return ""
}

func (m *LineItem) GetSKU() int64 {
	if m != nil {
		return m.SKU
	}
	return 0
}

type Value2Pointer struct {
	// In message.pb.go Address field will be of type Address.
	AddressNil Address `protobuf:"bytes,1,opt,name=address_nil,json=addressNil,proto3" json:"address_nil"`
}

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

var xxx_messageInfo_Value2Pointer proto.InternalMessageInfo

func (m *Value2Pointer) GetAddressNil() Address {
	if m != nil {
		return m.AddressNil
	}
	return Address{}
}

type Pointer2Value struct {
	// In message.pb.go Address field will be of type *Address.
	AddressNotNil *Address `protobuf:"bytes,1,opt,name=address_not_nil,json=addressNotNil,proto3" json:"address_not_nil,omitempty"`
}

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

var xxx_messageInfo_Pointer2Value proto.InternalMessageInfo

func (m *Pointer2Value) GetAddressNotNil() *Address {
	if m != nil {
		return m.AddressNotNil
	}
	return nil
}

type SkippedMessageOne struct {
}

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

var xxx_messageInfo_SkippedMessageOne proto.InternalMessageInfo

type SkippedMessageTwo struct {
}

func (m *SkippedMessageTwo) Reset()         { *m = SkippedMessageTwo{} }
func (m *SkippedMessageTwo) String() string { return proto.CompactTextString(m) }
func (*SkippedMessageTwo) ProtoMessage()    {}
func (*SkippedMessageTwo) Descriptor() ([]byte, []int) {
	return fileDescriptor_c1ffb7dddb00b34f, []int{13}
}
func (m *SkippedMessageTwo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SkippedMessageTwo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SkippedMessageTwo.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *SkippedMessageTwo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SkippedMessageTwo.Merge(m, src)
}
func (m *SkippedMessageTwo) XXX_Size() int {
	return m.Size()
}
func (m *SkippedMessageTwo) XXX_DiscardUnknown() {
	xxx_messageInfo_SkippedMessageTwo.DiscardUnknown(m)
}

var xxx_messageInfo_SkippedMessageTwo proto.InternalMessageInfo

type Timer struct {
	Time               time.Time  `protobuf:"bytes,1,opt,name=time,proto3,stdtime" json:"time"`
	PtrTime            *time.Time `protobuf:"bytes,2,opt,name=ptr_time,json=ptrTime,proto3,stdtime" json:"ptr_time,omitempty"`
	TimeToStruct       time.Time  `protobuf:"bytes,3,opt,name=time_to_struct,json=timeToStruct,proto3,stdtime" json:"time_to_struct"`
	TimeToStructPtr    *time.Time `protobuf:"bytes,4,opt,name=time_to_struct_ptr,json=timeToStructPtr,proto3,stdtime" json:"time_to_struct_ptr,omitempty"`
	TimePtrToStruct    *time.Time `protobuf:"bytes,5,opt,name=time_ptr_to_struct,json=timePtrToStruct,proto3,stdtime" json:"time_ptr_to_struct,omitempty"`
	TimePtrToPtrStruct *time.Time `protobuf:"bytes,6,opt,name=time_ptr_to_ptr_struct,json=timePtrToPtrStruct,proto3,stdtime" json:"time_ptr_to_ptr_struct,omitempty"`
}

func (m *Timer) Reset()         { *m = Timer{} }
func (m *Timer) String() string { return proto.CompactTextString(m) }
func (*Timer) ProtoMessage()    {}
func (*Timer) Descriptor() ([]byte, []int) {
	return fileDescriptor_c1ffb7dddb00b34f, []int{14}
}
func (m *Timer) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Timer) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Timer.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Timer) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Timer.Merge(m, src)
}
func (m *Timer) XXX_Size() int {
	return m.Size()
}
func (m *Timer) XXX_DiscardUnknown() {
	xxx_messageInfo_Timer.DiscardUnknown(m)
}

var xxx_messageInfo_Timer proto.InternalMessageInfo

func (m *Timer) GetTime() time.Time {
	if m != nil {
		return m.Time
	}
	return time.Time{}
}

func (m *Timer) GetPtrTime() *time.Time {
	if m != nil {
		return m.PtrTime
	}
	return nil
}

func (m *Timer) GetTimeToStruct() time.Time {
	if m != nil {
		return m.TimeToStruct
	}
	return time.Time{}
}

func (m *Timer) GetTimeToStructPtr() *time.Time {
	if m != nil {
		return m.TimeToStructPtr
	}
	return nil
}

func (m *Timer) GetTimePtrToStruct() *time.Time {
	if m != nil {
		return m.TimePtrToStruct
	}
	return nil
}

func (m *Timer) GetTimePtrToPtrStruct() *time.Time {
	if m != nil {
		return m.TimePtrToPtrStruct
	}
	return nil
}

type Ints struct {
	IntFor_32Value int32 `protobuf:"varint,1,opt,name=int_for_32_value,json=intFor32Value,proto3" json:"int_for_32_value,omitempty"`
	IntFor_64Value int64 `protobuf:"varint,2,opt,name=int_for_64_value,json=intFor64Value,proto3" json:"int_for_64_value,omitempty"`
	Int32Value     int32 `protobuf:"varint,3,opt,name=int32_value,json=int32Value,proto3" json:"int32_value,omitempty"`
	Int64Value     int64 `protobuf:"varint,4,opt,name=int64_value,json=int64Value,proto3" json:"int64_value,omitempty"`
	StringValue    int64 `protobuf:"varint,5,opt,name=string_value,json=stringValue,proto3" json:"string_value,omitempty"`
}

func (m *Ints) Reset()         { *m = Ints{} }
func (m *Ints) String() string { return proto.CompactTextString(m) }
func (*Ints) ProtoMessage()    {}
func (*Ints) Descriptor() ([]byte, []int) {
	return fileDescriptor_c1ffb7dddb00b34f, []int{15}
}
func (m *Ints) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Ints) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Ints.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Ints) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Ints.Merge(m, src)
}
func (m *Ints) XXX_Size() int {
	return m.Size()
}
func (m *Ints) XXX_DiscardUnknown() {
	xxx_messageInfo_Ints.DiscardUnknown(m)
}

var xxx_messageInfo_Ints proto.InternalMessageInfo

func (m *Ints) GetIntFor_32Value() int32 {
	if m != nil {
		return m.IntFor_32Value
	}
	return 0
}

func (m *Ints) GetIntFor_64Value() int64 {
	if m != nil {
		return m.IntFor_64Value
	}
	return 0
}

func (m *Ints) GetInt32Value() int32 {
	if m != nil {
		return m.Int32Value
	}
	return 0
}

func (m *Ints) GetInt64Value() int64 {
	if m != nil {
		return m.Int64Value
	}
	return 0
}

func (m *Ints) GetStringValue() int64 {
	if m != nil {
		return m.StringValue
	}
	return 0
}

func init() {
	proto.RegisterType((*TheOne)(nil), "svc.example.TheOne")
	proto.RegisterType((*NotSupportedOneOf)(nil), "svc.example.NotSupportedOneOf")
	proto.RegisterType((*CustomOneof)(nil), "svc.example.CustomOneof")
	proto.RegisterType((*CustomType)(nil), "svc.example.CustomType")
	proto.RegisterType((*Product)(nil), "svc.example.Product")
	proto.RegisterType((*Order)(nil), "svc.example.Order")
	proto.RegisterType((*Address)(nil), "svc.example.Address")
	proto.RegisterType((*Customer)(nil), "svc.example.Customer")
	proto.RegisterType((*LineItemUsage)(nil), "svc.example.LineItemUsage")
	proto.RegisterType((*LineItem)(nil), "svc.example.LineItem")
	proto.RegisterType((*Value2Pointer)(nil), "svc.example.Value2Pointer")
	proto.RegisterType((*Pointer2Value)(nil), "svc.example.Pointer2Value")
	proto.RegisterType((*SkippedMessageOne)(nil), "svc.example.SkippedMessageOne")
	proto.RegisterType((*SkippedMessageTwo)(nil), "svc.example.SkippedMessageTwo")
	proto.RegisterType((*Timer)(nil), "svc.example.Timer")
	proto.RegisterType((*Ints)(nil), "svc.example.Ints")
}

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

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

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

func (m *TheOne) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TheOne) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TheDecl != nil {
		{
			size := m.TheDecl.Size()
			i -= size
			if _, err := m.TheDecl.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	return len(dAtA) - i, nil
}

func (m *TheOne_StringValue) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TheOne_StringValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	i -= len(m.StringValue)
	copy(dAtA[i:], m.StringValue)
	i = encodeVarintMessage(dAtA, i, uint64(len(m.StringValue)))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}
func (m *TheOne_Int64Value) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TheOne_Int64Value) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	i = encodeVarintMessage(dAtA, i, uint64(m.Int64Value))
	i--
	dAtA[i] = 0x10
	return len(dAtA) - i, nil
}
func (m *NotSupportedOneOf) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *NotSupportedOneOf) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *NotSupportedOneOf) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TheDecl != nil {
		{
			size := m.TheDecl.Size()
			i -= size
			if _, err := m.TheDecl.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	return len(dAtA) - i, nil
}

func (m *NotSupportedOneOf_BoolValue) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *NotSupportedOneOf_BoolValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	i--
	if m.BoolValue {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i--
	dAtA[i] = 0x8
	return len(dAtA) - i, nil
}
func (m *NotSupportedOneOf_StringValue) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *NotSupportedOneOf_StringValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	i -= len(m.StringValue)
	copy(dAtA[i:], m.StringValue)
	i = encodeVarintMessage(dAtA, i, uint64(len(m.StringValue)))
	i--
	dAtA[i] = 0x12
	return len(dAtA) - i, nil
}
func (m *CustomOneof) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *CustomOneof) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CustomOneof) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Value != nil {
		{
			size := m.Value.Size()
			i -= size
			if _, err := m.Value.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	return len(dAtA) - i, nil
}

func (m *CustomOneof_StringValue) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CustomOneof_StringValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	i -= len(m.StringValue)
	copy(dAtA[i:], m.StringValue)
	i = encodeVarintMessage(dAtA, i, uint64(len(m.StringValue)))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}
func (m *CustomOneof_Int64Value) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CustomOneof_Int64Value) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	i = encodeVarintMessage(dAtA, i, uint64(m.Int64Value))
	i--
	dAtA[i] = 0x10
	return len(dAtA) - i, nil
}
func (m *CustomType) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *CustomType) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CustomType) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Value) > 0 {
		i -= len(m.Value)
		copy(dAtA[i:], m.Value)
		i = encodeVarintMessage(dAtA, i, uint64(len(m.Value)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *Product) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Product) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.NotsupportedOneof != nil {
		{
			size, err := m.NotsupportedOneof.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMessage(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	if m.CustomOneof != nil {
		{
			size, err := m.CustomOneof.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMessage(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if m.CustomField != nil {
		{
			size, err := m.CustomField.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMessage(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if m.SecondId != nil {
		{
			size, err := m.SecondId.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMessage(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.One != nil {
		{
			size, err := m.One.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMessage(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintMessage(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x12
	}
	if m.Id != 0 {
		i = encodeVarintMessage(dAtA, i, uint64(m.Id))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *Order) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Order) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ThirdUrl != nil {
		{
			size, err := m.ThirdUrl.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMessage(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.SecondId != nil {
		{
			size, err := m.SecondId.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMessage(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.FirstId != nil {
		{
			size, err := m.FirstId.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMessage(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Id != 0 {
		i = encodeVarintMessage(dAtA, i, uint64(m.Id))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *Address) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Address) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Type) > 0 {
		i -= len(m.Type)
		copy(dAtA[i:], m.Type)
		i = encodeVarintMessage(dAtA, i, uint64(len(m.Type)))
		i--
		dAtA[i] = 0x12
	}
	if m.Id != 0 {
		i = encodeVarintMessage(dAtA, i, uint64(m.Id))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *Customer) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Customer) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.MapFieldToWithoutDigits) > 0 {
		i -= len(m.MapFieldToWithoutDigits)
		copy(dAtA[i:], m.MapFieldToWithoutDigits)
		i = encodeVarintMessage(dAtA, i, uint64(len(m.MapFieldToWithoutDigits)))
		i--
		dAtA[i] = 0x3a
	}
	if len(m.MapField_1) > 0 {
		i -= len(m.MapField_1)
		copy(dAtA[i:], m.MapField_1)
		i = encodeVarintMessage(dAtA, i, uint64(len(m.MapField_1)))
		i--
		dAtA[i] = 0x32
	}
	{
		size, err := m.BillingAddress.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintMessage(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2a
	if m.DefaultAddress != nil {
		{
			size, err := m.DefaultAddress.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMessage(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if len(m.Addresses) > 0 {
		for iNdEx := len(m.Addresses) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Addresses[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMessage(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintMessage(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x12
	}
	if m.Id != 0 {
		i = encodeVarintMessage(dAtA, i, uint64(m.Id))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *LineItemUsage) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *LineItemUsage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.List) > 0 {
		for iNdEx := len(m.List) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.List[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMessage(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if m.Item != nil {
		{
			size, err := m.Item.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMessage(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *LineItem) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *LineItem) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.SKU != 0 {
		i = encodeVarintMessage(dAtA, i, uint64(m.SKU))
		i--
		dAtA[i] = 0x28
	}
	if len(m.URL) > 0 {
		i -= len(m.URL)
		copy(dAtA[i:], m.URL)
		i = encodeVarintMessage(dAtA, i, uint64(len(m.URL)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.SomeField) > 0 {
		i -= len(m.SomeField)
		copy(dAtA[i:], m.SomeField)
		i = encodeVarintMessage(dAtA, i, uint64(len(m.SomeField)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Type) > 0 {
		i -= len(m.Type)
		copy(dAtA[i:], m.Type)
		i = encodeVarintMessage(dAtA, i, uint64(len(m.Type)))
		i--
		dAtA[i] = 0x12
	}
	if m.ID != 0 {
		i = encodeVarintMessage(dAtA, i, uint64(m.ID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *Value2Pointer) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Value2Pointer) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.AddressNil.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintMessage(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *Pointer2Value) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Pointer2Value) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.AddressNotNil != nil {
		{
			size, err := m.AddressNotNil.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMessage(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *SkippedMessageOne) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SkippedMessageOne) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

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

func (m *SkippedMessageTwo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SkippedMessageTwo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

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

func (m *Timer) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Timer) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.TimePtrToPtrStruct != nil {
		n14, err14 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.TimePtrToPtrStruct, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.TimePtrToPtrStruct):])
		if err14 != nil {
			return 0, err14
		}
		i -= n14
		i = encodeVarintMessage(dAtA, i, uint64(n14))
		i--
		dAtA[i] = 0x32
	}
	if m.TimePtrToStruct != nil {
		n15, err15 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.TimePtrToStruct, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.TimePtrToStruct):])
		if err15 != nil {
			return 0, err15
		}
		i -= n15
		i = encodeVarintMessage(dAtA, i, uint64(n15))
		i--
		dAtA[i] = 0x2a
	}
	if m.TimeToStructPtr != nil {
		n16, err16 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.TimeToStructPtr, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.TimeToStructPtr):])
		if err16 != nil {
			return 0, err16
		}
		i -= n16
		i = encodeVarintMessage(dAtA, i, uint64(n16))
		i--
		dAtA[i] = 0x22
	}
	n17, err17 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.TimeToStruct, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.TimeToStruct):])
	if err17 != nil {
		return 0, err17
	}
	i -= n17
	i = encodeVarintMessage(dAtA, i, uint64(n17))
	i--
	dAtA[i] = 0x1a
	if m.PtrTime != nil {
		n18, err18 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.PtrTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.PtrTime):])
		if err18 != nil {
			return 0, err18
		}
		i -= n18
		i = encodeVarintMessage(dAtA, i, uint64(n18))
		i--
		dAtA[i] = 0x12
	}
	n19, err19 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Time, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Time):])
	if err19 != nil {
		return 0, err19
	}
	i -= n19
	i = encodeVarintMessage(dAtA, i, uint64(n19))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *Ints) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Ints) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.StringValue != 0 {
		i = encodeVarintMessage(dAtA, i, uint64(m.StringValue))
		i--
		dAtA[i] = 0x28
	}
	if m.Int64Value != 0 {
		i = encodeVarintMessage(dAtA, i, uint64(m.Int64Value))
		i--
		dAtA[i] = 0x20
	}
	if m.Int32Value != 0 {
		i = encodeVarintMessage(dAtA, i, uint64(m.Int32Value))
		i--
		dAtA[i] = 0x18
	}
	if m.IntFor_64Value != 0 {
		i = encodeVarintMessage(dAtA, i, uint64(m.IntFor_64Value))
		i--
		dAtA[i] = 0x10
	}
	if m.IntFor_32Value != 0 {
		i = encodeVarintMessage(dAtA, i, uint64(m.IntFor_32Value))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func encodeVarintMessage(dAtA []byte, offset int, v uint64) int {
	offset -= sovMessage(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *TheOne) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TheDecl != nil {
		n += m.TheDecl.Size()
	}
	return n
}

func (m *TheOne_StringValue) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.StringValue)
	n += 1 + l + sovMessage(uint64(l))
	return n
}
func (m *TheOne_Int64Value) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovMessage(uint64(m.Int64Value))
	return n
}
func (m *NotSupportedOneOf) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TheDecl != nil {
		n += m.TheDecl.Size()
	}
	return n
}

func (m *NotSupportedOneOf_BoolValue) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 2
	return n
}
func (m *NotSupportedOneOf_StringValue) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.StringValue)
	n += 1 + l + sovMessage(uint64(l))
	return n
}
func (m *CustomOneof) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Value != nil {
		n += m.Value.Size()
	}
	return n
}

func (m *CustomOneof_StringValue) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.StringValue)
	n += 1 + l + sovMessage(uint64(l))
	return n
}
func (m *CustomOneof_Int64Value) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovMessage(uint64(m.Int64Value))
	return n
}
func (m *CustomType) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovMessage(uint64(l))
	}
	return n
}

func (m *Product) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Id != 0 {
		n += 1 + sovMessage(uint64(m.Id))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovMessage(uint64(l))
	}
	if m.One != nil {
		l = m.One.Size()
		n += 1 + l + sovMessage(uint64(l))
	}
	if m.SecondId != nil {
		l = m.SecondId.Size()
		n += 1 + l + sovMessage(uint64(l))
	}
	if m.CustomField != nil {
		l = m.CustomField.Size()
		n += 1 + l + sovMessage(uint64(l))
	}
	if m.CustomOneof != nil {
		l = m.CustomOneof.Size()
		n += 1 + l + sovMessage(uint64(l))
	}
	if m.NotsupportedOneof != nil {
		l = m.NotsupportedOneof.Size()
		n += 1 + l + sovMessage(uint64(l))
	}
	return n
}

func (m *Order) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Id != 0 {
		n += 1 + sovMessage(uint64(m.Id))
	}
	if m.FirstId != nil {
		l = m.FirstId.Size()
		n += 1 + l + sovMessage(uint64(l))
	}
	if m.SecondId != nil {
		l = m.SecondId.Size()
		n += 1 + l + sovMessage(uint64(l))
	}
	if m.ThirdUrl != nil {
		l = m.ThirdUrl.Size()
		n += 1 + l + sovMessage(uint64(l))
	}
	return n
}

func (m *Address) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Id != 0 {
		n += 1 + sovMessage(uint64(m.Id))
	}
	l = len(m.Type)
	if l > 0 {
		n += 1 + l + sovMessage(uint64(l))
	}
	return n
}

func (m *Customer) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Id != 0 {
		n += 1 + sovMessage(uint64(m.Id))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovMessage(uint64(l))
	}
	if len(m.Addresses) > 0 {
		for _, e := range m.Addresses {
			l = e.Size()
			n += 1 + l + sovMessage(uint64(l))
		}
	}
	if m.DefaultAddress != nil {
		l = m.DefaultAddress.Size()
		n += 1 + l + sovMessage(uint64(l))
	}
	l = m.BillingAddress.Size()
	n += 1 + l + sovMessage(uint64(l))
	l = len(m.MapField_1)
	if l > 0 {
		n += 1 + l + sovMessage(uint64(l))
	}
	l = len(m.MapFieldToWithoutDigits)
	if l > 0 {
		n += 1 + l + sovMessage(uint64(l))
	}
	return n
}

func (m *LineItemUsage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Item != nil {
		l = m.Item.Size()
		n += 1 + l + sovMessage(uint64(l))
	}
	if len(m.List) > 0 {
		for _, e := range m.List {
			l = e.Size()
			n += 1 + l + sovMessage(uint64(l))
		}
	}
	return n
}

func (m *LineItem) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ID != 0 {
		n += 1 + sovMessage(uint64(m.ID))
	}
	l = len(m.Type)
	if l > 0 {
		n += 1 + l + sovMessage(uint64(l))
	}
	l = len(m.SomeField)
	if l > 0 {
		n += 1 + l + sovMessage(uint64(l))
	}
	l = len(m.URL)
	if l > 0 {
		n += 1 + l + sovMessage(uint64(l))
	}
	if m.SKU != 0 {
		n += 1 + sovMessage(uint64(m.SKU))
	}
	return n
}

func (m *Value2Pointer) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.AddressNil.Size()
	n += 1 + l + sovMessage(uint64(l))
	return n
}

func (m *Pointer2Value) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.AddressNotNil != nil {
		l = m.AddressNotNil.Size()
		n += 1 + l + sovMessage(uint64(l))
	}
	return n
}

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

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

func (m *Timer) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.Time)
	n += 1 + l + sovMessage(uint64(l))
	if m.PtrTime != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.PtrTime)
		n += 1 + l + sovMessage(uint64(l))
	}
	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.TimeToStruct)
	n += 1 + l + sovMessage(uint64(l))
	if m.TimeToStructPtr != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.TimeToStructPtr)
		n += 1 + l + sovMessage(uint64(l))
	}
	if m.TimePtrToStruct != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.TimePtrToStruct)
		n += 1 + l + sovMessage(uint64(l))
	}
	if m.TimePtrToPtrStruct != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.TimePtrToPtrStruct)
		n += 1 + l + sovMessage(uint64(l))
	}
	return n
}

func (m *Ints) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.IntFor_32Value != 0 {
		n += 1 + sovMessage(uint64(m.IntFor_32Value))
	}
	if m.IntFor_64Value != 0 {
		n += 1 + sovMessage(uint64(m.IntFor_64Value))
	}
	if m.Int32Value != 0 {
		n += 1 + sovMessage(uint64(m.Int32Value))
	}
	if m.Int64Value != 0 {
		n += 1 + sovMessage(uint64(m.Int64Value))
	}
	if m.StringValue != 0 {
		n += 1 + sovMessage(uint64(m.StringValue))
	}
	return n
}

func sovMessage(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozMessage(x uint64) (n int) {
	return sovMessage(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *TheOne) 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 ErrIntOverflowMessage
			}
			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: TheOne: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TheOne: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StringValue", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessage
				}
				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 ErrInvalidLengthMessage
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMessage
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TheDecl = &TheOne_StringValue{string(dAtA[iNdEx:postIndex])}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Int64Value", wireType)
			}
			var v int64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.TheDecl = &TheOne_Int64Value{v}
		default:
			iNdEx = preIndex
			skippy, err := skipMessage(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMessage
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMessage
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *NotSupportedOneOf) 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 ErrIntOverflowMessage
			}
			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: NotSupportedOneOf: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: NotSupportedOneOf: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BoolValue", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			b := bool(v != 0)
			m.TheDecl = &NotSupportedOneOf_BoolValue{b}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StringValue", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessage
				}
				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 ErrInvalidLengthMessage
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMessage
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TheDecl = &NotSupportedOneOf_StringValue{string(dAtA[iNdEx:postIndex])}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMessage(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMessage
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMessage
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CustomOneof) 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 ErrIntOverflowMessage
			}
			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: CustomOneof: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CustomOneof: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StringValue", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessage
				}
				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 ErrInvalidLengthMessage
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMessage
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Value = &CustomOneof_StringValue{string(dAtA[iNdEx:postIndex])}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Int64Value", wireType)
			}
			var v int64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Value = &CustomOneof_Int64Value{v}
		default:
			iNdEx = preIndex
			skippy, err := skipMessage(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMessage
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMessage
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CustomType) 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 ErrIntOverflowMessage
			}
			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: CustomType: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CustomType: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 ErrIntOverflowMessage
				}
				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 ErrInvalidLengthMessage
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMessage
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Value = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMessage(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMessage
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMessage
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Product) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMessage
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Product: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Product: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			m.Id = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Id |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessage
				}
				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 ErrInvalidLengthMessage
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMessage
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field One", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMessage
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMessage
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.One == nil {
				m.One = &TheOne{}
			}
			if err := m.One.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SecondId", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMessage
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMessage
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.SecondId == nil {
				m.SecondId = &TheOne{}
			}
			if err := m.SecondId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CustomField", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMessage
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMessage
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.CustomField == nil {
				m.CustomField = &CustomType{}
			}
			if err := m.CustomField.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CustomOneof", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMessage
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMessage
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.CustomOneof == nil {
				m.CustomOneof = &CustomOneof{}
			}
			if err := m.CustomOneof.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NotsupportedOneof", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMessage
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMessage
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NotsupportedOneof == nil {
				m.NotsupportedOneof = &NotSupportedOneOf{}
			}
			if err := m.NotsupportedOneof.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMessage(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMessage
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMessage
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Order) 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 ErrIntOverflowMessage
			}
			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: Order: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Order: 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 ErrIntOverflowMessage
				}
				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 FirstId", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMessage
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMessage
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.FirstId == nil {
				m.FirstId = &TheOne{}
			}
			if err := m.FirstId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SecondId", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMessage
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMessage
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.SecondId == nil {
				m.SecondId = &TheOne{}
			}
			if err := m.SecondId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ThirdUrl", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMessage
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMessage
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ThirdUrl == nil {
				m.ThirdUrl = &TheOne{}
			}
			if err := m.ThirdUrl.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMessage(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMessage
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMessage
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Address) 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 ErrIntOverflowMessage
			}
			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: Address: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Address: 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 ErrIntOverflowMessage
				}
				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 Type", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessage
				}
				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 ErrInvalidLengthMessage
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMessage
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Type = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMessage(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMessage
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMessage
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Customer) 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 ErrIntOverflowMessage
			}
			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: Customer: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Customer: 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 ErrIntOverflowMessage
				}
				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 Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessage
				}
				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 ErrInvalidLengthMessage
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMessage
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Addresses", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMessage
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMessage
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Addresses = append(m.Addresses, &Address{})
			if err := m.Addresses[len(m.Addresses)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DefaultAddress", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMessage
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMessage
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.DefaultAddress == nil {
				m.DefaultAddress = &Address{}
			}
			if err := m.DefaultAddress.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BillingAddress", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMessage
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMessage
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.BillingAddress.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MapField_1", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessage
				}
				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 ErrInvalidLengthMessage
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMessage
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MapField_1 = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MapFieldToWithoutDigits", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessage
				}
				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 ErrInvalidLengthMessage
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMessage
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MapFieldToWithoutDigits = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMessage(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMessage
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMessage
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *LineItem) 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 ErrIntOverflowMessage
			}
			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: LineItem: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LineItem: 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 ErrIntOverflowMessage
				}
				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 Type", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessage
				}
				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 ErrInvalidLengthMessage
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMessage
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Type = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SomeField", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessage
				}
				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 ErrInvalidLengthMessage
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMessage
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SomeField = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field URL", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessage
				}
				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 ErrInvalidLengthMessage
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMessage
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.URL = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SKU", wireType)
			}
			m.SKU = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SKU |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMessage(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMessage
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMessage
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SkippedMessageOne) 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 ErrIntOverflowMessage
			}
			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: SkippedMessageOne: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SkippedMessageOne: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipMessage(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMessage
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMessage
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SkippedMessageTwo) 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 ErrIntOverflowMessage
			}
			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: SkippedMessageTwo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SkippedMessageTwo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipMessage(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMessage
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMessage
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Timer) 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 ErrIntOverflowMessage
			}
			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: Timer: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Timer: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Time", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMessage
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMessage
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.Time, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PtrTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMessage
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMessage
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.PtrTime == nil {
				m.PtrTime = new(time.Time)
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(m.PtrTime, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TimeToStruct", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMessage
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMessage
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.TimeToStruct, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TimeToStructPtr", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMessage
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMessage
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TimeToStructPtr == nil {
				m.TimeToStructPtr = new(time.Time)
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(m.TimeToStructPtr, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TimePtrToStruct", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMessage
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMessage
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TimePtrToStruct == nil {
				m.TimePtrToStruct = new(time.Time)
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(m.TimePtrToStruct, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TimePtrToPtrStruct", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMessage
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMessage
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TimePtrToPtrStruct == nil {
				m.TimePtrToPtrStruct = new(time.Time)
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(m.TimePtrToPtrStruct, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMessage(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMessage
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMessage
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Ints) 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 ErrIntOverflowMessage
			}
			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: Ints: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Ints: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IntFor_32Value", wireType)
			}
			m.IntFor_32Value = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.IntFor_32Value |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IntFor_64Value", wireType)
			}
			m.IntFor_64Value = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.IntFor_64Value |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Int32Value", wireType)
			}
			m.Int32Value = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Int32Value |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Int64Value", wireType)
			}
			m.Int64Value = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Int64Value |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StringValue", wireType)
			}
			m.StringValue = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessage
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StringValue |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMessage(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMessage
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMessage
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipMessage(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowMessage
			}
			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, ErrIntOverflowMessage
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowMessage
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthMessage
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupMessage
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthMessage
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthMessage        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowMessage          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupMessage = fmt.Errorf("proto: unexpected end of group")
)