// Code generated by FastPB v0.0.1. DO NOT EDIT.

package testcase

import (
	fmt "fmt"
	fastpb "github.com/cloudwego/fastpb"
)

func (x *Number) FastRead(buf []byte, _type int8, number int32) (offset int, err error) {
	switch number {
	case 1:
		offset, err = x.fastReadField1(buf, _type)
		if err != nil {
			goto ReadFieldError
		}
	case 2:
		offset, err = x.fastReadField2(buf, _type)
		if err != nil {
			goto ReadFieldError
		}
	case 3:
		offset, err = x.fastReadField3(buf, _type)
		if err != nil {
			goto ReadFieldError
		}
	case 4:
		offset, err = x.fastReadField4(buf, _type)
		if err != nil {
			goto ReadFieldError
		}
	case 5:
		offset, err = x.fastReadField5(buf, _type)
		if err != nil {
			goto ReadFieldError
		}
	case 6:
		offset, err = x.fastReadField6(buf, _type)
		if err != nil {
			goto ReadFieldError
		}
	case 7:
		offset, err = x.fastReadField7(buf, _type)
		if err != nil {
			goto ReadFieldError
		}
	case 8:
		offset, err = x.fastReadField8(buf, _type)
		if err != nil {
			goto ReadFieldError
		}
	case 9:
		offset, err = x.fastReadField9(buf, _type)
		if err != nil {
			goto ReadFieldError
		}
	case 10:
		offset, err = x.fastReadField10(buf, _type)
		if err != nil {
			goto ReadFieldError
		}
	case 11:
		offset, err = x.fastReadField11(buf, _type)
		if err != nil {
			goto ReadFieldError
		}
	case 12:
		offset, err = x.fastReadField12(buf, _type)
		if err != nil {
			goto ReadFieldError
		}
	case 13:
		offset, err = x.fastReadField13(buf, _type)
		if err != nil {
			goto ReadFieldError
		}
	default:
		offset, err = fastpb.Skip(buf, _type, number)
		if err != nil {
			goto SkipFieldError
		}
	}
	return offset, nil
SkipFieldError:
	return offset, fmt.Errorf("%T cannot parse invalid wire-format data, error: %s", x, err)
ReadFieldError:
	return offset, fmt.Errorf("%T read field %d '%s' error: %s", x, number, fieldIDToName_Number[number], err)
}

func (x *Number) fastReadField1(buf []byte, _type int8) (offset int, err error) {
	x.Field1, offset, err = fastpb.ReadInt32(buf, _type)
	return offset, err
}

func (x *Number) fastReadField2(buf []byte, _type int8) (offset int, err error) {
	x.Field2, offset, err = fastpb.ReadInt64(buf, _type)
	return offset, err
}

func (x *Number) fastReadField3(buf []byte, _type int8) (offset int, err error) {
	x.Field3, offset, err = fastpb.ReadUint32(buf, _type)
	return offset, err
}

func (x *Number) fastReadField4(buf []byte, _type int8) (offset int, err error) {
	x.Field4, offset, err = fastpb.ReadUint64(buf, _type)
	return offset, err
}

func (x *Number) fastReadField5(buf []byte, _type int8) (offset int, err error) {
	x.Field5, offset, err = fastpb.ReadSint32(buf, _type)
	return offset, err
}

func (x *Number) fastReadField6(buf []byte, _type int8) (offset int, err error) {
	x.Field6, offset, err = fastpb.ReadSint64(buf, _type)
	return offset, err
}

func (x *Number) fastReadField7(buf []byte, _type int8) (offset int, err error) {
	x.Field7, offset, err = fastpb.ReadBool(buf, _type)
	return offset, err
}

func (x *Number) fastReadField8(buf []byte, _type int8) (offset int, err error) {
	x.Field8, offset, err = fastpb.ReadFloat(buf, _type)
	return offset, err
}

func (x *Number) fastReadField9(buf []byte, _type int8) (offset int, err error) {
	x.Field9, offset, err = fastpb.ReadDouble(buf, _type)
	return offset, err
}

func (x *Number) fastReadField10(buf []byte, _type int8) (offset int, err error) {
	x.Field10, offset, err = fastpb.ReadFixed32(buf, _type)
	return offset, err
}

func (x *Number) fastReadField11(buf []byte, _type int8) (offset int, err error) {
	x.Field11, offset, err = fastpb.ReadFixed64(buf, _type)
	return offset, err
}

func (x *Number) fastReadField12(buf []byte, _type int8) (offset int, err error) {
	x.Field12, offset, err = fastpb.ReadSfixed32(buf, _type)
	return offset, err
}

func (x *Number) fastReadField13(buf []byte, _type int8) (offset int, err error) {
	x.Field13, offset, err = fastpb.ReadSfixed64(buf, _type)
	return offset, err
}

func (x *String) FastRead(buf []byte, _type int8, number int32) (offset int, err error) {
	switch number {
	case 1:
		offset, err = x.fastReadField1(buf, _type)
		if err != nil {
			goto ReadFieldError
		}
	case 2:
		offset, err = x.fastReadField2(buf, _type)
		if err != nil {
			goto ReadFieldError
		}
	default:
		offset, err = fastpb.Skip(buf, _type, number)
		if err != nil {
			goto SkipFieldError
		}
	}
	return offset, nil
SkipFieldError:
	return offset, fmt.Errorf("%T cannot parse invalid wire-format data, error: %s", x, err)
ReadFieldError:
	return offset, fmt.Errorf("%T read field %d '%s' error: %s", x, number, fieldIDToName_String[number], err)
}

func (x *String) fastReadField1(buf []byte, _type int8) (offset int, err error) {
	x.Field1, offset, err = fastpb.ReadString(buf, _type)
	return offset, err
}

func (x *String) fastReadField2(buf []byte, _type int8) (offset int, err error) {
	x.Field2, offset, err = fastpb.ReadBytes(buf, _type)
	return offset, err
}

