// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: band/tss/v1beta1/originator.proto

package types

import (
	fmt "fmt"
	_ "github.com/cosmos/cosmos-proto"
	_ "github.com/cosmos/gogoproto/gogoproto"
	proto "github.com/cosmos/gogoproto/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

// DirectOriginator is a message originator defines an information of the requester
// on direct tss request.
type DirectOriginator struct {
	// source_chain_id is the source chain ID that the data is originated from.
	SourceChainID string `protobuf:"bytes,1,opt,name=source_chain_id,json=sourceChainId,proto3" json:"source_chain_id,omitempty"`
	// requester is the address of the requester, it can be the user address or module address.
	Requester string `protobuf:"bytes,2,opt,name=requester,proto3" json:"requester,omitempty"`
	// memo is the note of the message.
	Memo string `protobuf:"bytes,3,opt,name=memo,proto3" json:"memo,omitempty"`
}

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

var xxx_messageInfo_DirectOriginator proto.InternalMessageInfo

func (m *DirectOriginator) GetSourceChainID() string {
	if m != nil {
		return m.SourceChainID
	}
	return ""
}

func (m *DirectOriginator) GetRequester() string {
	if m != nil {
		return m.Requester
	}
	return ""
}

func (m *DirectOriginator) GetMemo() string {
	if m != nil {
		return m.Memo
	}
	return ""
}

// TunnelOriginator is a message originator defines an information of the requester
// on tss request via tunnel module.
type TunnelOriginator struct {
	// source_chain_id is the source chain ID that the data is originated from.
	SourceChainID string `protobuf:"bytes,1,opt,name=source_chain_id,json=sourceChainId,proto3" json:"source_chain_id,omitempty"`
	// tunnel_id is the tunnel ID that the request is originated from.
	TunnelID uint64 `protobuf:"varint,2,opt,name=tunnel_id,json=tunnelId,proto3" json:"tunnel_id,omitempty"`
	// destination_chain_id is the destination chain ID that the data should be relayed to.
	DestinationChainID string `protobuf:"bytes,3,opt,name=destination_chain_id,json=destinationChainId,proto3" json:"destination_chain_id,omitempty"`
	// destination_contract_address is the destination address that the data should be relayed to.
	DestinationContractAddress string `protobuf:"bytes,4,opt,name=destination_contract_address,json=destinationContractAddress,proto3" json:"destination_contract_address,omitempty"`
}

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

var xxx_messageInfo_TunnelOriginator proto.InternalMessageInfo

func (m *TunnelOriginator) GetSourceChainID() string {
	if m != nil {
		return m.SourceChainID
	}
	return ""
}

func (m *TunnelOriginator) GetTunnelID() uint64 {
	if m != nil {
		return m.TunnelID
	}
	return 0
}

func (m *TunnelOriginator) GetDestinationChainID() string {
	if m != nil {
		return m.DestinationChainID
	}
	return ""
}

func (m *TunnelOriginator) GetDestinationContractAddress() string {
	if m != nil {
		return m.DestinationContractAddress
	}
	return ""
}

func init() {
	proto.RegisterType((*DirectOriginator)(nil), "band.tss.v1beta1.DirectOriginator")
	proto.RegisterType((*TunnelOriginator)(nil), "band.tss.v1beta1.TunnelOriginator")
}

func init() { proto.RegisterFile("band/tss/v1beta1/originator.proto", fileDescriptor_220839966f1ace88) }

var fileDescriptor_220839966f1ace88 = []byte{
	// 369 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x92, 0x41, 0x4f, 0xfa, 0x30,
	0x18, 0xc6, 0x19, 0x7f, 0xf2, 0x0f, 0x34, 0xa2, 0xd8, 0x10, 0x33, 0x09, 0x19, 0xca, 0x49, 0x13,
	0x5d, 0x43, 0x38, 0xe9, 0x49, 0xe7, 0x62, 0xe4, 0x64, 0x82, 0x9e, 0xbc, 0x2c, 0xdb, 0xda, 0x8c,
	0x25, 0x6c, 0xc5, 0xb6, 0x23, 0xfa, 0x29, 0xf4, 0xe0, 0x47, 0xf1, 0x43, 0x18, 0x4f, 0x1c, 0x3d,
	0x11, 0x33, 0xbe, 0x88, 0x69, 0x8b, 0x0e, 0x39, 0x7b, 0x6b, 0xfb, 0x7b, 0xde, 0xf7, 0x79, 0xf2,
	0xf6, 0x05, 0xfb, 0x81, 0x9f, 0x62, 0x24, 0x38, 0x47, 0xd3, 0x5e, 0x40, 0x84, 0xdf, 0x43, 0x94,
	0xc5, 0x51, 0x9c, 0xfa, 0x82, 0x32, 0x7b, 0xc2, 0xa8, 0xa0, 0xb0, 0x21, 0x25, 0xb6, 0xe0, 0xdc,
	0x5e, 0x4a, 0x5a, 0xcd, 0x88, 0x46, 0x54, 0x41, 0x24, 0x4f, 0x5a, 0xd7, 0xda, 0x0d, 0x29, 0x4f,
	0x28, 0xf7, 0x34, 0xd0, 0x17, 0x8d, 0xba, 0x4f, 0x06, 0x68, 0xb8, 0x31, 0x23, 0xa1, 0xb8, 0xfe,
	0xe9, 0x0e, 0x4f, 0xc0, 0x16, 0xa7, 0x19, 0x0b, 0x89, 0x17, 0x8e, 0xfc, 0x38, 0xf5, 0x62, 0x6c,
	0x1a, 0x7b, 0xc6, 0x41, 0xcd, 0xd9, 0xce, 0xe7, 0x9d, 0xfa, 0x8d, 0x42, 0x17, 0x92, 0x0c, 0xdc,
	0x61, 0x9d, 0xaf, 0x5c, 0x31, 0x6c, 0x83, 0x1a, 0x23, 0xf7, 0x19, 0xe1, 0x82, 0x30, 0xb3, 0x2c,
	0x8b, 0x86, 0xc5, 0x03, 0x84, 0xa0, 0x92, 0x90, 0x84, 0x9a, 0xff, 0x14, 0x50, 0xe7, 0xd3, 0xcd,
	0xf7, 0xd7, 0x63, 0x50, 0x98, 0x77, 0x5f, 0xca, 0xa0, 0x71, 0x9b, 0xa5, 0x29, 0x19, 0xff, 0x4d,
	0xa2, 0x43, 0x50, 0x13, 0xaa, 0x9d, 0x2c, 0x92, 0x89, 0x2a, 0xce, 0x46, 0x3e, 0xef, 0x54, 0xb5,
	0xc7, 0xc0, 0x1d, 0x56, 0x35, 0x1e, 0x60, 0x78, 0x05, 0x9a, 0x98, 0x70, 0x21, 0x3d, 0x63, 0x9a,
	0x16, 0x56, 0x2a, 0xae, 0xb3, 0x93, 0xcf, 0x3b, 0xd0, 0x2d, 0xf8, 0xb7, 0x1f, 0xc4, 0xeb, 0x6f,
	0x18, 0x9e, 0x81, 0xf6, 0xaf, 0x4e, 0x34, 0x15, 0xcc, 0x0f, 0x85, 0xe7, 0x63, 0xcc, 0x08, 0xe7,
	0x66, 0x45, 0x0d, 0xa0, 0xb5, 0x5a, 0xb9, 0x94, 0x9c, 0x6b, 0xc5, 0xfa, 0x58, 0x9c, 0xcb, 0xb7,
	0xdc, 0x32, 0x66, 0xb9, 0x65, 0x7c, 0xe6, 0x96, 0xf1, 0xbc, 0xb0, 0x4a, 0xb3, 0x85, 0x55, 0xfa,
	0x58, 0x58, 0xa5, 0xbb, 0xa3, 0x28, 0x16, 0xa3, 0x2c, 0xb0, 0x43, 0x9a, 0x20, 0xb9, 0x10, 0xea,
	0x63, 0x43, 0x3a, 0x46, 0x2a, 0x3f, 0x9a, 0xf6, 0xd1, 0x83, 0x5a, 0x23, 0xf1, 0x38, 0x21, 0x3c,
	0xf8, 0xaf, 0x70, 0xff, 0x2b, 0x00, 0x00, 0xff, 0xff, 0x99, 0x9c, 0xcb, 0xbf, 0x5f, 0x02, 0x00,
	0x00,
}

func (m *DirectOriginator) 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 *DirectOriginator) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DirectOriginator) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Memo) > 0 {
		i -= len(m.Memo)
		copy(dAtA[i:], m.Memo)
		i = encodeVarintOriginator(dAtA, i, uint64(len(m.Memo)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Requester) > 0 {
		i -= len(m.Requester)
		copy(dAtA[i:], m.Requester)
		i = encodeVarintOriginator(dAtA, i, uint64(len(m.Requester)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.SourceChainID) > 0 {
		i -= len(m.SourceChainID)
		copy(dAtA[i:], m.SourceChainID)
		i = encodeVarintOriginator(dAtA, i, uint64(len(m.SourceChainID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *TunnelOriginator) 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 *TunnelOriginator) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TunnelOriginator) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.DestinationContractAddress) > 0 {
		i -= len(m.DestinationContractAddress)
		copy(dAtA[i:], m.DestinationContractAddress)
		i = encodeVarintOriginator(dAtA, i, uint64(len(m.DestinationContractAddress)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.DestinationChainID) > 0 {
		i -= len(m.DestinationChainID)
		copy(dAtA[i:], m.DestinationChainID)
		i = encodeVarintOriginator(dAtA, i, uint64(len(m.DestinationChainID)))
		i--
		dAtA[i] = 0x1a
	}
	if m.TunnelID != 0 {
		i = encodeVarintOriginator(dAtA, i, uint64(m.TunnelID))
		i--
		dAtA[i] = 0x10
	}
	if len(m.SourceChainID) > 0 {
		i -= len(m.SourceChainID)
		copy(dAtA[i:], m.SourceChainID)
		i = encodeVarintOriginator(dAtA, i, uint64(len(m.SourceChainID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func encodeVarintOriginator(dAtA []byte, offset int, v uint64) int {
	offset -= sovOriginator(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *DirectOriginator) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.SourceChainID)
	if l > 0 {
		n += 1 + l + sovOriginator(uint64(l))
	}
	l = len(m.Requester)
	if l > 0 {
		n += 1 + l + sovOriginator(uint64(l))
	}
	l = len(m.Memo)
	if l > 0 {
		n += 1 + l + sovOriginator(uint64(l))
	}
	return n
}

func (m *TunnelOriginator) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.SourceChainID)
	if l > 0 {
		n += 1 + l + sovOriginator(uint64(l))
	}
	if m.TunnelID != 0 {
		n += 1 + sovOriginator(uint64(m.TunnelID))
	}
	l = len(m.DestinationChainID)
	if l > 0 {
		n += 1 + l + sovOriginator(uint64(l))
	}
	l = len(m.DestinationContractAddress)
	if l > 0 {
		n += 1 + l + sovOriginator(uint64(l))
	}
	return n
}

func sovOriginator(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozOriginator(x uint64) (n int) {
	return sovOriginator(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *DirectOriginator) 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 ErrIntOverflowOriginator
			}
			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: DirectOriginator: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DirectOriginator: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SourceChainID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOriginator
				}
				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 ErrInvalidLengthOriginator
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthOriginator
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SourceChainID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Requester", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOriginator
				}
				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 ErrInvalidLengthOriginator
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthOriginator
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Requester = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Memo", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOriginator
				}
				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 ErrInvalidLengthOriginator
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthOriginator
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Memo = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipOriginator(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthOriginator
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TunnelOriginator) 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 ErrIntOverflowOriginator
			}
			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: TunnelOriginator: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TunnelOriginator: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SourceChainID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOriginator
				}
				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 ErrInvalidLengthOriginator
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthOriginator
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SourceChainID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TunnelID", wireType)
			}
			m.TunnelID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOriginator
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TunnelID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DestinationChainID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOriginator
				}
				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 ErrInvalidLengthOriginator
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthOriginator
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DestinationChainID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DestinationContractAddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOriginator
				}
				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 ErrInvalidLengthOriginator
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthOriginator
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DestinationContractAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipOriginator(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthOriginator
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipOriginator(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, ErrIntOverflowOriginator
			}
			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, ErrIntOverflowOriginator
				}
				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, ErrIntOverflowOriginator
				}
				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, ErrInvalidLengthOriginator
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupOriginator
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthOriginator
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthOriginator        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowOriginator          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupOriginator = fmt.Errorf("proto: unexpected end of group")
)
