message.pb.go

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

package example

import (
	fmt "fmt"
	_ "github.com/bold-commerce/protoc-gen-struct-transformer/options"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	io "io"
	math "math"
	math_bits "math/bits"
)

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

// 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 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"`
}

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{1}
}
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
}

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{2}
}
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{3}
}
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{4}
}
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{5}
}
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 {
	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"`
}

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{6}
}
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 ""
}

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{7}
}
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{8}
}
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{9}
}
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{10}
}
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

func init() {
	proto.RegisterType((*TheOne)(nil), "svc.example.TheOne")
	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")
}

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

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