func (x *List) FastRead(buf []byte, _type int8, number int32) (offset int, err error) {
	switch number {
	case 1:
		offset, err = x.fastReadField1(buf, _type)
		if err != nil {
			goto ReadFieldError
		}
	case 2:
		offset, err = x.fastReadField2(buf, _type)
		if err != nil {
			goto ReadFieldError
		}
	case 3:
		offset, err = x.fastReadField3(buf, _type)
		if err != nil {
			goto ReadFieldError
		}
	case 4:
		offset, err = x.fastReadField4(buf, _type)
		if err != nil {
			goto ReadFieldError
		}
	case 5:
		offset, err = x.fastReadField5(buf, _type)
		if err != nil {
			goto ReadFieldError
		}
	case 6:
		offset, err = x.fastReadField6(buf, _type)
		if err != nil {
			goto ReadFieldError
		}
	case 7:
		offset, err = x.fastReadField7(buf, _type)
		if err != nil {
			goto ReadFieldError
		}
	case 8:
		offset, err = x.fastReadField8(buf, _type)
		if err != nil {
			goto ReadFieldError
		}
	case 9:
		offset, err = x.fastReadField9(buf, _type)
		if err != nil {
			goto ReadFieldError
		}
	case 10:
		offset, err = x.fastReadField10(buf, _type)
		if err != nil {
			goto ReadFieldError
		}
	case 11:
		offset, err = x.fastReadField11(buf, _type)
		if err != nil {
			goto ReadFieldError
		}
	case 12:
		offset, err = x.fastReadField12(buf, _type)
		if err != nil {
			goto ReadFieldError
		}
	case 13:
		offset, err = x.fastReadField13(buf, _type)
		if err != nil {
			goto ReadFieldError
		}
	case 14:
		offset, err = x.fastReadField14(buf, _type)
		if err != nil {
			goto ReadFieldError
		}
	case 15:
		offset, err = x.fastReadField15(buf, _type)
		if err != nil {
			goto ReadFieldError
		}
	default:
		offset, err = fastpb.Skip(buf, _type, number)
		if err != nil {
			goto SkipFieldError
		}
	}
	return offset, nil
SkipFieldError:
	return offset, fmt.Errorf("%T cannot parse invalid wire-format data, error: %s", x, err)
ReadFieldError:
	return offset, fmt.Errorf("%T read field %d '%s' error: %s", x, number, fieldIDToName_List[number], err)
}

func (x *List) fastReadField1(buf []byte, _type int8) (offset int, err error) {
	offset, err = fastpb.ReadList(buf, _type,
		func(buf []byte, _type int8) (n int, err error) {
			var v int32
			v, offset, err = fastpb.ReadInt32(buf, _type)
			if err != nil {
				return offset, err
			}
			x.Field1 = append(x.Field1, v)
			return offset, err
		})
	return offset, err
}

func (x *List) fastReadField2(buf []byte, _type int8) (offset int, err error) {
	offset, err = fastpb.ReadList(buf, _type,
		func(buf []byte, _type int8) (n int, err error) {
			var v int64
			v, offset, err = fastpb.ReadInt64(buf, _type)
			if err != nil {
				return offset, err
			}
			x.Field2 = append(x.Field2, v)
			return offset, err
		})
	return offset, err
}

func (x *List) fastReadField3(buf []byte, _type int8) (offset int, err error) {
	offset, err = fastpb.ReadList(buf, _type,
		func(buf []byte, _type int8) (n int, err error) {
			var v uint32
			v, offset, err = fastpb.ReadUint32(buf, _type)
			if err != nil {
				return offset, err
			}
			x.Field3 = append(x.Field3, v)
			return offset, err
		})
	return offset, err
}

func (x *List) fastReadField4(buf []byte, _type int8) (offset int, err error) {
	offset, err = fastpb.ReadList(buf, _type,
		func(buf []byte, _type int8) (n int, err error) {
			var v uint64
			v, offset, err = fastpb.ReadUint64(buf, _type)
			if err != nil {
				return offset, err
			}
			x.Field4 = append(x.Field4, v)
			return offset, err
		})
	return offset, err
}

func (x *List) fastReadField5(buf []byte, _type int8) (offset int, err error) {
	offset, err = fastpb.ReadList(buf, _type,
		func(buf []byte, _type int8) (n int, err error) {
			var v int32
			v, offset, err = fastpb.ReadSint32(buf, _type)
			if err != nil {
				return offset, err
			}
			x.Field5 = append(x.Field5, v)
			return offset, err
		})
	return offset, err
}

func (x *List) fastReadField6(buf []byte, _type int8) (offset int, err error) {
	offset, err = fastpb.ReadList(buf, _type,
		func(buf []byte, _type int8) (n int, err error) {
			var v int64
			v, offset, err = fastpb.ReadSint64(buf, _type)
			if err != nil {
				return offset, err
			}
			x.Field6 = append(x.Field6, v)
			return offset, err
		})
	return offset, err
}

func (x *List) fastReadField7(buf []byte, _type int8) (offset int, err error) {
	offset, err = fastpb.ReadList(buf, _type,
		func(buf []byte, _type int8) (n int, err error) {
			var v bool
			v, offset, err = fastpb.ReadBool(buf, _type)
			if err != nil {
				return offset, err
			}
			x.Field7 = append(x.Field7, v)
			return offset, err
		})
	return offset, err
}

func (x *List) fastReadField8(buf []byte, _type int8) (offset int, err error) {
	offset, err = fastpb.ReadList(buf, _type,
		func(buf []byte, _type int8) (n int, err error) {
			var v float32
			v, offset, err = fastpb.ReadFloat(buf, _type)
			if err != nil {
				return offset, err
			}
			x.Field8 = append(x.Field8, v)
			return offset, err
		})
	return offset, err
}

func (x *List) fastReadField9(buf []byte, _type int8) (offset int, err error) {
	offset, err = fastpb.ReadList(buf, _type,
		func(buf []byte, _type int8) (n int, err error) {
			var v float64
			v, offset, err = fastpb.ReadDouble(buf, _type)
			if err != nil {
				return offset, err
			}
			x.Field9 = append(x.Field9, v)
			return offset, err
		})
	return offset, err
}

