// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: app/service/openplatform/ticket-item/api/grpc/v1/screen.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 ScreenInfo
type ScreenInfo struct {
	ID     int64  `protobuf:"varint,1,opt,name=id,proto3" json:"id" validate:"min=0"`
	Name   string `protobuf:"bytes,2,opt,name=name,proto3" json:"name"`
	Status int32  `protobuf:"varint,3,opt,name=status,proto3" json:"status" validate:"min=0"`
	// 类型: 1-坐, 2-站
	Type int32 `protobuf:"varint,4,opt,name=type,proto3" json:"type" validate:"min=0"`
	// 出票方式: 1-纸质票, 2-电子票, 3-外部票
	TicketType int32 `protobuf:"varint,5,opt,name=ticket_type,json=ticketType,proto3" json:"ticket_type" validate:"min=0"`
	// 票区分的场次类型: 1-普通场次, 2-通票场次 3-联票场次
	ScreenType int32 `protobuf:"varint,6,opt,name=screen_type,json=screenType,proto3" json:"screen_type" validate:"min=0"`
	// 配送方式: 1-不配送, 2-自取, 3-快递
	DeliveryType int32 `protobuf:"varint,7,opt,name=delivery_type,json=deliveryType,proto3" json:"delivery_type" validate:"min=0"`
	// 是否选座 是-1，否-0
	PickSeat int32 `protobuf:"varint,8,opt,name=pick_seat,json=pickSeat,proto3" json:"pick_seat" validate:"min=0"`
	// 售卖状态
	SaleFlag int32                 `protobuf:"varint,9,opt,name=sale_flag,json=saleFlag,proto3" json:"sale_flag" validate:"min=0"`
	ScTime   *ScreenTime           `protobuf:"bytes,10,opt,name=sc_time,json=scTime" json:"time"`
	Ticket   map[int64]*TicketInfo `protobuf:"bytes,11,rep,name=Ticket" json:"ticket" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"`
}

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

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

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

func (m *ScreenInfo) GetStatus() int32 {
	if m != nil {
		return m.Status
	}
	return 0
}

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

func (m *ScreenInfo) GetTicketType() int32 {
	if m != nil {
		return m.TicketType
	}
	return 0
}

func (m *ScreenInfo) GetScreenType() int32 {
	if m != nil {
		return m.ScreenType
	}
	return 0
}

func (m *ScreenInfo) GetDeliveryType() int32 {
	if m != nil {
		return m.DeliveryType
	}
	return 0
}

func (m *ScreenInfo) GetPickSeat() int32 {
	if m != nil {
		return m.PickSeat
	}
	return 0
}

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

func (m *ScreenInfo) GetScTime() *ScreenTime {
	if m != nil {
		return m.ScTime
	}
	return nil
}

func (m *ScreenInfo) GetTicket() map[int64]*TicketInfo {
	if m != nil {
		return m.Ticket
	}
	return nil
}

func init() {
	proto.RegisterType((*ScreenInfo)(nil), "ticket.service.item.v1.ScreenInfo")
}
func (m *ScreenInfo) 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 *ScreenInfo) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.ID != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintScreen(dAtA, i, uint64(m.ID))
	}
	if len(m.Name) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintScreen(dAtA, i, uint64(len(m.Name)))
		i += copy(dAtA[i:], m.Name)
	}
	if m.Status != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintScreen(dAtA, i, uint64(m.Status))
	}
	if m.Type != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintScreen(dAtA, i, uint64(m.Type))
	}
	if m.TicketType != 0 {
		dAtA[i] = 0x28
		i++
		i = encodeVarintScreen(dAtA, i, uint64(m.TicketType))
	}
	if m.ScreenType != 0 {
		dAtA[i] = 0x30
		i++
		i = encodeVarintScreen(dAtA, i, uint64(m.ScreenType))
	}
	if m.DeliveryType != 0 {
		dAtA[i] = 0x38
		i++
		i = encodeVarintScreen(dAtA, i, uint64(m.DeliveryType))
	}
	if m.PickSeat != 0 {
		dAtA[i] = 0x40
		i++
		i = encodeVarintScreen(dAtA, i, uint64(m.PickSeat))
	}
	if m.SaleFlag != 0 {
		dAtA[i] = 0x48
		i++
		i = encodeVarintScreen(dAtA, i, uint64(m.SaleFlag))
	}
	if m.ScTime != nil {
		dAtA[i] = 0x52
		i++
		i = encodeVarintScreen(dAtA, i, uint64(m.ScTime.Size()))
		n1, err := m.ScTime.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n1
	}
	if len(m.Ticket) > 0 {
		for k, _ := range m.Ticket {
			dAtA[i] = 0x5a
			i++
			v := m.Ticket[k]
			msgSize := 0
			if v != nil {
				msgSize = v.Size()
				msgSize += 1 + sovScreen(uint64(msgSize))
			}
			mapSize := 1 + sovScreen(uint64(k)) + msgSize
			i = encodeVarintScreen(dAtA, i, uint64(mapSize))
			dAtA[i] = 0x8
			i++
			i = encodeVarintScreen(dAtA, i, uint64(k))
			if v != nil {
				dAtA[i] = 0x12
				i++
				i = encodeVarintScreen(dAtA, i, uint64(v.Size()))
				n2, err := v.MarshalTo(dAtA[i:])
				if err != nil {
					return 0, err
				}
				i += n2
			}
		}
	}
	return i, nil
}

