openbilibili/app/service/openplatform/ticket-item/api/grpc/v1/ticket.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: app/service/openplatform/ticket-item/api/grpc/v1/ticket.proto

package v1

import proto "github.com/gogo/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/gogo/protobuf/gogoproto"

import io "io"

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

// The response message containing the TicketInfo
type TicketInfo struct {
	ID   int64  `protobuf:"varint,1,opt,name=id,proto3" json:"id" validate:"min=1"`
	Desc string `protobuf:"bytes,2,opt,name=desc,proto3" json:"name"`
	// 票类型：1-单场票 2-通票 3-联票
	Type int32 `protobuf:"varint,3,opt,name=type,proto3" json:"type" validate:"min=0"`
	// 售卖类型 1-预售票 2-现场票
	SaleType     int32              `protobuf:"varint,4,opt,name=sale_type,json=saleType,proto3" json:"stype" validate:"min=0"`
	LinkSc       string             `protobuf:"bytes,5,opt,name=link_sc,json=linkSc,proto3" json:"lk_screen"`
	LinkTicketID string             `protobuf:"bytes,6,opt,name=link_ticket_id,json=linkTicketId,proto3" json:"lk_ticket"`
	Symbol       string             `protobuf:"bytes,7,opt,name=symbol,proto3" json:"symbol"`
	Color        string             `protobuf:"bytes,8,opt,name=color,proto3" json:"color"`
	BuyLimit     int32              `protobuf:"varint,9,opt,name=buy_limit,json=buyLimit,proto3" json:"buy_limit" validate:"min=0"`
	DescDetail   string             `protobuf:"bytes,10,opt,name=desc_detail,json=descDetail,proto3" json:"desc"`
	SaleFlag     int32              `protobuf:"varint,11,opt,name=sale_flag,json=saleFlag,proto3" json:"sale_flag" validate:"min=0"`
	PriceList    *TicketPriceList   `protobuf:"bytes,12,opt,name=price_list,json=priceList" json:"price"`
	StatusList   *TicketStatus      `protobuf:"bytes,13,opt,name=status_list,json=statusList" json:"status"`
	Time         *TicketTime        `protobuf:"bytes,14,opt,name=time" json:"time"`
	BuyNumLimit  *TicketBuyNumLimit `protobuf:"bytes,15,opt,name=buy_num_limit,json=buyNumLimit" json:"buy_num_limit"`
}

func (m *TicketInfo) Reset()                    { *m = TicketInfo{} }
func (m *TicketInfo) String() string            { return proto.CompactTextString(m) }
func (*TicketInfo) ProtoMessage()               {}
func (*TicketInfo) Descriptor() ([]byte, []int) { return fileDescriptorTicket, []int{0} }

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

func (m *TicketInfo) GetDesc() string {
	if m != nil {
		return m.Desc
	}
	return ""
}

func (m *TicketInfo) GetType() int32 {
	if m != nil {
		return m.Type
	}
	return 0
}

func (m *TicketInfo) GetSaleType() int32 {
	if m != nil {
		return m.SaleType
	}
	return 0
}

func (m *TicketInfo) GetLinkSc() string {
	if m != nil {
		return m.LinkSc
	}
	return ""
}

func (m *TicketInfo) GetLinkTicketID() string {
	if m != nil {
		return m.LinkTicketID
	}
	return ""
}

func (m *TicketInfo) GetSymbol() string {
	if m != nil {
		return m.Symbol
	}
	return ""
}

func (m *TicketInfo) GetColor() string {
	if m != nil {
		return m.Color
	}
	return ""
}

func (m *TicketInfo) GetBuyLimit() int32 {
	if m != nil {
		return m.BuyLimit
	}
	return 0
}

func (m *TicketInfo) GetDescDetail() string {
	if m != nil {
		return m.DescDetail
	}
	return ""
}

func (m *TicketInfo) GetSaleFlag() int32 {
	if m != nil {
		return m.SaleFlag
	}
	return 0
}

func (m *TicketInfo) GetPriceList() *TicketPriceList {
	if m != nil {
		return m.PriceList
	}
	return nil
}

func (m *TicketInfo) GetStatusList() *TicketStatus {
	if m != nil {
		return m.StatusList
	}
	return nil
}

func (m *TicketInfo) GetTime() *TicketTime {
	if m != nil {
		return m.Time
	}
	return nil
}