func (x *List) fastReadField10(buf []byte, _type int8) (offset int, err error) {
	offset, err = fastpb.ReadList(buf, _type,
		func(buf []byte, _type int8) (n int, err error) {
			var v uint32
			v, offset, err = fastpb.ReadFixed32(buf, _type)
			if err != nil {
				return offset, err
			}
			x.Field10 = append(x.Field10, v)
			return offset, err
		})
	return offset, err
}

func (x *List) fastReadField11(buf []byte, _type int8) (offset int, err error) {
	offset, err = fastpb.ReadList(buf, _type,
		func(buf []byte, _type int8) (n int, err error) {
			var v uint64
			v, offset, err = fastpb.ReadFixed64(buf, _type)
			if err != nil {
				return offset, err
			}
			x.Field11 = append(x.Field11, v)
			return offset, err
		})
	return offset, err
}

func (x *List) fastReadField12(buf []byte, _type int8) (offset int, err error) {
	offset, err = fastpb.ReadList(buf, _type,
		func(buf []byte, _type int8) (n int, err error) {
			var v int32
			v, offset, err = fastpb.ReadSfixed32(buf, _type)
			if err != nil {
				return offset, err
			}
			x.Field12 = append(x.Field12, v)
			return offset, err
		})
	return offset, err
}

func (x *List) fastReadField13(buf []byte, _type int8) (offset int, err error) {
	offset, err = fastpb.ReadList(buf, _type,
		func(buf []byte, _type int8) (n int, err error) {
			var v int64
			v, offset, err = fastpb.ReadSfixed64(buf, _type)
			if err != nil {
				return offset, err
			}
			x.Field13 = append(x.Field13, v)
			return offset, err
		})
	return offset, err
}

func (x *List) fastReadField14(buf []byte, _type int8) (offset int, err error) {
	var v string
	v, offset, err = fastpb.ReadString(buf, _type)
	if err != nil {
		return offset, err
	}
	x.Field14 = append(x.Field14, v)
	return offset, err
}

func (x *List) fastReadField15(buf []byte, _type int8) (offset int, err error) {
	var v []byte
	v, offset, err = fastpb.ReadBytes(buf, _type)
	if err != nil {
		return offset, err
	}
	x.Field15 = append(x.Field15, v)
	return offset, err
}

func (x *Map) FastRead(buf []byte, _type int8, number int32) (offset int, err error) {
	switch number {
	case 1:
		offset, err = x.fastReadField1(buf, _type)
		if err != nil {
			goto ReadFieldError
		}
	case 2:
		offset, err = x.fastReadField2(buf, _type)
		if err != nil {
			goto ReadFieldError
		}
	case 3:
		offset, err = x.fastReadField3(buf, _type)
		if err != nil {
			goto ReadFieldError
		}
	case 4:
		offset, err = x.fastReadField4(buf, _type)
		if err != nil {
			goto ReadFieldError
		}
	case 5:
		offset, err = x.fastReadField5(buf, _type)
		if err != nil {
			goto ReadFieldError
		}
	case 6:
		offset, err = x.fastReadField6(buf, _type)
		if err != nil {
			goto ReadFieldError
		}
	default:
		offset, err = fastpb.Skip(buf, _type, number)
		if err != nil {
			goto SkipFieldError
		}
	}
	return offset, nil
SkipFieldError:
	return offset, fmt.Errorf("%T cannot parse invalid wire-format data, error: %s", x, err)
ReadFieldError:
	return offset, fmt.Errorf("%T read field %d '%s' error: %s", x, number, fieldIDToName_Map[number], err)
}

func (x *Map) fastReadField1(buf []byte, _type int8) (offset int, err error) {
	if x.Field1 == nil {
		x.Field1 = make(map[int32]int64)
	}
	var key int32
	var value int64
	offset, err = fastpb.ReadMapEntry(buf, _type,
		func(buf []byte, _type int8) (offset int, err error) {
			key, offset, err = fastpb.ReadInt32(buf, _type)
			return offset, err
		},
		func(buf []byte, _type int8) (offset int, err error) {
			value, offset, err = fastpb.ReadInt64(buf, _type)
			return offset, err
		})
	if err != nil {
		return offset, err
	}
	x.Field1[key] = value
	return offset, nil
}

func (x *Map) fastReadField2(buf []byte, _type int8) (offset int, err error) {
	if x.Field2 == nil {
		x.Field2 = make(map[uint32]uint64)
	}
	var key uint32
	var value uint64
	offset, err = fastpb.ReadMapEntry(buf, _type,
		func(buf []byte, _type int8) (offset int, err error) {
			key, offset, err = fastpb.ReadUint32(buf, _type)
			return offset, err
		},
		func(buf []byte, _type int8) (offset int, err error) {
			value, offset, err = fastpb.ReadUint64(buf, _type)
			return offset, err
		})
	if err != nil {
		return offset, err
	}
	x.Field2[key] = value
	return offset, nil
}

func (x *Map) fastReadField3(buf []byte, _type int8) (offset int, err error) {
	if x.Field3 == nil {
		x.Field3 = make(map[int32]int64)
	}
	var key int32
	var value int64
	offset, err = fastpb.ReadMapEntry(buf, _type,
		func(buf []byte, _type int8) (offset int, err error) {
			key, offset, err = fastpb.ReadSint32(buf, _type)
			return offset, err
		},
		func(buf []byte, _type int8) (offset int, err error) {
			value, offset, err = fastpb.ReadSint64(buf, _type)
			return offset, err
		})
	if err != nil {
		return offset, err
	}
	x.Field3[key] = value
	return offset, nil
}

func (x *Map) fastReadField4(buf []byte, _type int8) (offset int, err error) {
	if x.Field4 == nil {
		x.Field4 = make(map[uint32]uint64)
	}
	var key uint32
	var value uint64
	offset, err = fastpb.ReadMapEntry(buf, _type,
		func(buf []byte, _type int8) (offset int, err error) {
			key, offset, err = fastpb.ReadFixed32(buf, _type)
			return offset, err
		},
		func(buf []byte, _type int8) (offset int, err error) {
			value, offset, err = fastpb.ReadFixed64(buf, _type)
			return offset, err
		})
	if err != nil {
		return offset, err
	}
	x.Field4[key] = value
	return offset, nil
}

