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

package testcase

import (
	encoding_binary "encoding/binary"
	fmt "fmt"
	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 Number struct {
	Field1  int32   `protobuf:"varint,1,opt,name=field1,proto3" json:"field1,omitempty"`
	Field2  int64   `protobuf:"varint,2,opt,name=field2,proto3" json:"field2,omitempty"`
	Field3  uint32  `protobuf:"varint,3,opt,name=field3,proto3" json:"field3,omitempty"`
	Field4  uint64  `protobuf:"varint,4,opt,name=field4,proto3" json:"field4,omitempty"`
	Field5  int32   `protobuf:"zigzag32,5,opt,name=field5,proto3" json:"field5,omitempty"`
	Field6  int64   `protobuf:"zigzag64,6,opt,name=field6,proto3" json:"field6,omitempty"`
	Field7  bool    `protobuf:"varint,7,opt,name=field7,proto3" json:"field7,omitempty"`
	Field8  float32 `protobuf:"fixed32,8,opt,name=field8,proto3" json:"field8,omitempty"`
	Field9  float64 `protobuf:"fixed64,9,opt,name=field9,proto3" json:"field9,omitempty"`
	Field10 uint32  `protobuf:"fixed32,10,opt,name=field10,proto3" json:"field10,omitempty"`
	Field11 uint64  `protobuf:"fixed64,11,opt,name=field11,proto3" json:"field11,omitempty"`
	Field12 int32   `protobuf:"fixed32,12,opt,name=field12,proto3" json:"field12,omitempty"`
	Field13 int64   `protobuf:"fixed64,13,opt,name=field13,proto3" json:"field13,omitempty"`
}

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

var xxx_messageInfo_Number proto.InternalMessageInfo

func (m *Number) GetField1() int32 {
	if m != nil {
		return m.Field1
	}
	return 0
}

func (m *Number) GetField2() int64 {
	if m != nil {
		return m.Field2
	}
	return 0
}

func (m *Number) GetField3() uint32 {
	if m != nil {
		return m.Field3
	}
	return 0
}

func (m *Number) GetField4() uint64 {
	if m != nil {
		return m.Field4
	}
	return 0
}

func (m *Number) GetField5() int32 {
	if m != nil {
		return m.Field5
	}
	return 0
}

func (m *Number) GetField6() int64 {
	if m != nil {
		return m.Field6
	}
	return 0
}

func (m *Number) GetField7() bool {
	if m != nil {
		return m.Field7
	}
	return false
}

func (m *Number) GetField8() float32 {
	if m != nil {
		return m.Field8
	}
	return 0
}

func (m *Number) GetField9() float64 {
	if m != nil {
		return m.Field9
	}
	return 0
}

func (m *Number) GetField10() uint32 {
	if m != nil {
		return m.Field10
	}
	return 0
}

func (m *Number) GetField11() uint64 {
	if m != nil {
		return m.Field11
	}
	return 0
}

func (m *Number) GetField12() int32 {
	if m != nil {
		return m.Field12
	}
	return 0
}

func (m *Number) GetField13() int64 {
	if m != nil {
		return m.Field13
	}
	return 0
}

type String struct {
	Field1 string `protobuf:"bytes,1,opt,name=field1,proto3" json:"field1,omitempty"`
	Field2 []byte `protobuf:"bytes,2,opt,name=field2,proto3" json:"field2,omitempty"`
}

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

var xxx_messageInfo_String proto.InternalMessageInfo

func (m *String) GetField1() string {
	if m != nil {
		return m.Field1
	}
	return ""
}

func (m *String) GetField2() []byte {
	if m != nil {
		return m.Field2
	}
	return nil
}

type List struct {
	Field1  []int32   `protobuf:"varint,1,rep,packed,name=field1,proto3" json:"field1,omitempty"`
	Field2  []int64   `protobuf:"varint,2,rep,packed,name=field2,proto3" json:"field2,omitempty"`
	Field3  []uint32  `protobuf:"varint,3,rep,packed,name=field3,proto3" json:"field3,omitempty"`
	Field4  []uint64  `protobuf:"varint,4,rep,packed,name=field4,proto3" json:"field4,omitempty"`
	Field5  []int32   `protobuf:"zigzag32,5,rep,packed,name=field5,proto3" json:"field5,omitempty"`
	Field6  []int64   `protobuf:"zigzag64,6,rep,packed,name=field6,proto3" json:"field6,omitempty"`
	Field7  []bool    `protobuf:"varint,7,rep,packed,name=field7,proto3" json:"field7,omitempty"`
	Field8  []float32 `protobuf:"fixed32,8,rep,packed,name=field8,proto3" json:"field8,omitempty"`
	Field9  []float64 `protobuf:"fixed64,9,rep,packed,name=field9,proto3" json:"field9,omitempty"`
	Field10 []uint32  `protobuf:"fixed32,10,rep,packed,name=field10,proto3" json:"field10,omitempty"`
	Field11 []uint64  `protobuf:"fixed64,11,rep,packed,name=field11,proto3" json:"field11,omitempty"`
	Field12 []int32   `protobuf:"fixed32,12,rep,packed,name=field12,proto3" json:"field12,omitempty"`
	Field13 []int64   `protobuf:"fixed64,13,rep,packed,name=field13,proto3" json:"field13,omitempty"`
	Field14 []string  `protobuf:"bytes,14,rep,name=field14,proto3" json:"field14,omitempty"`
	Field15 [][]byte  `protobuf:"bytes,15,rep,name=field15,proto3" json:"field15,omitempty"`
}

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

var xxx_messageInfo_List proto.InternalMessageInfo

func (m *List) GetField1() []int32 {
	if m != nil {
		return m.Field1
	}
	return nil
}

func (m *List) GetField2() []int64 {
	if m != nil {
		return m.Field2
	}
	return nil
}

func (m *List) GetField3() []uint32 {
	if m != nil {
		return m.Field3
	}
	return nil
}

func (m *List) GetField4() []uint64 {
	if m != nil {
		return m.Field4
	}
	return nil
}

func (m *List) GetField5() []int32 {
	if m != nil {
		return m.Field5
	}
	return nil
}

func (m *List) GetField6() []int64 {
	if m != nil {
		return m.Field6
	}
	return nil
}

func (m *List) GetField7() []bool {
	if m != nil {
		return m.Field7
	}
	return nil
}

func (m *List) GetField8() []float32 {
	if m != nil {
		return m.Field8
	}
	return nil
}

func (m *List) GetField9() []float64 {
	if m != nil {
		return m.Field9
	}
	return nil
}

func (m *List) GetField10() []uint32 {
	if m != nil {
		return m.Field10
	}
	return nil
}

func (m *List) GetField11() []uint64 {
	if m != nil {
		return m.Field11
	}
	return nil
}

func (m *List) GetField12() []int32 {
	if m != nil {
		return m.Field12
	}
	return nil
}

func (m *List) GetField13() []int64 {
	if m != nil {
		return m.Field13
	}
	return nil
}

func (m *List) GetField14() []string {
	if m != nil {
		return m.Field14
	}
	return nil
}

func (m *List) GetField15() [][]byte {
	if m != nil {
		return m.Field15
	}
	return nil
}

type Map struct {
	Field1 map[int32]int64   `protobuf:"bytes,1,rep,name=field1,proto3" json:"field1,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
	Field2 map[uint32]uint64 `protobuf:"bytes,2,rep,name=field2,proto3" json:"field2,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
	Field3 map[int32]int64   `protobuf:"bytes,3,rep,name=field3,proto3" json:"field3,omitempty" protobuf_key:"zigzag32,1,opt,name=key,proto3" protobuf_val:"zigzag64,2,opt,name=value,proto3"`
	Field4 map[uint32]uint64 `protobuf:"bytes,4,rep,name=field4,proto3" json:"field4,omitempty" protobuf_key:"fixed32,1,opt,name=key,proto3" protobuf_val:"fixed64,2,opt,name=value,proto3"`
	Field5 map[int32]int64   `protobuf:"bytes,5,rep,name=field5,proto3" json:"field5,omitempty" protobuf_key:"fixed32,1,opt,name=key,proto3" protobuf_val:"fixed64,2,opt,name=value,proto3"`
	Field6 map[string][]byte `protobuf:"bytes,6,rep,name=field6,proto3" json:"field6,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}

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

var xxx_messageInfo_Map proto.InternalMessageInfo

func (m *Map) GetField1() map[int32]int64 {
	if m != nil {
		return m.Field1
	}
	return nil
}

func (m *Map) GetField2() map[uint32]uint64 {
	if m != nil {
		return m.Field2
	}
	return nil
}

func (m *Map) GetField3() map[int32]int64 {
	if m != nil {
		return m.Field3
	}
	return nil
}

func (m *Map) GetField4() map[uint32]uint64 {
	if m != nil {
		return m.Field4
	}
	return nil
}

func (m *Map) GetField5() map[int32]int64 {
	if m != nil {
		return m.Field5
	}
	return nil
}

func (m *Map) GetField6() map[string][]byte {
	if m != nil {
		return m.Field6
	}
	return nil
}

func init() {
	proto.RegisterType((*Number)(nil), "benchmark.Number")
	proto.RegisterType((*String)(nil), "benchmark.String")
	proto.RegisterType((*List)(nil), "benchmark.List")
	proto.RegisterType((*Map)(nil), "benchmark.Map")
	proto.RegisterMapType((map[int32]int64)(nil), "benchmark.Map.Field1Entry")
	proto.RegisterMapType((map[uint32]uint64)(nil), "benchmark.Map.Field2Entry")
	proto.RegisterMapType((map[int32]int64)(nil), "benchmark.Map.Field3Entry")
	proto.RegisterMapType((map[uint32]uint64)(nil), "benchmark.Map.Field4Entry")
	proto.RegisterMapType((map[int32]int64)(nil), "benchmark.Map.Field5Entry")
	proto.RegisterMapType((map[string][]byte)(nil), "benchmark.Map.Field6Entry")
}

func init() { proto.RegisterFile("testcase.proto", fileDescriptor_d7c4c3b74ab4cfaa) }

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

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

func (m *Number) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Field13 != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.Field13))
		i--
		dAtA[i] = 0x69
	}
	if m.Field12 != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(m.Field12))
		i--
		dAtA[i] = 0x65
	}
	if m.Field11 != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.Field11))
		i--
		dAtA[i] = 0x59
	}
	if m.Field10 != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(m.Field10))
		i--
		dAtA[i] = 0x55
	}
	if m.Field9 != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Field9))))
		i--
		dAtA[i] = 0x49
	}
	if m.Field8 != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Field8))))
		i--
		dAtA[i] = 0x45
	}
	if m.Field7 {
		i--
		if m.Field7 {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x38
	}
	if m.Field6 != 0 {
		i = encodeVarintTestcase(dAtA, i, uint64((uint64(m.Field6)<<1)^uint64((m.Field6>>63))))
		i--
		dAtA[i] = 0x30
	}
	if m.Field5 != 0 {
		i = encodeVarintTestcase(dAtA, i, uint64((uint32(m.Field5)<<1)^uint32((m.Field5>>31))))
		i--
		dAtA[i] = 0x28
	}
	if m.Field4 != 0 {
		i = encodeVarintTestcase(dAtA, i, uint64(m.Field4))
		i--
		dAtA[i] = 0x20
	}
	if m.Field3 != 0 {
		i = encodeVarintTestcase(dAtA, i, uint64(m.Field3))
		i--
		dAtA[i] = 0x18
	}
	if m.Field2 != 0 {
		i = encodeVarintTestcase(dAtA, i, uint64(m.Field2))
		i--
		dAtA[i] = 0x10
	}
	if m.Field1 != 0 {
		i = encodeVarintTestcase(dAtA, i, uint64(m.Field1))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *List) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Field15) > 0 {
		for iNdEx := len(m.Field15) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Field15[iNdEx])
			copy(dAtA[i:], m.Field15[iNdEx])
			i = encodeVarintTestcase(dAtA, i, uint64(len(m.Field15[iNdEx])))
			i--
			dAtA[i] = 0x7a
		}
	}
	if len(m.Field14) > 0 {
		for iNdEx := len(m.Field14) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Field14[iNdEx])
			copy(dAtA[i:], m.Field14[iNdEx])
			i = encodeVarintTestcase(dAtA, i, uint64(len(m.Field14[iNdEx])))
			i--
			dAtA[i] = 0x72
		}
	}
	if len(m.Field13) > 0 {
		for iNdEx := len(m.Field13) - 1; iNdEx >= 0; iNdEx-- {
			i -= 8
			encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.Field13[iNdEx]))
		}
		i = encodeVarintTestcase(dAtA, i, uint64(len(m.Field13)*8))
		i--
		dAtA[i] = 0x6a
	}
	if len(m.Field12) > 0 {
		for iNdEx := len(m.Field12) - 1; iNdEx >= 0; iNdEx-- {
			i -= 4
			encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(m.Field12[iNdEx]))
		}
		i = encodeVarintTestcase(dAtA, i, uint64(len(m.Field12)*4))
		i--
		dAtA[i] = 0x62
	}
	if len(m.Field11) > 0 {
		for iNdEx := len(m.Field11) - 1; iNdEx >= 0; iNdEx-- {
			i -= 8
			encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.Field11[iNdEx]))
		}
		i = encodeVarintTestcase(dAtA, i, uint64(len(m.Field11)*8))
		i--
		dAtA[i] = 0x5a
	}
	if len(m.Field10) > 0 {
		for iNdEx := len(m.Field10) - 1; iNdEx >= 0; iNdEx-- {
			i -= 4
			encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(m.Field10[iNdEx]))
		}
		i = encodeVarintTestcase(dAtA, i, uint64(len(m.Field10)*4))
		i--
		dAtA[i] = 0x52
	}
	if len(m.Field9) > 0 {
		for iNdEx := len(m.Field9) - 1; iNdEx >= 0; iNdEx-- {
			f1 := math.Float64bits(float64(m.Field9[iNdEx]))
			i -= 8
			encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(f1))
		}
		i = encodeVarintTestcase(dAtA, i, uint64(len(m.Field9)*8))
		i--
		dAtA[i] = 0x4a
	}
	if len(m.Field8) > 0 {
		for iNdEx := len(m.Field8) - 1; iNdEx >= 0; iNdEx-- {
			f2 := math.Float32bits(float32(m.Field8[iNdEx]))
			i -= 4
			encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(f2))
		}
		i = encodeVarintTestcase(dAtA, i, uint64(len(m.Field8)*4))
		i--
		dAtA[i] = 0x42
	}
	if len(m.Field7) > 0 {
		for iNdEx := len(m.Field7) - 1; iNdEx >= 0; iNdEx-- {
			i--
			if m.Field7[iNdEx] {
				dAtA[i] = 1
			} else {
				dAtA[i] = 0
			}
		}
		i = encodeVarintTestcase(dAtA, i, uint64(len(m.Field7)))
		i--
		dAtA[i] = 0x3a
	}
	if len(m.Field6) > 0 {
		var j3 int
		dAtA5 := make([]byte, len(m.Field6)*10)
		for _, num := range m.Field6 {
			x4 := (uint64(num) << 1) ^ uint64((num >> 63))
			for x4 >= 1<<7 {
				dAtA5[j3] = uint8(uint64(x4)&0x7f | 0x80)
				j3++
				x4 >>= 7
			}
			dAtA5[j3] = uint8(x4)
			j3++
		}
		i -= j3
		copy(dAtA[i:], dAtA5[:j3])
		i = encodeVarintTestcase(dAtA, i, uint64(j3))
		i--
		dAtA[i] = 0x32
	}
	if len(m.Field5) > 0 {
		dAtA6 := make([]byte, len(m.Field5)*5)
		var j7 int
		for _, num := range m.Field5 {
			x8 := (uint32(num) << 1) ^ uint32((num >> 31))
			for x8 >= 1<<7 {
				dAtA6[j7] = uint8(uint64(x8)&0x7f | 0x80)
				j7++
				x8 >>= 7
			}
			dAtA6[j7] = uint8(x8)
			j7++
		}
		i -= j7
		copy(dAtA[i:], dAtA6[:j7])
		i = encodeVarintTestcase(dAtA, i, uint64(j7))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Field4) > 0 {
		dAtA10 := make([]byte, len(m.Field4)*10)
		var j9 int
		for _, num := range m.Field4 {
			for num >= 1<<7 {
				dAtA10[j9] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j9++
			}
			dAtA10[j9] = uint8(num)
			j9++
		}
		i -= j9
		copy(dAtA[i:], dAtA10[:j9])
		i = encodeVarintTestcase(dAtA, i, uint64(j9))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Field3) > 0 {
		dAtA12 := make([]byte, len(m.Field3)*10)
		var j11 int
		for _, num := range m.Field3 {
			for num >= 1<<7 {
				dAtA12[j11] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j11++
			}
			dAtA12[j11] = uint8(num)
			j11++
		}
		i -= j11
		copy(dAtA[i:], dAtA12[:j11])
		i = encodeVarintTestcase(dAtA, i, uint64(j11))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Field2) > 0 {
		dAtA14 := make([]byte, len(m.Field2)*10)
		var j13 int
		for _, num1 := range m.Field2 {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA14[j13] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j13++
			}
			dAtA14[j13] = uint8(num)
			j13++
		}
		i -= j13
		copy(dAtA[i:], dAtA14[:j13])
		i = encodeVarintTestcase(dAtA, i, uint64(j13))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Field1) > 0 {
		dAtA16 := make([]byte, len(m.Field1)*10)
		var j15 int
		for _, num1 := range m.Field1 {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA16[j15] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j15++
			}
			dAtA16[j15] = uint8(num)
			j15++
		}
		i -= j15
		copy(dAtA[i:], dAtA16[:j15])
		i = encodeVarintTestcase(dAtA, i, uint64(j15))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *Map) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Field6) > 0 {
		for k := range m.Field6 {
			v := m.Field6[k]
			baseI := i
			if len(v) > 0 {
				i -= len(v)
				copy(dAtA[i:], v)
				i = encodeVarintTestcase(dAtA, i, uint64(len(v)))
				i--
				dAtA[i] = 0x12
			}
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintTestcase(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintTestcase(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x32
		}
	}
	if len(m.Field5) > 0 {
		for k := range m.Field5 {
			v := m.Field5[k]
			baseI := i
			i -= 8
			encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(v))
			i--
			dAtA[i] = 0x11
			i -= 4
			encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(k))
			i--
			dAtA[i] = 0xd
			i = encodeVarintTestcase(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x2a
		}
	}
	if len(m.Field4) > 0 {
		for k := range m.Field4 {
			v := m.Field4[k]
			baseI := i
			i -= 8
			encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(v))
			i--
			dAtA[i] = 0x11
			i -= 4
			encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(k))
			i--
			dAtA[i] = 0xd
			i = encodeVarintTestcase(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.Field3) > 0 {
		for k := range m.Field3 {
			v := m.Field3[k]
			baseI := i
			i = encodeVarintTestcase(dAtA, i, uint64((uint64(v)<<1)^uint64((v>>63))))
			i--
			dAtA[i] = 0x10
			i = encodeVarintTestcase(dAtA, i, uint64((uint32(k)<<1)^uint32((k>>31))))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTestcase(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.Field2) > 0 {
		for k := range m.Field2 {
			v := m.Field2[k]
			baseI := i
			i = encodeVarintTestcase(dAtA, i, uint64(v))
			i--
			dAtA[i] = 0x10
			i = encodeVarintTestcase(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTestcase(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Field1) > 0 {
		for k := range m.Field1 {
			v := m.Field1[k]
			baseI := i
			i = encodeVarintTestcase(dAtA, i, uint64(v))
			i--
			dAtA[i] = 0x10
			i = encodeVarintTestcase(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTestcase(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func encodeVarintTestcase(dAtA []byte, offset int, v uint64) int {
	offset -= sovTestcase(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *Number) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Field1 != 0 {
		n += 1 + sovTestcase(uint64(m.Field1))
	}
	if m.Field2 != 0 {
		n += 1 + sovTestcase(uint64(m.Field2))
	}
	if m.Field3 != 0 {
		n += 1 + sovTestcase(uint64(m.Field3))
	}
	if m.Field4 != 0 {
		n += 1 + sovTestcase(uint64(m.Field4))
	}
	if m.Field5 != 0 {
		n += 1 + sozTestcase(uint64(m.Field5))
	}
	if m.Field6 != 0 {
		n += 1 + sozTestcase(uint64(m.Field6))
	}
	if m.Field7 {
		n += 2
	}
	if m.Field8 != 0 {
		n += 5
	}
	if m.Field9 != 0 {
		n += 9
	}
	if m.Field10 != 0 {
		n += 5
	}
	if m.Field11 != 0 {
		n += 9
	}
	if m.Field12 != 0 {
		n += 5
	}
	if m.Field13 != 0 {
		n += 9
	}
	return n
}

func (m *String) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Field1)
	if l > 0 {
		n += 1 + l + sovTestcase(uint64(l))
	}
	l = len(m.Field2)
	if l > 0 {
		n += 1 + l + sovTestcase(uint64(l))
	}
	return n
}

func (m *List) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Field1) > 0 {
		l = 0
		for _, e := range m.Field1 {
			l += sovTestcase(uint64(e))
		}
		n += 1 + sovTestcase(uint64(l)) + l
	}
	if len(m.Field2) > 0 {
		l = 0
		for _, e := range m.Field2 {
			l += sovTestcase(uint64(e))
		}
		n += 1 + sovTestcase(uint64(l)) + l
	}
	if len(m.Field3) > 0 {
		l = 0
		for _, e := range m.Field3 {
			l += sovTestcase(uint64(e))
		}
		n += 1 + sovTestcase(uint64(l)) + l
	}
	if len(m.Field4) > 0 {
		l = 0
		for _, e := range m.Field4 {
			l += sovTestcase(uint64(e))
		}
		n += 1 + sovTestcase(uint64(l)) + l
	}
	if len(m.Field5) > 0 {
		l = 0
		for _, e := range m.Field5 {
			l += sozTestcase(uint64(e))
		}
		n += 1 + sovTestcase(uint64(l)) + l
	}
	if len(m.Field6) > 0 {
		l = 0
		for _, e := range m.Field6 {
			l += sozTestcase(uint64(e))
		}
		n += 1 + sovTestcase(uint64(l)) + l
	}
	if len(m.Field7) > 0 {
		n += 1 + sovTestcase(uint64(len(m.Field7))) + len(m.Field7)*1
	}
	if len(m.Field8) > 0 {
		n += 1 + sovTestcase(uint64(len(m.Field8)*4)) + len(m.Field8)*4
	}
	if len(m.Field9) > 0 {
		n += 1 + sovTestcase(uint64(len(m.Field9)*8)) + len(m.Field9)*8
	}
	if len(m.Field10) > 0 {
		n += 1 + sovTestcase(uint64(len(m.Field10)*4)) + len(m.Field10)*4
	}
	if len(m.Field11) > 0 {
		n += 1 + sovTestcase(uint64(len(m.Field11)*8)) + len(m.Field11)*8
	}
	if len(m.Field12) > 0 {
		n += 1 + sovTestcase(uint64(len(m.Field12)*4)) + len(m.Field12)*4
	}
	if len(m.Field13) > 0 {
		n += 1 + sovTestcase(uint64(len(m.Field13)*8)) + len(m.Field13)*8
	}
	if len(m.Field14) > 0 {
		for _, s := range m.Field14 {
			l = len(s)
			n += 1 + l + sovTestcase(uint64(l))
		}
	}
	if len(m.Field15) > 0 {
		for _, b := range m.Field15 {
			l = len(b)
			n += 1 + l + sovTestcase(uint64(l))
		}
	}
	return n
}

func (m *Map) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Field1) > 0 {
		for k, v := range m.Field1 {
			_ = k
			_ = v
			mapEntrySize := 1 + sovTestcase(uint64(k)) + 1 + sovTestcase(uint64(v))
			n += mapEntrySize + 1 + sovTestcase(uint64(mapEntrySize))
		}
	}
	if len(m.Field2) > 0 {
		for k, v := range m.Field2 {
			_ = k
			_ = v
			mapEntrySize := 1 + sovTestcase(uint64(k)) + 1 + sovTestcase(uint64(v))
			n += mapEntrySize + 1 + sovTestcase(uint64(mapEntrySize))
		}
	}
	if len(m.Field3) > 0 {
		for k, v := range m.Field3 {
			_ = k
			_ = v
			mapEntrySize := 1 + sozTestcase(uint64(k)) + 1 + sozTestcase(uint64(v))
			n += mapEntrySize + 1 + sovTestcase(uint64(mapEntrySize))
		}
	}
	if len(m.Field4) > 0 {
		for k, v := range m.Field4 {
			_ = k
			_ = v
			mapEntrySize := 1 + 4 + 1 + 8
			n += mapEntrySize + 1 + sovTestcase(uint64(mapEntrySize))
		}
	}
	if len(m.Field5) > 0 {
		for k, v := range m.Field5 {
			_ = k
			_ = v
			mapEntrySize := 1 + 4 + 1 + 8
			n += mapEntrySize + 1 + sovTestcase(uint64(mapEntrySize))
		}
	}
	if len(m.Field6) > 0 {
		for k, v := range m.Field6 {
			_ = k
			_ = v
			l = 0
			if len(v) > 0 {
				l = 1 + len(v) + sovTestcase(uint64(len(v)))
			}
			mapEntrySize := 1 + len(k) + sovTestcase(uint64(len(k))) + l
			n += mapEntrySize + 1 + sovTestcase(uint64(mapEntrySize))
		}
	}
	return n
}

func sovTestcase(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozTestcase(x uint64) (n int) {
	return sovTestcase(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *Number) 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 ErrIntOverflowTestcase
			}
			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: Number: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Number: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType)
			}
			m.Field1 = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTestcase
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Field1 |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType)
			}
			m.Field2 = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTestcase
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Field2 |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType)
			}
			m.Field3 = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTestcase
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Field3 |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType)
			}
			m.Field4 = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTestcase
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Field4 |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Field5", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTestcase
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31))
			m.Field5 = v
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType)
			}
			var v uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTestcase
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63)
			m.Field6 = int64(v)
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTestcase
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Field7 = bool(v != 0)
		case 8:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Field8 = float32(math.Float32frombits(v))
		case 9:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field Field9", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.Field9 = float64(math.Float64frombits(v))
		case 10:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Field10", wireType)
			}
			m.Field10 = 0
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			m.Field10 = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
		case 11:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field Field11", wireType)
			}
			m.Field11 = 0
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			m.Field11 = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
		case 12:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Field12", wireType)
			}
			m.Field12 = 0
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			m.Field12 = int32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
		case 13:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType)
			}
			m.Field13 = 0
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			m.Field13 = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
		default:
			iNdEx = preIndex
			skippy, err := skipTestcase(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTestcase
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *String) 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 ErrIntOverflowTestcase
			}
			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: String: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: String: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTestcase
				}
				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 ErrInvalidLengthTestcase
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTestcase
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Field1 = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTestcase
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTestcase
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTestcase
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Field2 = append(m.Field2[:0], dAtA[iNdEx:postIndex]...)
			if m.Field2 == nil {
				m.Field2 = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTestcase(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTestcase
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *List) 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 ErrIntOverflowTestcase
			}
			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: List: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: List: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType == 0 {
				var v int32
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTestcase
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.Field1 = append(m.Field1, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTestcase
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTestcase
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTestcase
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.Field1) == 0 {
					m.Field1 = make([]int32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int32
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTestcase
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.Field1 = append(m.Field1, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType)
			}
		case 2:
			if wireType == 0 {
				var v int64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTestcase
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.Field2 = append(m.Field2, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTestcase
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTestcase
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTestcase
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.Field2) == 0 {
					m.Field2 = make([]int64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTestcase
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.Field2 = append(m.Field2, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType)
			}
		case 3:
			if wireType == 0 {
				var v uint32
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTestcase
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.Field3 = append(m.Field3, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTestcase
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTestcase
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTestcase
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.Field3) == 0 {
					m.Field3 = make([]uint32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint32
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTestcase
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.Field3 = append(m.Field3, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType)
			}
		case 4:
			if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTestcase
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.Field4 = append(m.Field4, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTestcase
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTestcase
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTestcase
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.Field4) == 0 {
					m.Field4 = make([]uint64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTestcase
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.Field4 = append(m.Field4, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType)
			}
		case 5:
			if wireType == 0 {
				var v int32
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTestcase
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31))
				m.Field5 = append(m.Field5, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTestcase
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTestcase
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTestcase
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.Field5) == 0 {
					m.Field5 = make([]int32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int32
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTestcase
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31))
					m.Field5 = append(m.Field5, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Field5", wireType)
			}
		case 6:
			if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTestcase
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63)
				m.Field6 = append(m.Field6, int64(v))
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTestcase
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTestcase
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTestcase
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.Field6) == 0 {
					m.Field6 = make([]int64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTestcase
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63)
					m.Field6 = append(m.Field6, int64(v))
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType)
			}
		case 7:
			if wireType == 0 {
				var v int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTestcase
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.Field7 = append(m.Field7, bool(v != 0))
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTestcase
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTestcase
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTestcase
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen
				if elementCount != 0 && len(m.Field7) == 0 {
					m.Field7 = make([]bool, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTestcase
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.Field7 = append(m.Field7, bool(v != 0))
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType)
			}
		case 8:
			if wireType == 5 {
				var v uint32
				if (iNdEx + 4) > l {
					return io.ErrUnexpectedEOF
				}
				v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
				iNdEx += 4
				v2 := float32(math.Float32frombits(v))
				m.Field8 = append(m.Field8, v2)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTestcase
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTestcase
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTestcase
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen / 4
				if elementCount != 0 && len(m.Field8) == 0 {
					m.Field8 = make([]float32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint32
					if (iNdEx + 4) > l {
						return io.ErrUnexpectedEOF
					}
					v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
					iNdEx += 4
					v2 := float32(math.Float32frombits(v))
					m.Field8 = append(m.Field8, v2)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType)
			}
		case 9:
			if wireType == 1 {
				var v uint64
				if (iNdEx + 8) > l {
					return io.ErrUnexpectedEOF
				}
				v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
				iNdEx += 8
				v2 := float64(math.Float64frombits(v))
				m.Field9 = append(m.Field9, v2)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTestcase
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTestcase
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTestcase
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen / 8
				if elementCount != 0 && len(m.Field9) == 0 {
					m.Field9 = make([]float64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					if (iNdEx + 8) > l {
						return io.ErrUnexpectedEOF
					}
					v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
					iNdEx += 8
					v2 := float64(math.Float64frombits(v))
					m.Field9 = append(m.Field9, v2)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Field9", wireType)
			}
		case 10:
			if wireType == 5 {
				var v uint32
				if (iNdEx + 4) > l {
					return io.ErrUnexpectedEOF
				}
				v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
				iNdEx += 4
				m.Field10 = append(m.Field10, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTestcase
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTestcase
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTestcase
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen / 4
				if elementCount != 0 && len(m.Field10) == 0 {
					m.Field10 = make([]uint32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint32
					if (iNdEx + 4) > l {
						return io.ErrUnexpectedEOF
					}
					v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
					iNdEx += 4
					m.Field10 = append(m.Field10, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Field10", wireType)
			}
		case 11:
			if wireType == 1 {
				var v uint64
				if (iNdEx + 8) > l {
					return io.ErrUnexpectedEOF
				}
				v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
				iNdEx += 8
				m.Field11 = append(m.Field11, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTestcase
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTestcase
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTestcase
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen / 8
				if elementCount != 0 && len(m.Field11) == 0 {
					m.Field11 = make([]uint64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					if (iNdEx + 8) > l {
						return io.ErrUnexpectedEOF
					}
					v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
					iNdEx += 8
					m.Field11 = append(m.Field11, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Field11", wireType)
			}
		case 12:
			if wireType == 5 {
				var v int32
				if (iNdEx + 4) > l {
					return io.ErrUnexpectedEOF
				}
				v = int32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
				iNdEx += 4
				m.Field12 = append(m.Field12, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTestcase
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTestcase
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTestcase
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen / 4
				if elementCount != 0 && len(m.Field12) == 0 {
					m.Field12 = make([]int32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int32
					if (iNdEx + 4) > l {
						return io.ErrUnexpectedEOF
					}
					v = int32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
					iNdEx += 4
					m.Field12 = append(m.Field12, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Field12", wireType)
			}
		case 13:
			if wireType == 1 {
				var v int64
				if (iNdEx + 8) > l {
					return io.ErrUnexpectedEOF
				}
				v = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
				iNdEx += 8
				m.Field13 = append(m.Field13, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTestcase
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTestcase
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTestcase
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen / 8
				if elementCount != 0 && len(m.Field13) == 0 {
					m.Field13 = make([]int64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int64
					if (iNdEx + 8) > l {
						return io.ErrUnexpectedEOF
					}
					v = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
					iNdEx += 8
					m.Field13 = append(m.Field13, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType)
			}
		case 14:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTestcase
				}
				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 ErrInvalidLengthTestcase
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTestcase
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Field14 = append(m.Field14, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTestcase
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTestcase
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTestcase
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Field15 = append(m.Field15, make([]byte, postIndex-iNdEx))
			copy(m.Field15[len(m.Field15)-1], dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTestcase(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTestcase
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Map) 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 ErrIntOverflowTestcase
			}
			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: Map: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Map: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTestcase
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTestcase
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTestcase
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Field1 == nil {
				m.Field1 = 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 ErrIntOverflowTestcase
					}
					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 ErrIntOverflowTestcase
						}
						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 ErrIntOverflowTestcase
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapvalue |= int64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTestcase(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthTestcase
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Field1[mapkey] = mapvalue
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTestcase
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTestcase
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTestcase
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Field2 == nil {
				m.Field2 = make(map[uint32]uint64)
			}
			var mapkey uint32
			var mapvalue uint64
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTestcase
					}
					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 ErrIntOverflowTestcase
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= uint32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTestcase
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapvalue |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTestcase(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthTestcase
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Field2[mapkey] = mapvalue
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTestcase
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTestcase
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTestcase
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Field3 == nil {
				m.Field3 = 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 ErrIntOverflowTestcase
					}
					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 {
					var mapkeytemp int32
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTestcase
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkeytemp |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					mapkeytemp = int32((uint32(mapkeytemp) >> 1) ^ uint32(((mapkeytemp&1)<<31)>>31))
					mapkey = int32(mapkeytemp)
				} else if fieldNum == 2 {
					var mapvaluetemp uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTestcase
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapvaluetemp |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					mapvaluetemp = (mapvaluetemp >> 1) ^ uint64((int64(mapvaluetemp&1)<<63)>>63)
					mapvalue = int64(mapvaluetemp)
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTestcase(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthTestcase
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Field3[mapkey] = mapvalue
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTestcase
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTestcase
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTestcase
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Field4 == nil {
				m.Field4 = make(map[uint32]uint64)
			}
			var mapkey uint32
			var mapvalue uint64
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTestcase
					}
					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 {
					if (iNdEx + 4) > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
					iNdEx += 4
				} else if fieldNum == 2 {
					if (iNdEx + 8) > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
					iNdEx += 8
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTestcase(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthTestcase
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Field4[mapkey] = mapvalue
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Field5", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTestcase
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTestcase
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTestcase
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Field5 == nil {
				m.Field5 = 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 ErrIntOverflowTestcase
					}
					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 {
					if (iNdEx + 4) > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = int32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
					iNdEx += 4
				} else if fieldNum == 2 {
					if (iNdEx + 8) > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
					iNdEx += 8
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTestcase(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthTestcase
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Field5[mapkey] = mapvalue
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTestcase
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTestcase
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTestcase
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Field6 == nil {
				m.Field6 = make(map[string][]byte)
			}
			var mapkey string
			mapvalue := []byte{}
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTestcase
					}
					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 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTestcase
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthTestcase
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthTestcase
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var mapbyteLen uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTestcase
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapbyteLen |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intMapbyteLen := int(mapbyteLen)
					if intMapbyteLen < 0 {
						return ErrInvalidLengthTestcase
					}
					postbytesIndex := iNdEx + intMapbyteLen
					if postbytesIndex < 0 {
						return ErrInvalidLengthTestcase
					}
					if postbytesIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = make([]byte, mapbyteLen)
					copy(mapvalue, dAtA[iNdEx:postbytesIndex])
					iNdEx = postbytesIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTestcase(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthTestcase
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Field6[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTestcase(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTestcase
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

var (
	ErrInvalidLengthTestcase        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowTestcase          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupTestcase = fmt.Errorf("proto: unexpected end of group")
)