func encodeVarintScreen(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 *ScreenInfo) Size() (n int) {
	var l int
	_ = l
	if m.ID != 0 {
		n += 1 + sovScreen(uint64(m.ID))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovScreen(uint64(l))
	}
	if m.Status != 0 {
		n += 1 + sovScreen(uint64(m.Status))
	}
	if m.Type != 0 {
		n += 1 + sovScreen(uint64(m.Type))
	}
	if m.TicketType != 0 {
		n += 1 + sovScreen(uint64(m.TicketType))
	}
	if m.ScreenType != 0 {
		n += 1 + sovScreen(uint64(m.ScreenType))
	}
	if m.DeliveryType != 0 {
		n += 1 + sovScreen(uint64(m.DeliveryType))
	}
	if m.PickSeat != 0 {
		n += 1 + sovScreen(uint64(m.PickSeat))
	}
	if m.SaleFlag != 0 {
		n += 1 + sovScreen(uint64(m.SaleFlag))
	}
	if m.ScTime != nil {
		l = m.ScTime.Size()
		n += 1 + l + sovScreen(uint64(l))
	}
	if len(m.Ticket) > 0 {
		for k, v := range m.Ticket {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovScreen(uint64(l))
			}
			mapEntrySize := 1 + sovScreen(uint64(k)) + l
			n += mapEntrySize + 1 + sovScreen(uint64(mapEntrySize))
		}
	}
	return n
}

func sovScreen(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozScreen(x uint64) (n int) {
	return sovScreen(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *ScreenInfo) 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 ErrIntOverflowScreen
			}
			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: ScreenInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ScreenInfo: 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 ErrIntOverflowScreen
				}
				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 ErrIntOverflowScreen
				}
				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 ErrInvalidLengthScreen
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			m.Status = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScreen
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Status |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			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 ErrIntOverflowScreen
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TicketType", wireType)
			}
			m.TicketType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScreen
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TicketType |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ScreenType", wireType)
			}
			m.ScreenType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScreen
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ScreenType |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DeliveryType", wireType)
			}
			m.DeliveryType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScreen
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DeliveryType |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PickSeat", wireType)
			}
			m.PickSeat = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScreen
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PickSeat |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			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 ErrIntOverflowScreen
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SaleFlag |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ScTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScreen
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthScreen
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ScTime == nil {
				m.ScTime = &ScreenTime{}
			}
			if err := m.ScTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ticket", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScreen
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthScreen
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Ticket == nil {
				m.Ticket = make(map[int64]*TicketInfo)
			}
			var mapkey int64
			var mapvalue *TicketInfo
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowScreen
					}
					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 ErrIntOverflowScreen
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= (int64(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowScreen
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= (int(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthScreen
					}
					postmsgIndex := iNdEx + mapmsglen
					if mapmsglen < 0 {
						return ErrInvalidLengthScreen
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &TicketInfo{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipScreen(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthScreen
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Ticket[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipScreen(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthScreen
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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