func (x *Map) fastReadField5(buf []byte, _type int8) (offset int, err error) {
	if x.Field5 == nil {
		x.Field5 = make(map[int32]int64)
	}
	var key int32
	var value int64
	offset, err = fastpb.ReadMapEntry(buf, _type,
		func(buf []byte, _type int8) (offset int, err error) {
			key, offset, err = fastpb.ReadSfixed32(buf, _type)
			return offset, err
		},
		func(buf []byte, _type int8) (offset int, err error) {
			value, offset, err = fastpb.ReadSfixed64(buf, _type)
			return offset, err
		})
	if err != nil {
		return offset, err
	}
	x.Field5[key] = value
	return offset, nil
}

func (x *Map) fastReadField6(buf []byte, _type int8) (offset int, err error) {
	if x.Field6 == nil {
		x.Field6 = make(map[string][]byte)
	}
	var key string
	var value []byte
	offset, err = fastpb.ReadMapEntry(buf, _type,
		func(buf []byte, _type int8) (offset int, err error) {
			key, offset, err = fastpb.ReadString(buf, _type)
			return offset, err
		},
		func(buf []byte, _type int8) (offset int, err error) {
			value, offset, err = fastpb.ReadBytes(buf, _type)
			return offset, err
		})
	if err != nil {
		return offset, err
	}
	x.Field6[key] = value
	return offset, nil
}

func (x *Number) FastWrite(buf []byte) (offset int) {
	if x == nil {
		return offset
	}
	offset += x.fastWriteField1(buf[offset:])
	offset += x.fastWriteField2(buf[offset:])
	offset += x.fastWriteField3(buf[offset:])
	offset += x.fastWriteField4(buf[offset:])
	offset += x.fastWriteField5(buf[offset:])
	offset += x.fastWriteField6(buf[offset:])
	offset += x.fastWriteField7(buf[offset:])
	offset += x.fastWriteField8(buf[offset:])
	offset += x.fastWriteField9(buf[offset:])
	offset += x.fastWriteField10(buf[offset:])
	offset += x.fastWriteField11(buf[offset:])
	offset += x.fastWriteField12(buf[offset:])
	offset += x.fastWriteField13(buf[offset:])
	return offset
}

func (x *Number) fastWriteField1(buf []byte) (offset int) {
	if x.Field1 == 0 {
		return offset
	}
	offset += fastpb.WriteInt32(buf[offset:], 1, x.Field1)
	return offset
}

func (x *Number) fastWriteField2(buf []byte) (offset int) {
	if x.Field2 == 0 {
		return offset
	}
	offset += fastpb.WriteInt64(buf[offset:], 2, x.Field2)
	return offset
}

func (x *Number) fastWriteField3(buf []byte) (offset int) {
	if x.Field3 == 0 {
		return offset
	}
	offset += fastpb.WriteUint32(buf[offset:], 3, x.Field3)
	return offset
}

func (x *Number) fastWriteField4(buf []byte) (offset int) {
	if x.Field4 == 0 {
		return offset
	}
	offset += fastpb.WriteUint64(buf[offset:], 4, x.Field4)
	return offset
}

func (x *Number) fastWriteField5(buf []byte) (offset int) {
	if x.Field5 == 0 {
		return offset
	}
	offset += fastpb.WriteSint32(buf[offset:], 5, x.Field5)
	return offset
}

func (x *Number) fastWriteField6(buf []byte) (offset int) {
	if x.Field6 == 0 {
		return offset
	}
	offset += fastpb.WriteSint64(buf[offset:], 6, x.Field6)
	return offset
}

func (x *Number) fastWriteField7(buf []byte) (offset int) {
	if !x.Field7 {
		return offset
	}
	offset += fastpb.WriteBool(buf[offset:], 7, x.Field7)
	return offset
}

func (x *Number) fastWriteField8(buf []byte) (offset int) {
	if x.Field8 == 0 {
		return offset
	}
	offset += fastpb.WriteFloat(buf[offset:], 8, x.Field8)
	return offset
}

func (x *Number) fastWriteField9(buf []byte) (offset int) {
	if x.Field9 == 0 {
		return offset
	}
	offset += fastpb.WriteDouble(buf[offset:], 9, x.Field9)
	return offset
}

func (x *Number) fastWriteField10(buf []byte) (offset int) {
	if x.Field10 == 0 {
		return offset
	}
	offset += fastpb.WriteFixed32(buf[offset:], 10, x.Field10)
	return offset
}

func (x *Number) fastWriteField11(buf []byte) (offset int) {
	if x.Field11 == 0 {
		return offset
	}
	offset += fastpb.WriteFixed64(buf[offset:], 11, x.Field11)
	return offset
}

func (x *Number) fastWriteField12(buf []byte) (offset int) {
	if x.Field12 == 0 {
		return offset
	}
	offset += fastpb.WriteSfixed32(buf[offset:], 12, x.Field12)
	return offset
}

func (x *Number) fastWriteField13(buf []byte) (offset int) {
	if x.Field13 == 0 {
		return offset
	}
	offset += fastpb.WriteSfixed64(buf[offset:], 13, x.Field13)
	return offset
}

func (x *String) FastWrite(buf []byte) (offset int) {
	if x == nil {
		return offset
	}
	offset += x.fastWriteField1(buf[offset:])
	offset += x.fastWriteField2(buf[offset:])
	return offset
}

func (x *String) fastWriteField1(buf []byte) (offset int) {
	if x.Field1 == "" {
		return offset
	}
	offset += fastpb.WriteString(buf[offset:], 1, x.Field1)
	return offset
}

func (x *String) fastWriteField2(buf []byte) (offset int) {
	if len(x.Field2) == 0 {
		return offset
	}
	offset += fastpb.WriteBytes(buf[offset:], 2, x.Field2)
	return offset
}