func (m *TicketInfo) GetBuyNumLimit() *TicketBuyNumLimit {
	if m != nil {
		return m.BuyNumLimit
	}
	return nil
}

type TicketBuyNumLimit struct {
	Normal    map[int32]int64 `protobuf:"bytes,1,rep,name=normal" json:"normal" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
	Vip       map[int32]int64 `protobuf:"bytes,2,rep,name=vip" json:"vip" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
	AnnualVip map[int32]int64 `protobuf:"bytes,3,rep,name=annual_vip,json=annualVip" json:"annual_vip" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
}

func (m *TicketBuyNumLimit) Reset()                    { *m = TicketBuyNumLimit{} }
func (m *TicketBuyNumLimit) String() string            { return proto.CompactTextString(m) }
func (*TicketBuyNumLimit) ProtoMessage()               {}
func (*TicketBuyNumLimit) Descriptor() ([]byte, []int) { return fileDescriptorTicket, []int{1} }

func (m *TicketBuyNumLimit) GetNormal() map[int32]int64 {
	if m != nil {
		return m.Normal
	}
	return nil
}

func (m *TicketBuyNumLimit) GetVip() map[int32]int64 {
	if m != nil {
		return m.Vip
	}
	return nil
}

func (m *TicketBuyNumLimit) GetAnnualVip() map[int32]int64 {
	if m != nil {
		return m.AnnualVip
	}
	return nil
}

// The response message containing the IsSale IsVisible IsRefund
type TicketStatus struct {
	IsSale    int32 `protobuf:"varint,1,opt,name=is_sale,json=isSale,proto3" json:"is_sale" validate:"min=0"`
	IsVisible int32 `protobuf:"varint,2,opt,name=is_visible,json=isVisible,proto3" json:"is_visible" validate:"min=0"`
	IsRefund  int32 `protobuf:"varint,3,opt,name=is_refund,json=isRefund,proto3" json:"is_refund" validate:"min=0"`
}

func (m *TicketStatus) Reset()                    { *m = TicketStatus{} }
func (m *TicketStatus) String() string            { return proto.CompactTextString(m) }
func (*TicketStatus) ProtoMessage()               {}
func (*TicketStatus) Descriptor() ([]byte, []int) { return fileDescriptorTicket, []int{2} }

func (m *TicketStatus) GetIsSale() int32 {
	if m != nil {
		return m.IsSale
	}
	return 0
}

func (m *TicketStatus) GetIsVisible() int32 {
	if m != nil {
		return m.IsVisible
	}
	return 0
}

func (m *TicketStatus) GetIsRefund() int32 {
	if m != nil {
		return m.IsRefund
	}
	return 0
}

// The response message containing the Price OriginPrice MarketPrice
type TicketPriceList struct {
	Price    int32 `protobuf:"varint,1,opt,name=price,proto3" json:"price" validate:"min=0"`
	OriPrice int32 `protobuf:"varint,2,opt,name=ori_price,json=oriPrice,proto3" json:"oprice" validate:"min=0"`
	MktPrice int32 `protobuf:"varint,3,opt,name=mkt_price,json=mktPrice,proto3" json:"mprice" validate:"min=0"`
}

func (m *TicketPriceList) Reset()                    { *m = TicketPriceList{} }
func (m *TicketPriceList) String() string            { return proto.CompactTextString(m) }
func (*TicketPriceList) ProtoMessage()               {}
func (*TicketPriceList) Descriptor() ([]byte, []int) { return fileDescriptorTicket, []int{3} }

func (m *TicketPriceList) GetPrice() int32 {
	if m != nil {
		return m.Price
	}
	return 0
}

func (m *TicketPriceList) GetOriPrice() int32 {
	if m != nil {
		return m.OriPrice
	}
	return 0
}

func (m *TicketPriceList) GetMktPrice() int32 {
	if m != nil {
		return m.MktPrice
	}
	return 0
}

func init() {
	proto.RegisterType((*TicketInfo)(nil), "ticket.service.item.v1.TicketInfo")
	proto.RegisterType((*TicketBuyNumLimit)(nil), "ticket.service.item.v1.TicketBuyNumLimit")
	proto.RegisterType((*TicketStatus)(nil), "ticket.service.item.v1.TicketStatus")
	proto.RegisterType((*TicketPriceList)(nil), "ticket.service.item.v1.TicketPriceList")
}
func (m *TicketInfo) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *TicketInfo) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.ID != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintTicket(dAtA, i, uint64(m.ID))
	}
	if len(m.Desc) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintTicket(dAtA, i, uint64(len(m.Desc)))
		i += copy(dAtA[i:], m.Desc)
	}
	if m.Type != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintTicket(dAtA, i, uint64(m.Type))
	}
	if m.SaleType != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintTicket(dAtA, i, uint64(m.SaleType))
	}
	if len(m.LinkSc) > 0 {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintTicket(dAtA, i, uint64(len(m.LinkSc)))
		i += copy(dAtA[i:], m.LinkSc)
	}
	if len(m.LinkTicketID) > 0 {
		dAtA[i] = 0x32
		i++
		i = encodeVarintTicket(dAtA, i, uint64(len(m.LinkTicketID)))
		i += copy(dAtA[i:], m.LinkTicketID)
	}
	if len(m.Symbol) > 0 {
		dAtA[i] = 0x3a
		i++
		i = encodeVarintTicket(dAtA, i, uint64(len(m.Symbol)))
		i += copy(dAtA[i:], m.Symbol)
	}
	if len(m.Color) > 0 {
		dAtA[i] = 0x42
		i++
		i = encodeVarintTicket(dAtA, i, uint64(len(m.Color)))
		i += copy(dAtA[i:], m.Color)
	}
	if m.BuyLimit != 0 {
		dAtA[i] = 0x48
		i++
		i = encodeVarintTicket(dAtA, i, uint64(m.BuyLimit))
	}
	if len(m.DescDetail) > 0 {
		dAtA[i] = 0x52
		i++
		i = encodeVarintTicket(dAtA, i, uint64(len(m.DescDetail)))
		i += copy(dAtA[i:], m.DescDetail)
	}
	if m.SaleFlag != 0 {
		dAtA[i] = 0x58
		i++
		i = encodeVarintTicket(dAtA, i, uint64(m.SaleFlag))
	}
	if m.PriceList != nil {
		dAtA[i] = 0x62
		i++
		i = encodeVarintTicket(dAtA, i, uint64(m.PriceList.Size()))
		n1, err := m.PriceList.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n1
	}
	if m.StatusList != nil {
		dAtA[i] = 0x6a
		i++
		i = encodeVarintTicket(dAtA, i, uint64(m.StatusList.Size()))
		n2, err := m.StatusList.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n2
	}
	if m.Time != nil {
		dAtA[i] = 0x72
		i++
		i = encodeVarintTicket(dAtA, i, uint64(m.Time.Size()))
		n3, err := m.Time.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n3
	}
	if m.BuyNumLimit != nil {
		dAtA[i] = 0x7a
		i++
		i = encodeVarintTicket(dAtA, i, uint64(m.BuyNumLimit.Size()))
		n4, err := m.BuyNumLimit.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n4
	}
	return i, nil
}

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

func (m *TicketBuyNumLimit) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Normal) > 0 {
		for k, _ := range m.Normal {
			dAtA[i] = 0xa
			i++
			v := m.Normal[k]
			mapSize := 1 + sovTicket(uint64(k)) + 1 + sovTicket(uint64(v))
			i = encodeVarintTicket(dAtA, i, uint64(mapSize))
			dAtA[i] = 0x8
			i++
			i = encodeVarintTicket(dAtA, i, uint64(k))
			dAtA[i] = 0x10
			i++
			i = encodeVarintTicket(dAtA, i, uint64(v))
		}
	}
	if len(m.Vip) > 0 {
		for k, _ := range m.Vip {
			dAtA[i] = 0x12
			i++
			v := m.Vip[k]
			mapSize := 1 + sovTicket(uint64(k)) + 1 + sovTicket(uint64(v))
			i = encodeVarintTicket(dAtA, i, uint64(mapSize))
			dAtA[i] = 0x8
			i++
			i = encodeVarintTicket(dAtA, i, uint64(k))
			dAtA[i] = 0x10
			i++
			i = encodeVarintTicket(dAtA, i, uint64(v))
		}
	}
	if len(m.AnnualVip) > 0 {
		for k, _ := range m.AnnualVip {
			dAtA[i] = 0x1a
			i++
			v := m.AnnualVip[k]
			mapSize := 1 + sovTicket(uint64(k)) + 1 + sovTicket(uint64(v))
			i = encodeVarintTicket(dAtA, i, uint64(mapSize))
			dAtA[i] = 0x8
			i++
			i = encodeVarintTicket(dAtA, i, uint64(k))
			dAtA[i] = 0x10
			i++
			i = encodeVarintTicket(dAtA, i, uint64(v))
		}
	}
	return i, nil
}

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

func (m *TicketStatus) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.IsSale != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintTicket(dAtA, i, uint64(m.IsSale))
	}
	if m.IsVisible != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintTicket(dAtA, i, uint64(m.IsVisible))
	}
	if m.IsRefund != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintTicket(dAtA, i, uint64(m.IsRefund))
	}
	return i, nil
}

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

func (m *TicketPriceList) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Price != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintTicket(dAtA, i, uint64(m.Price))
	}
	if m.OriPrice != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintTicket(dAtA, i, uint64(m.OriPrice))
	}
	if m.MktPrice != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintTicket(dAtA, i, uint64(m.MktPrice))
	}
	return i, nil
}

func encodeVarintTicket(dAtA []byte, offset int, v uint64) int {
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return offset + 1
}
func (m *TicketInfo) Size() (n int) {
	var l int
	_ = l
	if m.ID != 0 {
		n += 1 + sovTicket(uint64(m.ID))
	}
	l = len(m.Desc)
	if l > 0 {
		n += 1 + l + sovTicket(uint64(l))
	}
	if m.Type != 0 {
		n += 1 + sovTicket(uint64(m.Type))
	}
	if m.SaleType != 0 {
		n += 1 + sovTicket(uint64(m.SaleType))
	}
	l = len(m.LinkSc)
	if l > 0 {
		n += 1 + l + sovTicket(uint64(l))
	}
	l = len(m.LinkTicketID)
	if l > 0 {
		n += 1 + l + sovTicket(uint64(l))
	}
	l = len(m.Symbol)
	if l > 0 {
		n += 1 + l + sovTicket(uint64(l))
	}
	l = len(m.Color)
	if l > 0 {
		n += 1 + l + sovTicket(uint64(l))
	}
	if m.BuyLimit != 0 {
		n += 1 + sovTicket(uint64(m.BuyLimit))
	}
	l = len(m.DescDetail)
	if l > 0 {
		n += 1 + l + sovTicket(uint64(l))
	}
	if m.SaleFlag != 0 {
		n += 1 + sovTicket(uint64(m.SaleFlag))
	}
	if m.PriceList != nil {
		l = m.PriceList.Size()
		n += 1 + l + sovTicket(uint64(l))
	}
	if m.StatusList != nil {
		l = m.StatusList.Size()
		n += 1 + l + sovTicket(uint64(l))
	}
	if m.Time != nil {
		l = m.Time.Size()
		n += 1 + l + sovTicket(uint64(l))
	}
	if m.BuyNumLimit != nil {
		l = m.BuyNumLimit.Size()
		n += 1 + l + sovTicket(uint64(l))
	}
	return n
}

func (m *TicketBuyNumLimit) Size() (n int) {
	var l int
	_ = l
	if len(m.Normal) > 0 {
		for k, v := range m.Normal {
			_ = k
			_ = v
			mapEntrySize := 1 + sovTicket(uint64(k)) + 1 + sovTicket(uint64(v))
			n += mapEntrySize + 1 + sovTicket(uint64(mapEntrySize))
		}
	}
	if len(m.Vip) > 0 {
		for k, v := range m.Vip {
			_ = k
			_ = v
			mapEntrySize := 1 + sovTicket(uint64(k)) + 1 + sovTicket(uint64(v))
			n += mapEntrySize + 1 + sovTicket(uint64(mapEntrySize))
		}
	}
	if len(m.AnnualVip) > 0 {
		for k, v := range m.AnnualVip {
			_ = k
			_ = v
			mapEntrySize := 1 + sovTicket(uint64(k)) + 1 + sovTicket(uint64(v))
			n += mapEntrySize + 1 + sovTicket(uint64(mapEntrySize))
		}
	}
	return n
}

func (m *TicketStatus) Size() (n int) {
	var l int
	_ = l
	if m.IsSale != 0 {
		n += 1 + sovTicket(uint64(m.IsSale))
	}
	if m.IsVisible != 0 {
		n += 1 + sovTicket(uint64(m.IsVisible))
	}
	if m.IsRefund != 0 {
		n += 1 + sovTicket(uint64(m.IsRefund))
	}
	return n
}

func (m *TicketPriceList) Size() (n int) {
	var l int
	_ = l
	if m.Price != 0 {
		n += 1 + sovTicket(uint64(m.Price))
	}
	if m.OriPrice != 0 {
		n += 1 + sovTicket(uint64(m.OriPrice))
	}
	if m.MktPrice != 0 {
		n += 1 + sovTicket(uint64(m.MktPrice))
	}
	return n
}

func sovTicket(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozTicket(x uint64) (n int) {
	return sovTicket(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *TicketInfo) 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 ErrIntOverflowTicket
			}
			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: TicketInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TicketInfo: 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 ErrIntOverflowTicket
				}
				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 Desc", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTicket
				}
				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 ErrInvalidLengthTicket
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Desc = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTicket
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SaleType", wireType)
			}
			m.SaleType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTicket
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SaleType |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LinkSc", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTicket
				}
				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 ErrInvalidLengthTicket
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LinkSc = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LinkTicketID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTicket
				}
				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 ErrInvalidLengthTicket
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LinkTicketID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Symbol", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTicket
				}
				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 ErrInvalidLengthTicket
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Symbol = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Color", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTicket
				}
				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 ErrInvalidLengthTicket
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Color = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BuyLimit", wireType)
			}
			m.BuyLimit = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTicket
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BuyLimit |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DescDetail", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTicket
				}
				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 ErrInvalidLengthTicket
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DescDetail = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SaleFlag", wireType)
			}
			m.SaleFlag = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTicket
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SaleFlag |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PriceList", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTicket
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTicket
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.PriceList == nil {
				m.PriceList = &TicketPriceList{}
			}
			if err := m.PriceList.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StatusList", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTicket
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTicket
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.StatusList == nil {
				m.StatusList = &TicketStatus{}
			}
			if err := m.StatusList.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 14:
			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 ErrIntOverflowTicket
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTicket
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Time == nil {
				m.Time = &TicketTime{}
			}
			if err := m.Time.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BuyNumLimit", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTicket
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTicket
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.BuyNumLimit == nil {
				m.BuyNumLimit = &TicketBuyNumLimit{}
			}
			if err := m.BuyNumLimit.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTicket(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthTicket
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TicketBuyNumLimit) 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 ErrIntOverflowTicket
			}
			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: TicketBuyNumLimit: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TicketBuyNumLimit: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Normal", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTicket
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTicket
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Normal == nil {
				m.Normal = make(map[int32]int64)
			}
			var mapkey int32
			var mapvalue int64
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTicket
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTicket
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= (int32(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTicket
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapvalue |= (int64(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTicket(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthTicket
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Normal[mapkey] = mapvalue
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Vip", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTicket
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTicket
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Vip == nil {
				m.Vip = make(map[int32]int64)
			}
			var mapkey int32
			var mapvalue int64
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTicket
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTicket
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= (int32(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTicket
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapvalue |= (int64(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTicket(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthTicket
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Vip[mapkey] = mapvalue
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AnnualVip", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTicket
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTicket
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.AnnualVip == nil {
				m.AnnualVip = make(map[int32]int64)
			}
			var mapkey int32
			var mapvalue int64
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTicket
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTicket
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= (int32(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTicket
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapvalue |= (int64(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTicket(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthTicket
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.AnnualVip[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTicket(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthTicket
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TicketStatus) 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 ErrIntOverflowTicket
			}
			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: TicketStatus: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TicketStatus: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsSale", wireType)
			}
			m.IsSale = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTicket
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.IsSale |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsVisible", wireType)
			}
			m.IsVisible = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTicket
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.IsVisible |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsRefund", wireType)
			}
			m.IsRefund = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTicket
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.IsRefund |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTicket(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthTicket
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TicketPriceList) 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 ErrIntOverflowTicket
			}
			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: TicketPriceList: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TicketPriceList: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Price", wireType)
			}
			m.Price = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTicket
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Price |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OriPrice", wireType)
			}
			m.OriPrice = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTicket
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.OriPrice |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MktPrice", wireType)
			}
			m.MktPrice = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTicket
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MktPrice |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTicket(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthTicket
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

func init() {
	proto.RegisterFile("app/service/openplatform/ticket-item/api/grpc/v1/ticket.proto", fileDescriptorTicket)
}

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