func (x *List) FastWrite(buf []byte) (offset int) {
	if x == nil {
		return offset
	}
	offset += x.fastWriteField1(buf[offset:])
	offset += x.fastWriteField2(buf[offset:])
	offset += x.fastWriteField3(buf[offset:])
	offset += x.fastWriteField4(buf[offset:])
	offset += x.fastWriteField5(buf[offset:])
	offset += x.fastWriteField6(buf[offset:])
	offset += x.fastWriteField7(buf[offset:])
	offset += x.fastWriteField8(buf[offset:])
	offset += x.fastWriteField9(buf[offset:])
	offset += x.fastWriteField10(buf[offset:])
	offset += x.fastWriteField11(buf[offset:])
	offset += x.fastWriteField12(buf[offset:])
	offset += x.fastWriteField13(buf[offset:])
	offset += x.fastWriteField14(buf[offset:])
	offset += x.fastWriteField15(buf[offset:])
	return offset
}

func (x *List) fastWriteField1(buf []byte) (offset int) {
	if len(x.Field1) == 0 {
		return offset
	}
	offset += fastpb.WriteListPacked(buf[offset:], 1, len(x.Field1),
		func(buf []byte, numTagOrKey, numIdxOrVal int32) int {
			offset := 0
			offset += fastpb.WriteInt32(buf[offset:], numTagOrKey, x.Field1[numIdxOrVal])
			return offset
		})
	return offset
}

func (x *List) fastWriteField2(buf []byte) (offset int) {
	if len(x.Field2) == 0 {
		return offset
	}
	offset += fastpb.WriteListPacked(buf[offset:], 2, len(x.Field2),
		func(buf []byte, numTagOrKey, numIdxOrVal int32) int {
			offset := 0
			offset += fastpb.WriteInt64(buf[offset:], numTagOrKey, x.Field2[numIdxOrVal])
			return offset
		})
	return offset
}

func (x *List) fastWriteField3(buf []byte) (offset int) {
	if len(x.Field3) == 0 {
		return offset
	}
	offset += fastpb.WriteListPacked(buf[offset:], 3, len(x.Field3),
		func(buf []byte, numTagOrKey, numIdxOrVal int32) int {
			offset := 0
			offset += fastpb.WriteUint32(buf[offset:], numTagOrKey, x.Field3[numIdxOrVal])
			return offset
		})
	return offset
}

func (x *List) fastWriteField4(buf []byte) (offset int) {
	if len(x.Field4) == 0 {
		return offset
	}
	offset += fastpb.WriteListPacked(buf[offset:], 4, len(x.Field4),
		func(buf []byte, numTagOrKey, numIdxOrVal int32) int {
			offset := 0
			offset += fastpb.WriteUint64(buf[offset:], numTagOrKey, x.Field4[numIdxOrVal])
			return offset
		})
	return offset
}

func (x *List) fastWriteField5(buf []byte) (offset int) {
	if len(x.Field5) == 0 {
		return offset
	}
	offset += fastpb.WriteListPacked(buf[offset:], 5, len(x.Field5),
		func(buf []byte, numTagOrKey, numIdxOrVal int32) int {
			offset := 0
			offset += fastpb.WriteSint32(buf[offset:], numTagOrKey, x.Field5[numIdxOrVal])
			return offset
		})
	return offset
}

func (x *List) fastWriteField6(buf []byte) (offset int) {
	if len(x.Field6) == 0 {
		return offset
	}
	offset += fastpb.WriteListPacked(buf[offset:], 6, len(x.Field6),
		func(buf []byte, numTagOrKey, numIdxOrVal int32) int {
			offset := 0
			offset += fastpb.WriteSint64(buf[offset:], numTagOrKey, x.Field6[numIdxOrVal])
			return offset
		})
	return offset
}

func (x *List) fastWriteField7(buf []byte) (offset int) {
	if len(x.Field7) == 0 {
		return offset
	}
	offset += fastpb.WriteListPacked(buf[offset:], 7, len(x.Field7),
		func(buf []byte, numTagOrKey, numIdxOrVal int32) int {
			offset := 0
			offset += fastpb.WriteBool(buf[offset:], numTagOrKey, x.Field7[numIdxOrVal])
			return offset
		})
	return offset
}

func (x *List) fastWriteField8(buf []byte) (offset int) {
	if len(x.Field8) == 0 {
		return offset
	}
	offset += fastpb.WriteListPacked(buf[offset:], 8, len(x.Field8),
		func(buf []byte, numTagOrKey, numIdxOrVal int32) int {
			offset := 0
			offset += fastpb.WriteFloat(buf[offset:], numTagOrKey, x.Field8[numIdxOrVal])
			return offset
		})
	return offset
}

func (x *List) fastWriteField9(buf []byte) (offset int) {
	if len(x.Field9) == 0 {
		return offset
	}
	offset += fastpb.WriteListPacked(buf[offset:], 9, len(x.Field9),
		func(buf []byte, numTagOrKey, numIdxOrVal int32) int {
			offset := 0
			offset += fastpb.WriteDouble(buf[offset:], numTagOrKey, x.Field9[numIdxOrVal])
			return offset
		})
	return offset
}

func (x *List) fastWriteField10(buf []byte) (offset int) {
	if len(x.Field10) == 0 {
		return offset
	}
	offset += fastpb.WriteListPacked(buf[offset:], 10, len(x.Field10),
		func(buf []byte, numTagOrKey, numIdxOrVal int32) int {
			offset := 0
			offset += fastpb.WriteFixed32(buf[offset:], numTagOrKey, x.Field10[numIdxOrVal])
			return offset
		})
	return offset
}

func (x *List) fastWriteField11(buf []byte) (offset int) {
	if len(x.Field11) == 0 {
		return offset
	}
	offset += fastpb.WriteListPacked(buf[offset:], 11, len(x.Field11),
		func(buf []byte, numTagOrKey, numIdxOrVal int32) int {
			offset := 0
			offset += fastpb.WriteFixed64(buf[offset:], numTagOrKey, x.Field11[numIdxOrVal])
			return offset
		})
	return offset
}

func (x *List) fastWriteField12(buf []byte) (offset int) {
	if len(x.Field12) == 0 {
		return offset
	}
	offset += fastpb.WriteListPacked(buf[offset:], 12, len(x.Field12),
		func(buf []byte, numTagOrKey, numIdxOrVal int32) int {
			offset := 0
			offset += fastpb.WriteSfixed32(buf[offset:], numTagOrKey, x.Field12[numIdxOrVal])
			return offset
		})
	return offset
}

func (x *List) fastWriteField13(buf []byte) (offset int) {
	if len(x.Field13) == 0 {
		return offset
	}
	offset += fastpb.WriteListPacked(buf[offset:], 13, len(x.Field13),
		func(buf []byte, numTagOrKey, numIdxOrVal int32) int {
			offset := 0
			offset += fastpb.WriteSfixed64(buf[offset:], numTagOrKey, x.Field13[numIdxOrVal])
			return offset
		})
	return offset
}

func (x *List) fastWriteField14(buf []byte) (offset int) {
	if len(x.Field14) == 0 {
		return offset
	}
	for i := range x.Field14 {
		offset += fastpb.WriteString(buf[offset:], 14, x.Field14[i])
	}
	return offset
}

func (x *List) fastWriteField15(buf []byte) (offset int) {
	if len(x.Field15) == 0 {
		return offset
	}
	for i := range x.Field15 {
		offset += fastpb.WriteBytes(buf[offset:], 15, x.Field15[i])
	}
	return offset
}

func (x *Map) FastWrite(buf []byte) (offset int) {
	if x == nil {
		return offset
	}
	offset += x.fastWriteField1(buf[offset:])
	offset += x.fastWriteField2(buf[offset:])
	offset += x.fastWriteField3(buf[offset:])
	offset += x.fastWriteField4(buf[offset:])
	offset += x.fastWriteField5(buf[offset:])
	offset += x.fastWriteField6(buf[offset:])
	return offset
}

func (x *Map) fastWriteField1(buf []byte) (offset int) {
	if x.Field1 == nil {
		return offset
	}
	for k, v := range x.Field1 {
		offset += fastpb.WriteMapEntry(buf[offset:], 1,
			func(buf []byte, numTagOrKey, numIdxOrVal int32) int {
				offset := 0
				offset += fastpb.WriteInt32(buf[offset:], numTagOrKey, k)
				offset += fastpb.WriteInt64(buf[offset:], numIdxOrVal, v)
				return offset
			})
	}
	return offset
}

func (x *Map) fastWriteField2(buf []byte) (offset int) {
	if x.Field2 == nil {
		return offset
	}
	for k, v := range x.Field2 {
		offset += fastpb.WriteMapEntry(buf[offset:], 2,
			func(buf []byte, numTagOrKey, numIdxOrVal int32) int {
				offset := 0
				offset += fastpb.WriteUint32(buf[offset:], numTagOrKey, k)
				offset += fastpb.WriteUint64(buf[offset:], numIdxOrVal, v)
				return offset
			})
	}
	return offset
}

func (x *Map) fastWriteField3(buf []byte) (offset int) {
	if x.Field3 == nil {
		return offset
	}
	for k, v := range x.Field3 {
		offset += fastpb.WriteMapEntry(buf[offset:], 3,
			func(buf []byte, numTagOrKey, numIdxOrVal int32) int {
				offset := 0
				offset += fastpb.WriteSint32(buf[offset:], numTagOrKey, k)
				offset += fastpb.WriteSint64(buf[offset:], numIdxOrVal, v)
				return offset
			})
	}
	return offset
}

func (x *Map) fastWriteField4(buf []byte) (offset int) {
	if x.Field4 == nil {
		return offset
	}
	for k, v := range x.Field4 {
		offset += fastpb.WriteMapEntry(buf[offset:], 4,
			func(buf []byte, numTagOrKey, numIdxOrVal int32) int {
				offset := 0
				offset += fastpb.WriteFixed32(buf[offset:], numTagOrKey, k)
				offset += fastpb.WriteFixed64(buf[offset:], numIdxOrVal, v)
				return offset
			})
	}
	return offset
}

func (x *Map) fastWriteField5(buf []byte) (offset int) {
	if x.Field5 == nil {
		return offset
	}
	for k, v := range x.Field5 {
		offset += fastpb.WriteMapEntry(buf[offset:], 5,
			func(buf []byte, numTagOrKey, numIdxOrVal int32) int {
				offset := 0
				offset += fastpb.WriteSfixed32(buf[offset:], numTagOrKey, k)
				offset += fastpb.WriteSfixed64(buf[offset:], numIdxOrVal, v)
				return offset
			})
	}
	return offset
}

func (x *Map) fastWriteField6(buf []byte) (offset int) {
	if x.Field6 == nil {
		return offset
	}
	for k, v := range x.Field6 {
		offset += fastpb.WriteMapEntry(buf[offset:], 6,
			func(buf []byte, numTagOrKey, numIdxOrVal int32) int {
				offset := 0
				offset += fastpb.WriteString(buf[offset:], numTagOrKey, k)
				offset += fastpb.WriteBytes(buf[offset:], numIdxOrVal, v)
				return offset
			})
	}
	return offset
}

func (x *Number) Size() (n int) {
	if x == nil {
		return n
	}
	n += x.sizeField1()
	n += x.sizeField2()
	n += x.sizeField3()
	n += x.sizeField4()
	n += x.sizeField5()
	n += x.sizeField6()
	n += x.sizeField7()
	n += x.sizeField8()
	n += x.sizeField9()
	n += x.sizeField10()
	n += x.sizeField11()
	n += x.sizeField12()
	n += x.sizeField13()
	return n
}

func (x *Number) sizeField1() (n int) {
	if x.Field1 == 0 {
		return n
	}
	n += fastpb.SizeInt32(1, x.Field1)
	return n
}

func (x *Number) sizeField2() (n int) {
	if x.Field2 == 0 {
		return n
	}
	n += fastpb.SizeInt64(2, x.Field2)
	return n
}

func (x *Number) sizeField3() (n int) {
	if x.Field3 == 0 {
		return n
	}
	n += fastpb.SizeUint32(3, x.Field3)
	return n
}

func (x *Number) sizeField4() (n int) {
	if x.Field4 == 0 {
		return n
	}
	n += fastpb.SizeUint64(4, x.Field4)
	return n
}

func (x *Number) sizeField5() (n int) {
	if x.Field5 == 0 {
		return n
	}
	n += fastpb.SizeSint32(5, x.Field5)
	return n
}

func (x *Number) sizeField6() (n int) {
	if x.Field6 == 0 {
		return n
	}
	n += fastpb.SizeSint64(6, x.Field6)
	return n
}

func (x *Number) sizeField7() (n int) {
	if !x.Field7 {
		return n
	}
	n += fastpb.SizeBool(7, x.Field7)
	return n
}

func (x *Number) sizeField8() (n int) {
	if x.Field8 == 0 {
		return n
	}
	n += fastpb.SizeFloat(8, x.Field8)
	return n
}

func (x *Number) sizeField9() (n int) {
	if x.Field9 == 0 {
		return n
	}
	n += fastpb.SizeDouble(9, x.Field9)
	return n
}

func (x *Number) sizeField10() (n int) {
	if x.Field10 == 0 {
		return n
	}
	n += fastpb.SizeFixed32(10, x.Field10)
	return n
}

func (x *Number) sizeField11() (n int) {
	if x.Field11 == 0 {
		return n
	}
	n += fastpb.SizeFixed64(11, x.Field11)
	return n
}

func (x *Number) sizeField12() (n int) {
	if x.Field12 == 0 {
		return n
	}
	n += fastpb.SizeSfixed32(12, x.Field12)
	return n
}

func (x *Number) sizeField13() (n int) {
	if x.Field13 == 0 {
		return n
	}
	n += fastpb.SizeSfixed64(13, x.Field13)
	return n
}

func (x *String) Size() (n int) {
	if x == nil {
		return n
	}
	n += x.sizeField1()
	n += x.sizeField2()
	return n
}

func (x *String) sizeField1() (n int) {
	if x.Field1 == "" {
		return n
	}
	n += fastpb.SizeString(1, x.Field1)
	return n
}

func (x *String) sizeField2() (n int) {
	if len(x.Field2) == 0 {
		return n
	}
	n += fastpb.SizeBytes(2, x.Field2)
	return n
}

func (x *List) Size() (n int) {
	if x == nil {
		return n
	}
	n += x.sizeField1()
	n += x.sizeField2()
	n += x.sizeField3()
	n += x.sizeField4()
	n += x.sizeField5()
	n += x.sizeField6()
	n += x.sizeField7()
	n += x.sizeField8()
	n += x.sizeField9()
	n += x.sizeField10()
	n += x.sizeField11()
	n += x.sizeField12()
	n += x.sizeField13()
	n += x.sizeField14()
	n += x.sizeField15()
	return n
}

func (x *List) sizeField1() (n int) {
	if len(x.Field1) == 0 {
		return n
	}
	n += fastpb.SizeListPacked(1, len(x.Field1),
		func(numTagOrKey, numIdxOrVal int32) int {
			n := 0
			n += fastpb.SizeInt32(numTagOrKey, x.Field1[numIdxOrVal])
			return n
		})
	return n
}

func (x *List) sizeField2() (n int) {
	if len(x.Field2) == 0 {
		return n
	}
	n += fastpb.SizeListPacked(2, len(x.Field2),
		func(numTagOrKey, numIdxOrVal int32) int {
			n := 0
			n += fastpb.SizeInt64(numTagOrKey, x.Field2[numIdxOrVal])
			return n
		})
	return n
}

func (x *List) sizeField3() (n int) {
	if len(x.Field3) == 0 {
		return n
	}
	n += fastpb.SizeListPacked(3, len(x.Field3),
		func(numTagOrKey, numIdxOrVal int32) int {
			n := 0
			n += fastpb.SizeUint32(numTagOrKey, x.Field3[numIdxOrVal])
			return n
		})
	return n
}

func (x *List) sizeField4() (n int) {
	if len(x.Field4) == 0 {
		return n
	}
	n += fastpb.SizeListPacked(4, len(x.Field4),
		func(numTagOrKey, numIdxOrVal int32) int {
			n := 0
			n += fastpb.SizeUint64(numTagOrKey, x.Field4[numIdxOrVal])
			return n
		})
	return n
}

func (x *List) sizeField5() (n int) {
	if len(x.Field5) == 0 {
		return n
	}
	n += fastpb.SizeListPacked(5, len(x.Field5),
		func(numTagOrKey, numIdxOrVal int32) int {
			n := 0
			n += fastpb.SizeSint32(numTagOrKey, x.Field5[numIdxOrVal])
			return n
		})
	return n
}

func (x *List) sizeField6() (n int) {
	if len(x.Field6) == 0 {
		return n
	}
	n += fastpb.SizeListPacked(6, len(x.Field6),
		func(numTagOrKey, numIdxOrVal int32) int {
			n := 0
			n += fastpb.SizeSint64(numTagOrKey, x.Field6[numIdxOrVal])
			return n
		})
	return n
}

func (x *List) sizeField7() (n int) {
	if len(x.Field7) == 0 {
		return n
	}
	n += fastpb.SizeListPacked(7, len(x.Field7),
		func(numTagOrKey, numIdxOrVal int32) int {
			n := 0
			n += fastpb.SizeBool(numTagOrKey, x.Field7[numIdxOrVal])
			return n
		})
	return n
}

func (x *List) sizeField8() (n int) {
	if len(x.Field8) == 0 {
		return n
	}
	n += fastpb.SizeListPacked(8, len(x.Field8),
		func(numTagOrKey, numIdxOrVal int32) int {
			n := 0
			n += fastpb.SizeFloat(numTagOrKey, x.Field8[numIdxOrVal])
			return n
		})
	return n
}

func (x *List) sizeField9() (n int) {
	if len(x.Field9) == 0 {
		return n
	}
	n += fastpb.SizeListPacked(9, len(x.Field9),
		func(numTagOrKey, numIdxOrVal int32) int {
			n := 0
			n += fastpb.SizeDouble(numTagOrKey, x.Field9[numIdxOrVal])
			return n
		})
	return n
}

func (x *List) sizeField10() (n int) {
	if len(x.Field10) == 0 {
		return n
	}
	n += fastpb.SizeListPacked(10, len(x.Field10),
		func(numTagOrKey, numIdxOrVal int32) int {
			n := 0
			n += fastpb.SizeFixed32(numTagOrKey, x.Field10[numIdxOrVal])
			return n
		})
	return n
}

func (x *List) sizeField11() (n int) {
	if len(x.Field11) == 0 {
		return n
	}
	n += fastpb.SizeListPacked(11, len(x.Field11),
		func(numTagOrKey, numIdxOrVal int32) int {
			n := 0
			n += fastpb.SizeFixed64(numTagOrKey, x.Field11[numIdxOrVal])
			return n
		})
	return n
}

func (x *List) sizeField12() (n int) {
	if len(x.Field12) == 0 {
		return n
	}
	n += fastpb.SizeListPacked(12, len(x.Field12),
		func(numTagOrKey, numIdxOrVal int32) int {
			n := 0
			n += fastpb.SizeSfixed32(numTagOrKey, x.Field12[numIdxOrVal])
			return n
		})
	return n
}

func (x *List) sizeField13() (n int) {
	if len(x.Field13) == 0 {
		return n
	}
	n += fastpb.SizeListPacked(13, len(x.Field13),
		func(numTagOrKey, numIdxOrVal int32) int {
			n := 0
			n += fastpb.SizeSfixed64(numTagOrKey, x.Field13[numIdxOrVal])
			return n
		})
	return n
}

func (x *List) sizeField14() (n int) {
	if len(x.Field14) == 0 {
		return n
	}
	for i := range x.Field14 {
		n += fastpb.SizeString(14, x.Field14[i])
	}
	return n
}

func (x *List) sizeField15() (n int) {
	if len(x.Field15) == 0 {
		return n
	}
	for i := range x.Field15 {
		n += fastpb.SizeBytes(15, x.Field15[i])
	}
	return n
}

func (x *Map) Size() (n int) {
	if x == nil {
		return n
	}
	n += x.sizeField1()
	n += x.sizeField2()
	n += x.sizeField3()
	n += x.sizeField4()
	n += x.sizeField5()
	n += x.sizeField6()
	return n
}

func (x *Map) sizeField1() (n int) {
	if x.Field1 == nil {
		return n
	}
	for k, v := range x.Field1 {
		n += fastpb.SizeMapEntry(1,
			func(numTagOrKey, numIdxOrVal int32) int {
				n := 0
				n += fastpb.SizeInt32(numTagOrKey, k)
				n += fastpb.SizeInt64(numIdxOrVal, v)
				return n
			})
	}
	return n
}

func (x *Map) sizeField2() (n int) {
	if x.Field2 == nil {
		return n
	}
	for k, v := range x.Field2 {
		n += fastpb.SizeMapEntry(2,
			func(numTagOrKey, numIdxOrVal int32) int {
				n := 0
				n += fastpb.SizeUint32(numTagOrKey, k)
				n += fastpb.SizeUint64(numIdxOrVal, v)
				return n
			})
	}
	return n
}

func (x *Map) sizeField3() (n int) {
	if x.Field3 == nil {
		return n
	}
	for k, v := range x.Field3 {
		n += fastpb.SizeMapEntry(3,
			func(numTagOrKey, numIdxOrVal int32) int {
				n := 0
				n += fastpb.SizeSint32(numTagOrKey, k)
				n += fastpb.SizeSint64(numIdxOrVal, v)
				return n
			})
	}
	return n
}

func (x *Map) sizeField4() (n int) {
	if x.Field4 == nil {
		return n
	}
	for k, v := range x.Field4 {
		n += fastpb.SizeMapEntry(4,
			func(numTagOrKey, numIdxOrVal int32) int {
				n := 0
				n += fastpb.SizeFixed32(numTagOrKey, k)
				n += fastpb.SizeFixed64(numIdxOrVal, v)
				return n
			})
	}
	return n
}

func (x *Map) sizeField5() (n int) {
	if x.Field5 == nil {
		return n
	}
	for k, v := range x.Field5 {
		n += fastpb.SizeMapEntry(5,
			func(numTagOrKey, numIdxOrVal int32) int {
				n := 0
				n += fastpb.SizeSfixed32(numTagOrKey, k)
				n += fastpb.SizeSfixed64(numIdxOrVal, v)
				return n
			})
	}
	return n
}

func (x *Map) sizeField6() (n int) {
	if x.Field6 == nil {
		return n
	}
	for k, v := range x.Field6 {
		n += fastpb.SizeMapEntry(6,
			func(numTagOrKey, numIdxOrVal int32) int {
				n := 0
				n += fastpb.SizeString(numTagOrKey, k)
				n += fastpb.SizeBytes(numIdxOrVal, v)
				return n
			})
	}
	return n
}

var fieldIDToName_Number = map[int32]string{
	1:  "Field1",
	2:  "Field2",
	3:  "Field3",
	4:  "Field4",
	5:  "Field5",
	6:  "Field6",
	7:  "Field7",
	8:  "Field8",
	9:  "Field9",
	10: "Field10",
	11: "Field11",
	12: "Field12",
	13: "Field13",
}

var fieldIDToName_String = map[int32]string{
	1: "Field1",
	2: "Field2",
}

var fieldIDToName_List = map[int32]string{
	1:  "Field1",
	2:  "Field2",
	3:  "Field3",
	4:  "Field4",
	5:  "Field5",
	6:  "Field6",
	7:  "Field7",
	8:  "Field8",
	9:  "Field9",
	10: "Field10",
	11: "Field11",
	12: "Field12",
	13: "Field13",
	14: "Field14",
	15: "Field15",
}

var fieldIDToName_Map = map[int32]string{
	1: "Field1",
	2: "Field2",
	3: "Field3",
	4: "Field4",
	5: "Field5",
	6: "Field6",
}
