github.com/cloudwego/dynamicgo@v0.2.6-0.20240519101509-707f41b6b834/testdata/kitex_gen/pb/example/example.pb.fast.go

// Code generated by Fastpb v0.0.2. DO NOT EDIT.

package example

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

var (
	_ = fmt.Errorf
	_ = fastpb.Skip
)

func (x *Scalars) 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 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 20:
		offset, err = x.fastReadField20(buf, _type)
		if err != nil {
			goto ReadFieldError
		}
	case 21:
		offset, err = x.fastReadField21(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_Scalars[number], err)
}

func (x *Scalars) fastReadField1(buf []byte, _type int8) (offset int, err error) {
	x.SBool, offset, err = fastpb.ReadBool(buf, _type)
	return offset, err
}

func (x *Scalars) fastReadField2(buf []byte, _type int8) (offset int, err error) {
	x.SInt32, offset, err = fastpb.ReadInt32(buf, _type)
	return offset, err
}

func (x *Scalars) fastReadField3(buf []byte, _type int8) (offset int, err error) {
	x.SInt64, offset, err = fastpb.ReadInt64(buf, _type)
	return offset, err
}

func (x *Scalars) fastReadField4(buf []byte, _type int8) (offset int, err error) {
	x.SUint32, offset, err = fastpb.ReadUint32(buf, _type)
	return offset, err
}

func (x *Scalars) fastReadField5(buf []byte, _type int8) (offset int, err error) {
	x.SUint64, offset, err = fastpb.ReadUint64(buf, _type)
	return offset, err
}

func (x *Scalars) fastReadField6(buf []byte, _type int8) (offset int, err error) {
	x.SSint32, offset, err = fastpb.ReadSint32(buf, _type)
	return offset, err
}

func (x *Scalars) fastReadField7(buf []byte, _type int8) (offset int, err error) {
	x.SSint64, offset, err = fastpb.ReadSint64(buf, _type)
	return offset, err
}

func (x *Scalars) fastReadField8(buf []byte, _type int8) (offset int, err error) {
	x.SFixed32, offset, err = fastpb.ReadFixed32(buf, _type)
	return offset, err
}

func (x *Scalars) fastReadField9(buf []byte, _type int8) (offset int, err error) {
	x.SFixed64, offset, err = fastpb.ReadFixed64(buf, _type)
	return offset, err
}

func (x *Scalars) fastReadField10(buf []byte, _type int8) (offset int, err error) {
	x.SSfixed32, offset, err = fastpb.ReadSfixed32(buf, _type)
	return offset, err
}

func (x *Scalars) fastReadField11(buf []byte, _type int8) (offset int, err error) {
	x.SSfixed64, offset, err = fastpb.ReadSfixed64(buf, _type)
	return offset, err
}

func (x *Scalars) fastReadField13(buf []byte, _type int8) (offset int, err error) {
	x.SString, offset, err = fastpb.ReadString(buf, _type)
	return offset, err
}

func (x *Scalars) fastReadField14(buf []byte, _type int8) (offset int, err error) {
	x.SBytes, offset, err = fastpb.ReadBytes(buf, _type)
	return offset, err
}

func (x *Scalars) fastReadField20(buf []byte, _type int8) (offset int, err error) {
	x.SFloat, offset, err = fastpb.ReadFloat(buf, _type)
	return offset, err
}

func (x *Scalars) fastReadField21(buf []byte, _type int8) (offset int, err error) {
	x.SDouble, offset, err = fastpb.ReadDouble(buf, _type)
	return offset, err
}

func (x *Repeats) 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
		}
	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_Repeats[number], err)
}

func (x *Repeats) 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 bool
			v, offset, err = fastpb.ReadBool(buf, _type)
			if err != nil {
				return offset, err
			}
			x.RptBool = append(x.RptBool, v)
			return offset, err
		})
	return offset, err
}

func (x *Repeats) 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 int32
			v, offset, err = fastpb.ReadInt32(buf, _type)
			if err != nil {
				return offset, err
			}
			x.RptInt32 = append(x.RptInt32, v)
			return offset, err
		})
	return offset, err
}

func (x *Repeats) 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 int64
			v, offset, err = fastpb.ReadInt64(buf, _type)
			if err != nil {
				return offset, err
			}
			x.RptInt64 = append(x.RptInt64, v)
			return offset, err
		})
	return offset, err
}

func (x *Repeats) 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 uint32
			v, offset, err = fastpb.ReadUint32(buf, _type)
			if err != nil {
				return offset, err
			}
			x.RptUint32 = append(x.RptUint32, v)
			return offset, err
		})
	return offset, err
}

func (x *Repeats) 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 uint64
			v, offset, err = fastpb.ReadUint64(buf, _type)
			if err != nil {
				return offset, err
			}
			x.RptUint64 = append(x.RptUint64, v)
			return offset, err
		})
	return offset, err
}

func (x *Repeats) 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 float32
			v, offset, err = fastpb.ReadFloat(buf, _type)
			if err != nil {
				return offset, err
			}
			x.RptFloat = append(x.RptFloat, v)
			return offset, err
		})
	return offset, err
}

func (x *Repeats) 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 float64
			v, offset, err = fastpb.ReadDouble(buf, _type)
			if err != nil {
				return offset, err
			}
			x.RptDouble = append(x.RptDouble, v)
			return offset, err
		})
	return offset, err
}

func (x *Repeats) fastReadField8(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.RptString = append(x.RptString, v)
	return offset, err
}

func (x *Repeats) fastReadField9(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.RptBytes = append(x.RptBytes, v)
	return offset, err
}

func (x *Proto3Optional) 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
		}
	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_Proto3Optional[number], err)
}

func (x *Proto3Optional) fastReadField1(buf []byte, _type int8) (offset int, err error) {
	tmp, offset, err := fastpb.ReadBool(buf, _type)
	x.OptBool = &tmp
	return offset, err
}

func (x *Proto3Optional) fastReadField2(buf []byte, _type int8) (offset int, err error) {
	tmp, offset, err := fastpb.ReadInt32(buf, _type)
	x.OptInt32 = &tmp
	return offset, err
}

func (x *Proto3Optional) fastReadField3(buf []byte, _type int8) (offset int, err error) {
	tmp, offset, err := fastpb.ReadInt64(buf, _type)
	x.OptInt64 = &tmp
	return offset, err
}

func (x *Proto3Optional) fastReadField4(buf []byte, _type int8) (offset int, err error) {
	tmp, offset, err := fastpb.ReadUint32(buf, _type)
	x.OptUint32 = &tmp
	return offset, err
}

func (x *Proto3Optional) fastReadField5(buf []byte, _type int8) (offset int, err error) {
	tmp, offset, err := fastpb.ReadUint64(buf, _type)
	x.OptUint64 = &tmp
	return offset, err
}

func (x *Proto3Optional) fastReadField6(buf []byte, _type int8) (offset int, err error) {
	tmp, offset, err := fastpb.ReadFloat(buf, _type)
	x.OptFloat = &tmp
	return offset, err
}

func (x *Proto3Optional) fastReadField7(buf []byte, _type int8) (offset int, err error) {
	tmp, offset, err := fastpb.ReadDouble(buf, _type)
	x.OptDouble = &tmp
	return offset, err
}

func (x *Proto3Optional) fastReadField8(buf []byte, _type int8) (offset int, err error) {
	tmp, offset, err := fastpb.ReadString(buf, _type)
	x.OptString = &tmp
	return offset, err
}

func (x *Proto3Optional) fastReadField9(buf []byte, _type int8) (offset int, err error) {
	x.OptBytes, offset, err = fastpb.ReadBytes(buf, _type)
	return offset, err
}

func (x *Proto3Optional) fastReadField10(buf []byte, _type int8) (offset int, err error) {
	var v int32
	v, offset, err = fastpb.ReadInt32(buf, _type)
	if err != nil {
		return offset, err
	}
	x.OptEnum = Enum(v).Enum()
	return offset, nil
}

func (x *Proto3Optional) fastReadField11(buf []byte, _type int8) (offset int, err error) {
	var v Nested
	offset, err = fastpb.ReadMessage(buf, _type, &v)
	if err != nil {
		return offset, err
	}
	x.OptMessage = &v
	return offset, nil
}

func (x *Enums) 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 3:
		offset, err = x.fastReadField3(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_Enums[number], err)
}

func (x *Enums) fastReadField1(buf []byte, _type int8) (offset int, err error) {
	var v int32
	v, offset, err = fastpb.ReadInt32(buf, _type)
	if err != nil {
		return offset, err
	}
	x.SEnum = Enum(v)
	return offset, nil
}

func (x *Enums) fastReadField3(buf []byte, _type int8) (offset int, err error) {
	var v int32
	v, offset, err = fastpb.ReadInt32(buf, _type)
	if err != nil {
		return offset, err
	}
	x.SNestedEnum = Enums_NestedEnum(v)
	return offset, nil
}

func (x *Nests) FastRead(buf []byte, _type int8, number int32) (offset int, err error) {
	switch number {
	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_Nests[number], err)
}

func (x *Nests) fastReadField2(buf []byte, _type int8) (offset int, err error) {
	var v Nested
	offset, err = fastpb.ReadMessage(buf, _type, &v)
	if err != nil {
		return offset, err
	}
	x.SNested = &v
	return offset, nil
}

func (x *Nested) 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_Nested[number], err)
}

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

func (x *Nested) fastReadField2(buf []byte, _type int8) (offset int, err error) {
	var v InnerBase
	offset, err = fastpb.ReadMessage(buf, _type, &v)
	if err != nil {
		return offset, err
	}
	x.Base = &v
	return offset, nil
}

func (x *Oneofs) 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
		}
	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_Oneofs[number], err)
}

func (x *Oneofs) fastReadField1(buf []byte, _type int8) (offset int, err error) {
	var ov Oneofs_OneofEnum
	x.Union = &ov
	var v int32
	v, offset, err = fastpb.ReadInt32(buf, _type)
	if err != nil {
		return offset, err
	}
	ov.OneofEnum = Enum(v)
	return offset, nil
}

func (x *Oneofs) fastReadField2(buf []byte, _type int8) (offset int, err error) {
	var ov Oneofs_OneofString
	x.Union = &ov
	ov.OneofString, offset, err = fastpb.ReadString(buf, _type)
	return offset, err
}

func (x *Oneofs) fastReadField3(buf []byte, _type int8) (offset int, err error) {
	var ov Oneofs_OneofNested
	x.Union = &ov
	var v Nested
	offset, err = fastpb.ReadMessage(buf, _type, &v)
	if err != nil {
		return offset, err
	}
	ov.OneofNested = &v
	return offset, nil
}

func (x *Maps) 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
		}
	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_Maps[number], err)
}

func (x *Maps) fastReadField1(buf []byte, _type int8) (offset int, err error) {
	if x.Int32ToStr == nil {
		x.Int32ToStr = make(map[int32]string)
	}
	var key int32
	var value string
	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.ReadString(buf, _type)
			return offset, err
		})
	if err != nil {
		return offset, err
	}
	x.Int32ToStr[key] = value
	return offset, nil
}

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

func (x *Maps) fastReadField3(buf []byte, _type int8) (offset int, err error) {
	if x.Uint64ToEnum == nil {
		x.Uint64ToEnum = make(map[uint64]Enum)
	}
	var key uint64
	var value Enum
	offset, err = fastpb.ReadMapEntry(buf, _type,
		func(buf []byte, _type int8) (offset int, err error) {
			key, offset, err = fastpb.ReadUint64(buf, _type)
			return offset, err
		},
		func(buf []byte, _type int8) (offset int, err error) {
			var v int32
			v, offset, err = fastpb.ReadInt32(buf, _type)
			if err != nil {
				return offset, err
			}
			value = Enum(v)
			return offset, nil
		})
	if err != nil {
		return offset, err
	}
	x.Uint64ToEnum[key] = value
	return offset, nil
}

func (x *Maps) fastReadField4(buf []byte, _type int8) (offset int, err error) {
	if x.StrToNested == nil {
		x.StrToNested = make(map[string]*Nested)
	}
	var key string
	var value *Nested
	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) {
			var v Nested
			offset, err = fastpb.ReadMessage(buf, _type, &v)
			if err != nil {
				return offset, err
			}
			value = &v
			return offset, nil
		})
	if err != nil {
		return offset, err
	}
	x.StrToNested[key] = value
	return offset, nil
}

func (x *Maps) fastReadField5(buf []byte, _type int8) (offset int, err error) {
	if x.StrToOneofs == nil {
		x.StrToOneofs = make(map[string]*Oneofs)
	}
	var key string
	var value *Oneofs
	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) {
			var v Oneofs
			offset, err = fastpb.ReadMessage(buf, _type, &v)
			if err != nil {
				return offset, err
			}
			value = &v
			return offset, nil
		})
	if err != nil {
		return offset, err
	}
	x.StrToOneofs[key] = value
	return offset, nil
}

func (x *JSONNames) 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
		}
	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_JSONNames[number], err)
}

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

func (x *InnerBase) 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 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 20:
		offset, err = x.fastReadField20(buf, _type)
		if err != nil {
			goto ReadFieldError
		}
	case 21:
		offset, err = x.fastReadField21(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_InnerBase[number], err)
}

func (x *InnerBase) fastReadField1(buf []byte, _type int8) (offset int, err error) {
	x.SBool, offset, err = fastpb.ReadBool(buf, _type)
	return offset, err
}

func (x *InnerBase) fastReadField2(buf []byte, _type int8) (offset int, err error) {
	x.SInt32, offset, err = fastpb.ReadInt32(buf, _type)
	return offset, err
}

func (x *InnerBase) fastReadField3(buf []byte, _type int8) (offset int, err error) {
	x.SInt64, offset, err = fastpb.ReadInt64(buf, _type)
	return offset, err
}

func (x *InnerBase) fastReadField4(buf []byte, _type int8) (offset int, err error) {
	x.SUint32, offset, err = fastpb.ReadUint32(buf, _type)
	return offset, err
}

func (x *InnerBase) fastReadField5(buf []byte, _type int8) (offset int, err error) {
	x.SUint64, offset, err = fastpb.ReadUint64(buf, _type)
	return offset, err
}

func (x *InnerBase) fastReadField6(buf []byte, _type int8) (offset int, err error) {
	x.SSint32, offset, err = fastpb.ReadSint32(buf, _type)
	return offset, err
}

func (x *InnerBase) fastReadField7(buf []byte, _type int8) (offset int, err error) {
	x.SSint64, offset, err = fastpb.ReadSint64(buf, _type)
	return offset, err
}

func (x *InnerBase) fastReadField8(buf []byte, _type int8) (offset int, err error) {
	x.SFixed32, offset, err = fastpb.ReadFixed32(buf, _type)
	return offset, err
}

func (x *InnerBase) fastReadField9(buf []byte, _type int8) (offset int, err error) {
	x.SFixed64, offset, err = fastpb.ReadFixed64(buf, _type)
	return offset, err
}

func (x *InnerBase) fastReadField10(buf []byte, _type int8) (offset int, err error) {
	x.SSfixed32, offset, err = fastpb.ReadSfixed32(buf, _type)
	return offset, err
}

func (x *InnerBase) fastReadField11(buf []byte, _type int8) (offset int, err error) {
	x.SSfixed64, offset, err = fastpb.ReadSfixed64(buf, _type)
	return offset, err
}

func (x *InnerBase) fastReadField13(buf []byte, _type int8) (offset int, err error) {
	x.SString, offset, err = fastpb.ReadString(buf, _type)
	return offset, err
}

func (x *InnerBase) fastReadField14(buf []byte, _type int8) (offset int, err error) {
	x.SBytes, offset, err = fastpb.ReadBytes(buf, _type)
	return offset, err
}

func (x *InnerBase) fastReadField20(buf []byte, _type int8) (offset int, err error) {
	x.SFloat, offset, err = fastpb.ReadFloat(buf, _type)
	return offset, err
}

func (x *InnerBase) fastReadField21(buf []byte, _type int8) (offset int, err error) {
	x.SDouble, offset, err = fastpb.ReadDouble(buf, _type)
	return offset, err
}

func (x *ExampleScalarsReq) 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
		}
	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_ExampleScalarsReq[number], err)
}

func (x *ExampleScalarsReq) fastReadField1(buf []byte, _type int8) (offset int, err error) {
	tmp, offset, err := fastpb.ReadString(buf, _type)
	x.Msg = &tmp
	return offset, err
}

func (x *ExampleScalarsReq) fastReadField2(buf []byte, _type int8) (offset int, err error) {
	tmp, offset, err := fastpb.ReadDouble(buf, _type)
	x.Cookie = &tmp
	return offset, err
}

func (x *ExampleScalarsReq) fastReadField3(buf []byte, _type int8) (offset int, err error) {
	x.Path, offset, err = fastpb.ReadString(buf, _type)
	return offset, err
}

func (x *ExampleScalarsReq) fastReadField4(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.Query = append(x.Query, v)
	return offset, err
}

func (x *ExampleScalarsReq) fastReadField5(buf []byte, _type int8) (offset int, err error) {
	x.Header, offset, err = fastpb.ReadBool(buf, _type)
	return offset, err
}

func (x *ExampleScalarsReq) fastReadField6(buf []byte, _type int8) (offset int, err error) {
	x.Code, offset, err = fastpb.ReadInt64(buf, _type)
	return offset, err
}

func (x *ExampleScalarsReq) fastReadField7(buf []byte, _type int8) (offset int, err error) {
	var v InnerBase
	offset, err = fastpb.ReadMessage(buf, _type, &v)
	if err != nil {
		return offset, err
	}
	x.InnerBase = &v
	return offset, nil
}

func (x *ExampleScalarsReq) fastReadField8(buf []byte, _type int8) (offset int, err error) {
	x.RawUri, offset, err = fastpb.ReadString(buf, _type)
	return offset, err
}

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

func (x *ExampleScalarsReq) fastReadField10(buf []byte, _type int8) (offset int, err error) {
	var v Scalars
	offset, err = fastpb.ReadMessage(buf, _type, &v)
	if err != nil {
		return offset, err
	}
	x.Scalars = &v
	return offset, nil
}

func (x *ExampleScalarsResp) 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
		}
	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_ExampleScalarsResp[number], err)
}

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

func (x *ExampleScalarsResp) fastReadField2(buf []byte, _type int8) (offset int, err error) {
	tmp, offset, err := fastpb.ReadDouble(buf, _type)
	x.Cookie = &tmp
	return offset, err
}

func (x *ExampleScalarsResp) fastReadField3(buf []byte, _type int8) (offset int, err error) {
	x.Status, offset, err = fastpb.ReadInt32(buf, _type)
	return offset, err
}

func (x *ExampleScalarsResp) fastReadField4(buf []byte, _type int8) (offset int, err error) {
	tmp, offset, err := fastpb.ReadBool(buf, _type)
	x.Header = &tmp
	return offset, err
}

func (x *ExampleScalarsResp) fastReadField5(buf []byte, _type int8) (offset int, err error) {
	x.Code, offset, err = fastpb.ReadInt64(buf, _type)
	return offset, err
}

func (x *ExampleScalarsResp) fastReadField6(buf []byte, _type int8) (offset int, err error) {
	x.Subfix, offset, err = fastpb.ReadDouble(buf, _type)
	return offset, err
}

func (x *ExampleScalarsResp) fastReadField7(buf []byte, _type int8) (offset int, err error) {
	var v Scalars
	offset, err = fastpb.ReadMessage(buf, _type, &v)
	if err != nil {
		return offset, err
	}
	x.Scalars = &v
	return offset, nil
}

func (x *ExampleMessageReq) 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
		}
	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_ExampleMessageReq[number], err)
}

func (x *ExampleMessageReq) fastReadField1(buf []byte, _type int8) (offset int, err error) {
	var v InnerBase
	offset, err = fastpb.ReadMessage(buf, _type, &v)
	if err != nil {
		return offset, err
	}
	x.Base = &v
	return offset, nil
}

func (x *ExampleMessageResp) 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
		}
	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_ExampleMessageResp[number], err)
}

func (x *ExampleMessageResp) fastReadField1(buf []byte, _type int8) (offset int, err error) {
	var v InnerBase
	offset, err = fastpb.ReadMessage(buf, _type, &v)
	if err != nil {
		return offset, err
	}
	x.Base = &v
	return offset, nil
}

func (x *ExampleNestedReq) 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
		}
	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_ExampleNestedReq[number], err)
}

func (x *ExampleNestedReq) fastReadField1(buf []byte, _type int8) (offset int, err error) {
	var v Nested
	offset, err = fastpb.ReadMessage(buf, _type, &v)
	if err != nil {
		return offset, err
	}
	x.TestNested = &v
	return offset, nil
}

func (x *ExampleNestedResp) 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
		}
	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_ExampleNestedResp[number], err)
}

func (x *ExampleNestedResp) fastReadField1(buf []byte, _type int8) (offset int, err error) {
	var v Nested
	offset, err = fastpb.ReadMessage(buf, _type, &v)
	if err != nil {
		return offset, err
	}
	x.TestNested = &v
	return offset, nil
}

func (x *ExampleParitalReq) 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
		}
	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_ExampleParitalReq[number], err)
}

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

func (x *ExampleParitalReq) fastReadField2(buf []byte, _type int8) (offset int, err error) {
	tmp, offset, err := fastpb.ReadDouble(buf, _type)
	x.Cookie = &tmp
	return offset, err
}

func (x *ExampleParitalReq) fastReadField3(buf []byte, _type int8) (offset int, err error) {
	x.Status, offset, err = fastpb.ReadInt32(buf, _type)
	return offset, err
}

func (x *ExampleParitalReq) fastReadField4(buf []byte, _type int8) (offset int, err error) {
	x.Header, offset, err = fastpb.ReadBool(buf, _type)
	return offset, err
}

func (x *ExampleParitalReq) fastReadField5(buf []byte, _type int8) (offset int, err error) {
	x.Code, offset, err = fastpb.ReadInt64(buf, _type)
	return offset, err
}

func (x *ExamplePartialResp) 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
		}
	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_ExamplePartialResp[number], err)
}

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

func (x *ExamplePartialResp) fastReadField2(buf []byte, _type int8) (offset int, err error) {
	x.ChineseMsg, offset, err = fastpb.ReadString(buf, _type)
	return offset, err
}

func (x *ExamplePartialResp) fastReadField3(buf []byte, _type int8) (offset int, err error) {
	x.LongEnglishMsg, offset, err = fastpb.ReadString(buf, _type)
	return offset, err
}

func (x *ExampleListReq) 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
		}
	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_ExampleListReq[number], err)
}

func (x *ExampleListReq) fastReadField1(buf []byte, _type int8) (offset int, err error) {
	var v Repeats
	offset, err = fastpb.ReadMessage(buf, _type, &v)
	if err != nil {
		return offset, err
	}
	x.TestList = &v
	return offset, nil
}

func (x *ExampleListResp) 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
		}
	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_ExampleListResp[number], err)
}

func (x *ExampleListResp) fastReadField1(buf []byte, _type int8) (offset int, err error) {
	var v Repeats
	offset, err = fastpb.ReadMessage(buf, _type, &v)
	if err != nil {
		return offset, err
	}
	x.TestList = &v
	return offset, nil
}

func (x *ExampleMapReq) 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
		}
	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_ExampleMapReq[number], err)
}

func (x *ExampleMapReq) fastReadField1(buf []byte, _type int8) (offset int, err error) {
	var v Maps
	offset, err = fastpb.ReadMessage(buf, _type, &v)
	if err != nil {
		return offset, err
	}
	x.TestMap = &v
	return offset, nil
}

func (x *ExampleMapResp) 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
		}
	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_ExampleMapResp[number], err)
}

func (x *ExampleMapResp) fastReadField1(buf []byte, _type int8) (offset int, err error) {
	var v Maps
	offset, err = fastpb.ReadMessage(buf, _type, &v)
	if err != nil {
		return offset, err
	}
	x.TestMap = &v
	return offset, nil
}

func (x *ExampleOneofReq) 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
		}
	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_ExampleOneofReq[number], err)
}

func (x *ExampleOneofReq) fastReadField1(buf []byte, _type int8) (offset int, err error) {
	var v Oneofs
	offset, err = fastpb.ReadMessage(buf, _type, &v)
	if err != nil {
		return offset, err
	}
	x.TestOneof = &v
	return offset, nil
}

func (x *ExampleOneofResp) 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
		}
	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_ExampleOneofResp[number], err)
}

func (x *ExampleOneofResp) fastReadField1(buf []byte, _type int8) (offset int, err error) {
	var v Oneofs
	offset, err = fastpb.ReadMessage(buf, _type, &v)
	if err != nil {
		return offset, err
	}
	x.TestOneof = &v
	return offset, nil
}

func (x *Scalars) 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.fastWriteField13(buf[offset:])
	offset += x.fastWriteField14(buf[offset:])
	offset += x.fastWriteField20(buf[offset:])
	offset += x.fastWriteField21(buf[offset:])
	return offset
}

func (x *Scalars) fastWriteField1(buf []byte) (offset int) {
	if !x.SBool {
		return offset
	}
	offset += fastpb.WriteBool(buf[offset:], 1, x.GetSBool())
	return offset
}

func (x *Scalars) fastWriteField2(buf []byte) (offset int) {
	if x.SInt32 == 0 {
		return offset
	}
	offset += fastpb.WriteInt32(buf[offset:], 2, x.GetSInt32())
	return offset
}

func (x *Scalars) fastWriteField3(buf []byte) (offset int) {
	if x.SInt64 == 0 {
		return offset
	}
	offset += fastpb.WriteInt64(buf[offset:], 3, x.GetSInt64())
	return offset
}

func (x *Scalars) fastWriteField4(buf []byte) (offset int) {
	if x.SUint32 == 0 {
		return offset
	}
	offset += fastpb.WriteUint32(buf[offset:], 4, x.GetSUint32())
	return offset
}

func (x *Scalars) fastWriteField5(buf []byte) (offset int) {
	if x.SUint64 == 0 {
		return offset
	}
	offset += fastpb.WriteUint64(buf[offset:], 5, x.GetSUint64())
	return offset
}

func (x *Scalars) fastWriteField6(buf []byte) (offset int) {
	if x.SSint32 == 0 {
		return offset
	}
	offset += fastpb.WriteSint32(buf[offset:], 6, x.GetSSint32())
	return offset
}

func (x *Scalars) fastWriteField7(buf []byte) (offset int) {
	if x.SSint64 == 0 {
		return offset
	}
	offset += fastpb.WriteSint64(buf[offset:], 7, x.GetSSint64())
	return offset
}

func (x *Scalars) fastWriteField8(buf []byte) (offset int) {
	if x.SFixed32 == 0 {
		return offset
	}
	offset += fastpb.WriteFixed32(buf[offset:], 8, x.GetSFixed32())
	return offset
}

func (x *Scalars) fastWriteField9(buf []byte) (offset int) {
	if x.SFixed64 == 0 {
		return offset
	}
	offset += fastpb.WriteFixed64(buf[offset:], 9, x.GetSFixed64())
	return offset
}

func (x *Scalars) fastWriteField10(buf []byte) (offset int) {
	if x.SSfixed32 == 0 {
		return offset
	}
	offset += fastpb.WriteSfixed32(buf[offset:], 10, x.GetSSfixed32())
	return offset
}

func (x *Scalars) fastWriteField11(buf []byte) (offset int) {
	if x.SSfixed64 == 0 {
		return offset
	}
	offset += fastpb.WriteSfixed64(buf[offset:], 11, x.GetSSfixed64())
	return offset
}

func (x *Scalars) fastWriteField13(buf []byte) (offset int) {
	if x.SString == "" {
		return offset
	}
	offset += fastpb.WriteString(buf[offset:], 13, x.GetSString())
	return offset
}

func (x *Scalars) fastWriteField14(buf []byte) (offset int) {
	if len(x.SBytes) == 0 {
		return offset
	}
	offset += fastpb.WriteBytes(buf[offset:], 14, x.GetSBytes())
	return offset
}

func (x *Scalars) fastWriteField20(buf []byte) (offset int) {
	if x.SFloat == 0 {
		return offset
	}
	offset += fastpb.WriteFloat(buf[offset:], 20, x.GetSFloat())
	return offset
}

func (x *Scalars) fastWriteField21(buf []byte) (offset int) {
	if x.SDouble == 0 {
		return offset
	}
	offset += fastpb.WriteDouble(buf[offset:], 21, x.GetSDouble())
	return offset
}

func (x *Repeats) 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:])
	return offset
}

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

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

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

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

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

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

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

func (x *Repeats) fastWriteField8(buf []byte) (offset int) {
	if len(x.RptString) == 0 {
		return offset
	}
	for i := range x.GetRptString() {
		offset += fastpb.WriteString(buf[offset:], 8, x.GetRptString()[i])
	}
	return offset
}

func (x *Repeats) fastWriteField9(buf []byte) (offset int) {
	if len(x.RptBytes) == 0 {
		return offset
	}
	for i := range x.GetRptBytes() {
		offset += fastpb.WriteBytes(buf[offset:], 9, x.GetRptBytes()[i])
	}
	return offset
}

func (x *Proto3Optional) 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:])
	return offset
}

func (x *Proto3Optional) fastWriteField1(buf []byte) (offset int) {
	if x.OptBool == nil {
		return offset
	}
	offset += fastpb.WriteBool(buf[offset:], 1, x.GetOptBool())
	return offset
}

func (x *Proto3Optional) fastWriteField2(buf []byte) (offset int) {
	if x.OptInt32 == nil {
		return offset
	}
	offset += fastpb.WriteInt32(buf[offset:], 2, x.GetOptInt32())
	return offset
}

func (x *Proto3Optional) fastWriteField3(buf []byte) (offset int) {
	if x.OptInt64 == nil {
		return offset
	}
	offset += fastpb.WriteInt64(buf[offset:], 3, x.GetOptInt64())
	return offset
}

func (x *Proto3Optional) fastWriteField4(buf []byte) (offset int) {
	if x.OptUint32 == nil {
		return offset
	}
	offset += fastpb.WriteUint32(buf[offset:], 4, x.GetOptUint32())
	return offset
}

func (x *Proto3Optional) fastWriteField5(buf []byte) (offset int) {
	if x.OptUint64 == nil {
		return offset
	}
	offset += fastpb.WriteUint64(buf[offset:], 5, x.GetOptUint64())
	return offset
}

func (x *Proto3Optional) fastWriteField6(buf []byte) (offset int) {
	if x.OptFloat == nil {
		return offset
	}
	offset += fastpb.WriteFloat(buf[offset:], 6, x.GetOptFloat())
	return offset
}

func (x *Proto3Optional) fastWriteField7(buf []byte) (offset int) {
	if x.OptDouble == nil {
		return offset
	}
	offset += fastpb.WriteDouble(buf[offset:], 7, x.GetOptDouble())
	return offset
}

func (x *Proto3Optional) fastWriteField8(buf []byte) (offset int) {
	if x.OptString == nil {
		return offset
	}
	offset += fastpb.WriteString(buf[offset:], 8, x.GetOptString())
	return offset
}

func (x *Proto3Optional) fastWriteField9(buf []byte) (offset int) {
	if x.OptBytes == nil {
		return offset
	}
	offset += fastpb.WriteBytes(buf[offset:], 9, x.GetOptBytes())
	return offset
}

func (x *Proto3Optional) fastWriteField10(buf []byte) (offset int) {
	if x.OptEnum == nil {
		return offset
	}
	offset += fastpb.WriteInt32(buf[offset:], 10, int32(x.GetOptEnum()))
	return offset
}

func (x *Proto3Optional) fastWriteField11(buf []byte) (offset int) {
	if x.OptMessage == nil {
		return offset
	}
	offset += fastpb.WriteMessage(buf[offset:], 11, x.GetOptMessage())
	return offset
}

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

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

func (x *Enums) fastWriteField3(buf []byte) (offset int) {
	if x.SNestedEnum == 0 {
		return offset
	}
	offset += fastpb.WriteInt32(buf[offset:], 3, int32(x.GetSNestedEnum()))
	return offset
}

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

func (x *Nests) fastWriteField2(buf []byte) (offset int) {
	if x.SNested == nil {
		return offset
	}
	offset += fastpb.WriteMessage(buf[offset:], 2, x.GetSNested())
	return offset
}

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

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

func (x *Nested) fastWriteField2(buf []byte) (offset int) {
	if x.Base == nil {
		return offset
	}
	offset += fastpb.WriteMessage(buf[offset:], 2, x.GetBase())
	return offset
}

func (x *Oneofs) 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:])
	return offset
}

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

func (x *Oneofs) fastWriteField2(buf []byte) (offset int) {
	if x.GetOneofString() == "" {
		return offset
	}
	offset += fastpb.WriteString(buf[offset:], 2, x.GetOneofString())
	return offset
}

func (x *Oneofs) fastWriteField3(buf []byte) (offset int) {
	if x.GetOneofNested() == nil {
		return offset
	}
	offset += fastpb.WriteMessage(buf[offset:], 3, x.GetOneofNested())
	return offset
}

func (x *Maps) 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:])
	return offset
}

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

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

func (x *Maps) fastWriteField3(buf []byte) (offset int) {
	if x.Uint64ToEnum == nil {
		return offset
	}
	for k, v := range x.GetUint64ToEnum() {
		offset += fastpb.WriteMapEntry(buf[offset:], 3,
			func(buf []byte, numTagOrKey, numIdxOrVal int32) int {
				offset := 0
				offset += fastpb.WriteUint64(buf[offset:], numTagOrKey, k)
				offset += fastpb.WriteInt32(buf[offset:], numIdxOrVal, int32(v))
				return offset
			})
	}
	return offset
}

func (x *Maps) fastWriteField4(buf []byte) (offset int) {
	if x.StrToNested == nil {
		return offset
	}
	for k, v := range x.GetStrToNested() {
		offset += fastpb.WriteMapEntry(buf[offset:], 4,
			func(buf []byte, numTagOrKey, numIdxOrVal int32) int {
				offset := 0
				offset += fastpb.WriteString(buf[offset:], numTagOrKey, k)
				offset += fastpb.WriteMessage(buf[offset:], numIdxOrVal, v)
				return offset
			})
	}
	return offset
}

func (x *Maps) fastWriteField5(buf []byte) (offset int) {
	if x.StrToOneofs == nil {
		return offset
	}
	for k, v := range x.GetStrToOneofs() {
		offset += fastpb.WriteMapEntry(buf[offset:], 5,
			func(buf []byte, numTagOrKey, numIdxOrVal int32) int {
				offset := 0
				offset += fastpb.WriteString(buf[offset:], numTagOrKey, k)
				offset += fastpb.WriteMessage(buf[offset:], numIdxOrVal, v)
				return offset
			})
	}
	return offset
}

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

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

func (x *InnerBase) 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.fastWriteField13(buf[offset:])
	offset += x.fastWriteField14(buf[offset:])
	offset += x.fastWriteField20(buf[offset:])
	offset += x.fastWriteField21(buf[offset:])
	return offset
}

func (x *InnerBase) fastWriteField1(buf []byte) (offset int) {
	if !x.SBool {
		return offset
	}
	offset += fastpb.WriteBool(buf[offset:], 1, x.GetSBool())
	return offset
}

func (x *InnerBase) fastWriteField2(buf []byte) (offset int) {
	if x.SInt32 == 0 {
		return offset
	}
	offset += fastpb.WriteInt32(buf[offset:], 2, x.GetSInt32())
	return offset
}

func (x *InnerBase) fastWriteField3(buf []byte) (offset int) {
	if x.SInt64 == 0 {
		return offset
	}
	offset += fastpb.WriteInt64(buf[offset:], 3, x.GetSInt64())
	return offset
}

func (x *InnerBase) fastWriteField4(buf []byte) (offset int) {
	if x.SUint32 == 0 {
		return offset
	}
	offset += fastpb.WriteUint32(buf[offset:], 4, x.GetSUint32())
	return offset
}

func (x *InnerBase) fastWriteField5(buf []byte) (offset int) {
	if x.SUint64 == 0 {
		return offset
	}
	offset += fastpb.WriteUint64(buf[offset:], 5, x.GetSUint64())
	return offset
}

func (x *InnerBase) fastWriteField6(buf []byte) (offset int) {
	if x.SSint32 == 0 {
		return offset
	}
	offset += fastpb.WriteSint32(buf[offset:], 6, x.GetSSint32())
	return offset
}

func (x *InnerBase) fastWriteField7(buf []byte) (offset int) {
	if x.SSint64 == 0 {
		return offset
	}
	offset += fastpb.WriteSint64(buf[offset:], 7, x.GetSSint64())
	return offset
}

func (x *InnerBase) fastWriteField8(buf []byte) (offset int) {
	if x.SFixed32 == 0 {
		return offset
	}
	offset += fastpb.WriteFixed32(buf[offset:], 8, x.GetSFixed32())
	return offset
}

func (x *InnerBase) fastWriteField9(buf []byte) (offset int) {
	if x.SFixed64 == 0 {
		return offset
	}
	offset += fastpb.WriteFixed64(buf[offset:], 9, x.GetSFixed64())
	return offset
}

func (x *InnerBase) fastWriteField10(buf []byte) (offset int) {
	if x.SSfixed32 == 0 {
		return offset
	}
	offset += fastpb.WriteSfixed32(buf[offset:], 10, x.GetSSfixed32())
	return offset
}

func (x *InnerBase) fastWriteField11(buf []byte) (offset int) {
	if x.SSfixed64 == 0 {
		return offset
	}
	offset += fastpb.WriteSfixed64(buf[offset:], 11, x.GetSSfixed64())
	return offset
}

func (x *InnerBase) fastWriteField13(buf []byte) (offset int) {
	if x.SString == "" {
		return offset
	}
	offset += fastpb.WriteString(buf[offset:], 13, x.GetSString())
	return offset
}

func (x *InnerBase) fastWriteField14(buf []byte) (offset int) {
	if len(x.SBytes) == 0 {
		return offset
	}
	offset += fastpb.WriteBytes(buf[offset:], 14, x.GetSBytes())
	return offset
}

func (x *InnerBase) fastWriteField20(buf []byte) (offset int) {
	if x.SFloat == 0 {
		return offset
	}
	offset += fastpb.WriteFloat(buf[offset:], 20, x.GetSFloat())
	return offset
}

func (x *InnerBase) fastWriteField21(buf []byte) (offset int) {
	if x.SDouble == 0 {
		return offset
	}
	offset += fastpb.WriteDouble(buf[offset:], 21, x.GetSDouble())
	return offset
}

func (x *ExampleScalarsReq) 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:])
	return offset
}

func (x *ExampleScalarsReq) fastWriteField1(buf []byte) (offset int) {
	if x.Msg == nil {
		return offset
	}
	offset += fastpb.WriteString(buf[offset:], 1, x.GetMsg())
	return offset
}

func (x *ExampleScalarsReq) fastWriteField2(buf []byte) (offset int) {
	if x.Cookie == nil {
		return offset
	}
	offset += fastpb.WriteDouble(buf[offset:], 2, x.GetCookie())
	return offset
}

func (x *ExampleScalarsReq) fastWriteField3(buf []byte) (offset int) {
	if x.Path == "" {
		return offset
	}
	offset += fastpb.WriteString(buf[offset:], 3, x.GetPath())
	return offset
}

func (x *ExampleScalarsReq) fastWriteField4(buf []byte) (offset int) {
	if len(x.Query) == 0 {
		return offset
	}
	for i := range x.GetQuery() {
		offset += fastpb.WriteString(buf[offset:], 4, x.GetQuery()[i])
	}
	return offset
}

func (x *ExampleScalarsReq) fastWriteField5(buf []byte) (offset int) {
	if !x.Header {
		return offset
	}
	offset += fastpb.WriteBool(buf[offset:], 5, x.GetHeader())
	return offset
}

func (x *ExampleScalarsReq) fastWriteField6(buf []byte) (offset int) {
	if x.Code == 0 {
		return offset
	}
	offset += fastpb.WriteInt64(buf[offset:], 6, x.GetCode())
	return offset
}

func (x *ExampleScalarsReq) fastWriteField7(buf []byte) (offset int) {
	if x.InnerBase == nil {
		return offset
	}
	offset += fastpb.WriteMessage(buf[offset:], 7, x.GetInnerBase())
	return offset
}

func (x *ExampleScalarsReq) fastWriteField8(buf []byte) (offset int) {
	if x.RawUri == "" {
		return offset
	}
	offset += fastpb.WriteString(buf[offset:], 8, x.GetRawUri())
	return offset
}

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

func (x *ExampleScalarsReq) fastWriteField10(buf []byte) (offset int) {
	if x.Scalars == nil {
		return offset
	}
	offset += fastpb.WriteMessage(buf[offset:], 10, x.GetScalars())
	return offset
}

func (x *ExampleScalarsResp) 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:])
	return offset
}

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

func (x *ExampleScalarsResp) fastWriteField2(buf []byte) (offset int) {
	if x.Cookie == nil {
		return offset
	}
	offset += fastpb.WriteDouble(buf[offset:], 2, x.GetCookie())
	return offset
}

func (x *ExampleScalarsResp) fastWriteField3(buf []byte) (offset int) {
	if x.Status == 0 {
		return offset
	}
	offset += fastpb.WriteInt32(buf[offset:], 3, x.GetStatus())
	return offset
}

func (x *ExampleScalarsResp) fastWriteField4(buf []byte) (offset int) {
	if x.Header == nil {
		return offset
	}
	offset += fastpb.WriteBool(buf[offset:], 4, x.GetHeader())
	return offset
}

func (x *ExampleScalarsResp) fastWriteField5(buf []byte) (offset int) {
	if x.Code == 0 {
		return offset
	}
	offset += fastpb.WriteInt64(buf[offset:], 5, x.GetCode())
	return offset
}

func (x *ExampleScalarsResp) fastWriteField6(buf []byte) (offset int) {
	if x.Subfix == 0 {
		return offset
	}
	offset += fastpb.WriteDouble(buf[offset:], 6, x.GetSubfix())
	return offset
}

func (x *ExampleScalarsResp) fastWriteField7(buf []byte) (offset int) {
	if x.Scalars == nil {
		return offset
	}
	offset += fastpb.WriteMessage(buf[offset:], 7, x.GetScalars())
	return offset
}

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

func (x *ExampleMessageReq) fastWriteField1(buf []byte) (offset int) {
	if x.Base == nil {
		return offset
	}
	offset += fastpb.WriteMessage(buf[offset:], 1, x.GetBase())
	return offset
}

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

func (x *ExampleMessageResp) fastWriteField1(buf []byte) (offset int) {
	if x.Base == nil {
		return offset
	}
	offset += fastpb.WriteMessage(buf[offset:], 1, x.GetBase())
	return offset
}

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

func (x *ExampleNestedReq) fastWriteField1(buf []byte) (offset int) {
	if x.TestNested == nil {
		return offset
	}
	offset += fastpb.WriteMessage(buf[offset:], 1, x.GetTestNested())
	return offset
}

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

func (x *ExampleNestedResp) fastWriteField1(buf []byte) (offset int) {
	if x.TestNested == nil {
		return offset
	}
	offset += fastpb.WriteMessage(buf[offset:], 1, x.GetTestNested())
	return offset
}

func (x *ExampleParitalReq) 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:])
	return offset
}

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

func (x *ExampleParitalReq) fastWriteField2(buf []byte) (offset int) {
	if x.Cookie == nil {
		return offset
	}
	offset += fastpb.WriteDouble(buf[offset:], 2, x.GetCookie())
	return offset
}

func (x *ExampleParitalReq) fastWriteField3(buf []byte) (offset int) {
	if x.Status == 0 {
		return offset
	}
	offset += fastpb.WriteInt32(buf[offset:], 3, x.GetStatus())
	return offset
}

func (x *ExampleParitalReq) fastWriteField4(buf []byte) (offset int) {
	if !x.Header {
		return offset
	}
	offset += fastpb.WriteBool(buf[offset:], 4, x.GetHeader())
	return offset
}

func (x *ExampleParitalReq) fastWriteField5(buf []byte) (offset int) {
	if x.Code == 0 {
		return offset
	}
	offset += fastpb.WriteInt64(buf[offset:], 5, x.GetCode())
	return offset
}

func (x *ExamplePartialResp) 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:])
	return offset
}

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

func (x *ExamplePartialResp) fastWriteField2(buf []byte) (offset int) {
	if x.ChineseMsg == "" {
		return offset
	}
	offset += fastpb.WriteString(buf[offset:], 2, x.GetChineseMsg())
	return offset
}

func (x *ExamplePartialResp) fastWriteField3(buf []byte) (offset int) {
	if x.LongEnglishMsg == "" {
		return offset
	}
	offset += fastpb.WriteString(buf[offset:], 3, x.GetLongEnglishMsg())
	return offset
}

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

func (x *ExampleListReq) fastWriteField1(buf []byte) (offset int) {
	if x.TestList == nil {
		return offset
	}
	offset += fastpb.WriteMessage(buf[offset:], 1, x.GetTestList())
	return offset
}

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

func (x *ExampleListResp) fastWriteField1(buf []byte) (offset int) {
	if x.TestList == nil {
		return offset
	}
	offset += fastpb.WriteMessage(buf[offset:], 1, x.GetTestList())
	return offset
}

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

func (x *ExampleMapReq) fastWriteField1(buf []byte) (offset int) {
	if x.TestMap == nil {
		return offset
	}
	offset += fastpb.WriteMessage(buf[offset:], 1, x.GetTestMap())
	return offset
}

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

func (x *ExampleMapResp) fastWriteField1(buf []byte) (offset int) {
	if x.TestMap == nil {
		return offset
	}
	offset += fastpb.WriteMessage(buf[offset:], 1, x.GetTestMap())
	return offset
}

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

func (x *ExampleOneofReq) fastWriteField1(buf []byte) (offset int) {
	if x.TestOneof == nil {
		return offset
	}
	offset += fastpb.WriteMessage(buf[offset:], 1, x.GetTestOneof())
	return offset
}

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

func (x *ExampleOneofResp) fastWriteField1(buf []byte) (offset int) {
	if x.TestOneof == nil {
		return offset
	}
	offset += fastpb.WriteMessage(buf[offset:], 1, x.GetTestOneof())
	return offset
}

func (x *Scalars) 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.sizeField13()
	n += x.sizeField14()
	n += x.sizeField20()
	n += x.sizeField21()
	return n
}

func (x *Scalars) sizeField1() (n int) {
	if !x.SBool {
		return n
	}
	n += fastpb.SizeBool(1, x.GetSBool())
	return n
}

func (x *Scalars) sizeField2() (n int) {
	if x.SInt32 == 0 {
		return n
	}
	n += fastpb.SizeInt32(2, x.GetSInt32())
	return n
}

func (x *Scalars) sizeField3() (n int) {
	if x.SInt64 == 0 {
		return n
	}
	n += fastpb.SizeInt64(3, x.GetSInt64())
	return n
}

func (x *Scalars) sizeField4() (n int) {
	if x.SUint32 == 0 {
		return n
	}
	n += fastpb.SizeUint32(4, x.GetSUint32())
	return n
}

func (x *Scalars) sizeField5() (n int) {
	if x.SUint64 == 0 {
		return n
	}
	n += fastpb.SizeUint64(5, x.GetSUint64())
	return n
}

func (x *Scalars) sizeField6() (n int) {
	if x.SSint32 == 0 {
		return n
	}
	n += fastpb.SizeSint32(6, x.GetSSint32())
	return n
}

func (x *Scalars) sizeField7() (n int) {
	if x.SSint64 == 0 {
		return n
	}
	n += fastpb.SizeSint64(7, x.GetSSint64())
	return n
}

func (x *Scalars) sizeField8() (n int) {
	if x.SFixed32 == 0 {
		return n
	}
	n += fastpb.SizeFixed32(8, x.GetSFixed32())
	return n
}

func (x *Scalars) sizeField9() (n int) {
	if x.SFixed64 == 0 {
		return n
	}
	n += fastpb.SizeFixed64(9, x.GetSFixed64())
	return n
}

func (x *Scalars) sizeField10() (n int) {
	if x.SSfixed32 == 0 {
		return n
	}
	n += fastpb.SizeSfixed32(10, x.GetSSfixed32())
	return n
}

func (x *Scalars) sizeField11() (n int) {
	if x.SSfixed64 == 0 {
		return n
	}
	n += fastpb.SizeSfixed64(11, x.GetSSfixed64())
	return n
}

func (x *Scalars) sizeField13() (n int) {
	if x.SString == "" {
		return n
	}
	n += fastpb.SizeString(13, x.GetSString())
	return n
}

func (x *Scalars) sizeField14() (n int) {
	if len(x.SBytes) == 0 {
		return n
	}
	n += fastpb.SizeBytes(14, x.GetSBytes())
	return n
}

func (x *Scalars) sizeField20() (n int) {
	if x.SFloat == 0 {
		return n
	}
	n += fastpb.SizeFloat(20, x.GetSFloat())
	return n
}

func (x *Scalars) sizeField21() (n int) {
	if x.SDouble == 0 {
		return n
	}
	n += fastpb.SizeDouble(21, x.GetSDouble())
	return n
}

func (x *Repeats) 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()
	return n
}

func (x *Repeats) sizeField1() (n int) {
	if len(x.RptBool) == 0 {
		return n
	}
	n += fastpb.SizeListPacked(1, len(x.GetRptBool()),
		func(numTagOrKey, numIdxOrVal int32) int {
			n := 0
			n += fastpb.SizeBool(numTagOrKey, x.GetRptBool()[numIdxOrVal])
			return n
		})
	return n
}

func (x *Repeats) sizeField2() (n int) {
	if len(x.RptInt32) == 0 {
		return n
	}
	n += fastpb.SizeListPacked(2, len(x.GetRptInt32()),
		func(numTagOrKey, numIdxOrVal int32) int {
			n := 0
			n += fastpb.SizeInt32(numTagOrKey, x.GetRptInt32()[numIdxOrVal])
			return n
		})
	return n
}

func (x *Repeats) sizeField3() (n int) {
	if len(x.RptInt64) == 0 {
		return n
	}
	n += fastpb.SizeListPacked(3, len(x.GetRptInt64()),
		func(numTagOrKey, numIdxOrVal int32) int {
			n := 0
			n += fastpb.SizeInt64(numTagOrKey, x.GetRptInt64()[numIdxOrVal])
			return n
		})
	return n
}

func (x *Repeats) sizeField4() (n int) {
	if len(x.RptUint32) == 0 {
		return n
	}
	n += fastpb.SizeListPacked(4, len(x.GetRptUint32()),
		func(numTagOrKey, numIdxOrVal int32) int {
			n := 0
			n += fastpb.SizeUint32(numTagOrKey, x.GetRptUint32()[numIdxOrVal])
			return n
		})
	return n
}

func (x *Repeats) sizeField5() (n int) {
	if len(x.RptUint64) == 0 {
		return n
	}
	n += fastpb.SizeListPacked(5, len(x.GetRptUint64()),
		func(numTagOrKey, numIdxOrVal int32) int {
			n := 0
			n += fastpb.SizeUint64(numTagOrKey, x.GetRptUint64()[numIdxOrVal])
			return n
		})
	return n
}

func (x *Repeats) sizeField6() (n int) {
	if len(x.RptFloat) == 0 {
		return n
	}
	n += fastpb.SizeListPacked(6, len(x.GetRptFloat()),
		func(numTagOrKey, numIdxOrVal int32) int {
			n := 0
			n += fastpb.SizeFloat(numTagOrKey, x.GetRptFloat()[numIdxOrVal])
			return n
		})
	return n
}

func (x *Repeats) sizeField7() (n int) {
	if len(x.RptDouble) == 0 {
		return n
	}
	n += fastpb.SizeListPacked(7, len(x.GetRptDouble()),
		func(numTagOrKey, numIdxOrVal int32) int {
			n := 0
			n += fastpb.SizeDouble(numTagOrKey, x.GetRptDouble()[numIdxOrVal])
			return n
		})
	return n
}

func (x *Repeats) sizeField8() (n int) {
	if len(x.RptString) == 0 {
		return n
	}
	for i := range x.GetRptString() {
		n += fastpb.SizeString(8, x.GetRptString()[i])
	}
	return n
}

func (x *Repeats) sizeField9() (n int) {
	if len(x.RptBytes) == 0 {
		return n
	}
	for i := range x.GetRptBytes() {
		n += fastpb.SizeBytes(9, x.GetRptBytes()[i])
	}
	return n
}

func (x *Proto3Optional) 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()
	return n
}

func (x *Proto3Optional) sizeField1() (n int) {
	if x.OptBool == nil {
		return n
	}
	n += fastpb.SizeBool(1, x.GetOptBool())
	return n
}

func (x *Proto3Optional) sizeField2() (n int) {
	if x.OptInt32 == nil {
		return n
	}
	n += fastpb.SizeInt32(2, x.GetOptInt32())
	return n
}

func (x *Proto3Optional) sizeField3() (n int) {
	if x.OptInt64 == nil {
		return n
	}
	n += fastpb.SizeInt64(3, x.GetOptInt64())
	return n
}

func (x *Proto3Optional) sizeField4() (n int) {
	if x.OptUint32 == nil {
		return n
	}
	n += fastpb.SizeUint32(4, x.GetOptUint32())
	return n
}

func (x *Proto3Optional) sizeField5() (n int) {
	if x.OptUint64 == nil {
		return n
	}
	n += fastpb.SizeUint64(5, x.GetOptUint64())
	return n
}

func (x *Proto3Optional) sizeField6() (n int) {
	if x.OptFloat == nil {
		return n
	}
	n += fastpb.SizeFloat(6, x.GetOptFloat())
	return n
}

func (x *Proto3Optional) sizeField7() (n int) {
	if x.OptDouble == nil {
		return n
	}
	n += fastpb.SizeDouble(7, x.GetOptDouble())
	return n
}

func (x *Proto3Optional) sizeField8() (n int) {
	if x.OptString == nil {
		return n
	}
	n += fastpb.SizeString(8, x.GetOptString())
	return n
}

func (x *Proto3Optional) sizeField9() (n int) {
	if x.OptBytes == nil {
		return n
	}
	n += fastpb.SizeBytes(9, x.GetOptBytes())
	return n
}

func (x *Proto3Optional) sizeField10() (n int) {
	if x.OptEnum == nil {
		return n
	}
	n += fastpb.SizeInt32(10, int32(x.GetOptEnum()))
	return n
}

func (x *Proto3Optional) sizeField11() (n int) {
	if x.OptMessage == nil {
		return n
	}
	n += fastpb.SizeMessage(11, x.GetOptMessage())
	return n
}

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

func (x *Enums) sizeField1() (n int) {
	if x.SEnum == 0 {
		return n
	}
	n += fastpb.SizeInt32(1, int32(x.GetSEnum()))
	return n
}

func (x *Enums) sizeField3() (n int) {
	if x.SNestedEnum == 0 {
		return n
	}
	n += fastpb.SizeInt32(3, int32(x.GetSNestedEnum()))
	return n
}

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

func (x *Nests) sizeField2() (n int) {
	if x.SNested == nil {
		return n
	}
	n += fastpb.SizeMessage(2, x.GetSNested())
	return n
}

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

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

func (x *Nested) sizeField2() (n int) {
	if x.Base == nil {
		return n
	}
	n += fastpb.SizeMessage(2, x.GetBase())
	return n
}

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

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

func (x *Oneofs) sizeField2() (n int) {
	if x.GetOneofString() == "" {
		return n
	}
	n += fastpb.SizeString(2, x.GetOneofString())
	return n
}

func (x *Oneofs) sizeField3() (n int) {
	if x.GetOneofNested() == nil {
		return n
	}
	n += fastpb.SizeMessage(3, x.GetOneofNested())
	return n
}

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

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

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

func (x *Maps) sizeField3() (n int) {
	if x.Uint64ToEnum == nil {
		return n
	}
	for k, v := range x.GetUint64ToEnum() {
		n += fastpb.SizeMapEntry(3,
			func(numTagOrKey, numIdxOrVal int32) int {
				n := 0
				n += fastpb.SizeUint64(numTagOrKey, k)
				n += fastpb.SizeInt32(numIdxOrVal, int32(v))
				return n
			})
	}
	return n
}

func (x *Maps) sizeField4() (n int) {
	if x.StrToNested == nil {
		return n
	}
	for k, v := range x.GetStrToNested() {
		n += fastpb.SizeMapEntry(4,
			func(numTagOrKey, numIdxOrVal int32) int {
				n := 0
				n += fastpb.SizeString(numTagOrKey, k)
				n += fastpb.SizeMessage(numIdxOrVal, v)
				return n
			})
	}
	return n
}

func (x *Maps) sizeField5() (n int) {
	if x.StrToOneofs == nil {
		return n
	}
	for k, v := range x.GetStrToOneofs() {
		n += fastpb.SizeMapEntry(5,
			func(numTagOrKey, numIdxOrVal int32) int {
				n := 0
				n += fastpb.SizeString(numTagOrKey, k)
				n += fastpb.SizeMessage(numIdxOrVal, v)
				return n
			})
	}
	return n
}

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

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

func (x *InnerBase) 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.sizeField13()
	n += x.sizeField14()
	n += x.sizeField20()
	n += x.sizeField21()
	return n
}

func (x *InnerBase) sizeField1() (n int) {
	if !x.SBool {
		return n
	}
	n += fastpb.SizeBool(1, x.GetSBool())
	return n
}

func (x *InnerBase) sizeField2() (n int) {
	if x.SInt32 == 0 {
		return n
	}
	n += fastpb.SizeInt32(2, x.GetSInt32())
	return n
}

func (x *InnerBase) sizeField3() (n int) {
	if x.SInt64 == 0 {
		return n
	}
	n += fastpb.SizeInt64(3, x.GetSInt64())
	return n
}

func (x *InnerBase) sizeField4() (n int) {
	if x.SUint32 == 0 {
		return n
	}
	n += fastpb.SizeUint32(4, x.GetSUint32())
	return n
}

func (x *InnerBase) sizeField5() (n int) {
	if x.SUint64 == 0 {
		return n
	}
	n += fastpb.SizeUint64(5, x.GetSUint64())
	return n
}

func (x *InnerBase) sizeField6() (n int) {
	if x.SSint32 == 0 {
		return n
	}
	n += fastpb.SizeSint32(6, x.GetSSint32())
	return n
}

func (x *InnerBase) sizeField7() (n int) {
	if x.SSint64 == 0 {
		return n
	}
	n += fastpb.SizeSint64(7, x.GetSSint64())
	return n
}

func (x *InnerBase) sizeField8() (n int) {
	if x.SFixed32 == 0 {
		return n
	}
	n += fastpb.SizeFixed32(8, x.GetSFixed32())
	return n
}

func (x *InnerBase) sizeField9() (n int) {
	if x.SFixed64 == 0 {
		return n
	}
	n += fastpb.SizeFixed64(9, x.GetSFixed64())
	return n
}

func (x *InnerBase) sizeField10() (n int) {
	if x.SSfixed32 == 0 {
		return n
	}
	n += fastpb.SizeSfixed32(10, x.GetSSfixed32())
	return n
}

func (x *InnerBase) sizeField11() (n int) {
	if x.SSfixed64 == 0 {
		return n
	}
	n += fastpb.SizeSfixed64(11, x.GetSSfixed64())
	return n
}

func (x *InnerBase) sizeField13() (n int) {
	if x.SString == "" {
		return n
	}
	n += fastpb.SizeString(13, x.GetSString())
	return n
}

func (x *InnerBase) sizeField14() (n int) {
	if len(x.SBytes) == 0 {
		return n
	}
	n += fastpb.SizeBytes(14, x.GetSBytes())
	return n
}

func (x *InnerBase) sizeField20() (n int) {
	if x.SFloat == 0 {
		return n
	}
	n += fastpb.SizeFloat(20, x.GetSFloat())
	return n
}

func (x *InnerBase) sizeField21() (n int) {
	if x.SDouble == 0 {
		return n
	}
	n += fastpb.SizeDouble(21, x.GetSDouble())
	return n
}

func (x *ExampleScalarsReq) 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()
	return n
}

func (x *ExampleScalarsReq) sizeField1() (n int) {
	if x.Msg == nil {
		return n
	}
	n += fastpb.SizeString(1, x.GetMsg())
	return n
}

func (x *ExampleScalarsReq) sizeField2() (n int) {
	if x.Cookie == nil {
		return n
	}
	n += fastpb.SizeDouble(2, x.GetCookie())
	return n
}

func (x *ExampleScalarsReq) sizeField3() (n int) {
	if x.Path == "" {
		return n
	}
	n += fastpb.SizeString(3, x.GetPath())
	return n
}

func (x *ExampleScalarsReq) sizeField4() (n int) {
	if len(x.Query) == 0 {
		return n
	}
	for i := range x.GetQuery() {
		n += fastpb.SizeString(4, x.GetQuery()[i])
	}
	return n
}

func (x *ExampleScalarsReq) sizeField5() (n int) {
	if !x.Header {
		return n
	}
	n += fastpb.SizeBool(5, x.GetHeader())
	return n
}

func (x *ExampleScalarsReq) sizeField6() (n int) {
	if x.Code == 0 {
		return n
	}
	n += fastpb.SizeInt64(6, x.GetCode())
	return n
}

func (x *ExampleScalarsReq) sizeField7() (n int) {
	if x.InnerBase == nil {
		return n
	}
	n += fastpb.SizeMessage(7, x.GetInnerBase())
	return n
}

func (x *ExampleScalarsReq) sizeField8() (n int) {
	if x.RawUri == "" {
		return n
	}
	n += fastpb.SizeString(8, x.GetRawUri())
	return n
}

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

func (x *ExampleScalarsReq) sizeField10() (n int) {
	if x.Scalars == nil {
		return n
	}
	n += fastpb.SizeMessage(10, x.GetScalars())
	return n
}

func (x *ExampleScalarsResp) 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()
	return n
}

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

func (x *ExampleScalarsResp) sizeField2() (n int) {
	if x.Cookie == nil {
		return n
	}
	n += fastpb.SizeDouble(2, x.GetCookie())
	return n
}

func (x *ExampleScalarsResp) sizeField3() (n int) {
	if x.Status == 0 {
		return n
	}
	n += fastpb.SizeInt32(3, x.GetStatus())
	return n
}

func (x *ExampleScalarsResp) sizeField4() (n int) {
	if x.Header == nil {
		return n
	}
	n += fastpb.SizeBool(4, x.GetHeader())
	return n
}

func (x *ExampleScalarsResp) sizeField5() (n int) {
	if x.Code == 0 {
		return n
	}
	n += fastpb.SizeInt64(5, x.GetCode())
	return n
}

func (x *ExampleScalarsResp) sizeField6() (n int) {
	if x.Subfix == 0 {
		return n
	}
	n += fastpb.SizeDouble(6, x.GetSubfix())
	return n
}

func (x *ExampleScalarsResp) sizeField7() (n int) {
	if x.Scalars == nil {
		return n
	}
	n += fastpb.SizeMessage(7, x.GetScalars())
	return n
}

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

func (x *ExampleMessageReq) sizeField1() (n int) {
	if x.Base == nil {
		return n
	}
	n += fastpb.SizeMessage(1, x.GetBase())
	return n
}

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

func (x *ExampleMessageResp) sizeField1() (n int) {
	if x.Base == nil {
		return n
	}
	n += fastpb.SizeMessage(1, x.GetBase())
	return n
}

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

func (x *ExampleNestedReq) sizeField1() (n int) {
	if x.TestNested == nil {
		return n
	}
	n += fastpb.SizeMessage(1, x.GetTestNested())
	return n
}

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

func (x *ExampleNestedResp) sizeField1() (n int) {
	if x.TestNested == nil {
		return n
	}
	n += fastpb.SizeMessage(1, x.GetTestNested())
	return n
}

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

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

func (x *ExampleParitalReq) sizeField2() (n int) {
	if x.Cookie == nil {
		return n
	}
	n += fastpb.SizeDouble(2, x.GetCookie())
	return n
}

func (x *ExampleParitalReq) sizeField3() (n int) {
	if x.Status == 0 {
		return n
	}
	n += fastpb.SizeInt32(3, x.GetStatus())
	return n
}

func (x *ExampleParitalReq) sizeField4() (n int) {
	if !x.Header {
		return n
	}
	n += fastpb.SizeBool(4, x.GetHeader())
	return n
}

func (x *ExampleParitalReq) sizeField5() (n int) {
	if x.Code == 0 {
		return n
	}
	n += fastpb.SizeInt64(5, x.GetCode())
	return n
}

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

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

func (x *ExamplePartialResp) sizeField2() (n int) {
	if x.ChineseMsg == "" {
		return n
	}
	n += fastpb.SizeString(2, x.GetChineseMsg())
	return n
}

func (x *ExamplePartialResp) sizeField3() (n int) {
	if x.LongEnglishMsg == "" {
		return n
	}
	n += fastpb.SizeString(3, x.GetLongEnglishMsg())
	return n
}

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

func (x *ExampleListReq) sizeField1() (n int) {
	if x.TestList == nil {
		return n
	}
	n += fastpb.SizeMessage(1, x.GetTestList())
	return n
}

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

func (x *ExampleListResp) sizeField1() (n int) {
	if x.TestList == nil {
		return n
	}
	n += fastpb.SizeMessage(1, x.GetTestList())
	return n
}

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

func (x *ExampleMapReq) sizeField1() (n int) {
	if x.TestMap == nil {
		return n
	}
	n += fastpb.SizeMessage(1, x.GetTestMap())
	return n
}

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

func (x *ExampleMapResp) sizeField1() (n int) {
	if x.TestMap == nil {
		return n
	}
	n += fastpb.SizeMessage(1, x.GetTestMap())
	return n
}

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

func (x *ExampleOneofReq) sizeField1() (n int) {
	if x.TestOneof == nil {
		return n
	}
	n += fastpb.SizeMessage(1, x.GetTestOneof())
	return n
}

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

func (x *ExampleOneofResp) sizeField1() (n int) {
	if x.TestOneof == nil {
		return n
	}
	n += fastpb.SizeMessage(1, x.GetTestOneof())
	return n
}

var fieldIDToName_Scalars = map[int32]string{
	1:  "SBool",
	2:  "SInt32",
	3:  "SInt64",
	4:  "SUint32",
	5:  "SUint64",
	6:  "SSint32",
	7:  "SSint64",
	8:  "SFixed32",
	9:  "SFixed64",
	10: "SSfixed32",
	11: "SSfixed64",
	13: "SString",
	14: "SBytes",
	20: "SFloat",
	21: "SDouble",
}

var fieldIDToName_Repeats = map[int32]string{
	1: "RptBool",
	2: "RptInt32",
	3: "RptInt64",
	4: "RptUint32",
	5: "RptUint64",
	6: "RptFloat",
	7: "RptDouble",
	8: "RptString",
	9: "RptBytes",
}

var fieldIDToName_Proto3Optional = map[int32]string{
	1:  "OptBool",
	2:  "OptInt32",
	3:  "OptInt64",
	4:  "OptUint32",
	5:  "OptUint64",
	6:  "OptFloat",
	7:  "OptDouble",
	8:  "OptString",
	9:  "OptBytes",
	10: "OptEnum",
	11: "OptMessage",
}

var fieldIDToName_Enums = map[int32]string{
	1: "SEnum",
	3: "SNestedEnum",
}

var fieldIDToName_Nests = map[int32]string{
	2: "SNested",
}

var fieldIDToName_Nested = map[int32]string{
	1: "SString",
	2: "Base",
}

var fieldIDToName_Oneofs = map[int32]string{
	1: "OneofEnum",
	2: "OneofString",
	3: "OneofNested",
}

var fieldIDToName_Maps = map[int32]string{
	1: "Int32ToStr",
	2: "BoolToUint32",
	3: "Uint64ToEnum",
	4: "StrToNested",
	5: "StrToOneofs",
}

var fieldIDToName_JSONNames = map[int32]string{
	1: "SString",
}

var fieldIDToName_InnerBase = map[int32]string{
	1:  "SBool",
	2:  "SInt32",
	3:  "SInt64",
	4:  "SUint32",
	5:  "SUint64",
	6:  "SSint32",
	7:  "SSint64",
	8:  "SFixed32",
	9:  "SFixed64",
	10: "SSfixed32",
	11: "SSfixed64",
	13: "SString",
	14: "SBytes",
	20: "SFloat",
	21: "SDouble",
}

var fieldIDToName_ExampleScalarsReq = map[int32]string{
	1:  "Msg",
	2:  "Cookie",
	3:  "Path",
	4:  "Query",
	5:  "Header",
	6:  "Code",
	7:  "InnerBase",
	8:  "RawUri",
	9:  "Subfix",
	10: "Scalars",
}

var fieldIDToName_ExampleScalarsResp = map[int32]string{
	1: "Msg",
	2: "Cookie",
	3: "Status",
	4: "Header",
	5: "Code",
	6: "Subfix",
	7: "Scalars",
}

var fieldIDToName_ExampleMessageReq = map[int32]string{
	1: "Base",
}

var fieldIDToName_ExampleMessageResp = map[int32]string{
	1: "Base",
}

var fieldIDToName_ExampleNestedReq = map[int32]string{
	1: "TestNested",
}

var fieldIDToName_ExampleNestedResp = map[int32]string{
	1: "TestNested",
}

var fieldIDToName_ExampleParitalReq = map[int32]string{
	1: "Msg",
	2: "Cookie",
	3: "Status",
	4: "Header",
	5: "Code",
}

var fieldIDToName_ExamplePartialResp = map[int32]string{
	1: "ShortEnglishMsg",
	2: "ChineseMsg",
	3: "LongEnglishMsg",
}

var fieldIDToName_ExampleListReq = map[int32]string{
	1: "TestList",
}

var fieldIDToName_ExampleListResp = map[int32]string{
	1: "TestList",
}

var fieldIDToName_ExampleMapReq = map[int32]string{
	1: "TestMap",
}

var fieldIDToName_ExampleMapResp = map[int32]string{
	1: "TestMap",
}

var fieldIDToName_ExampleOneofReq = map[int32]string{
	1: "TestOneof",
}

var fieldIDToName_ExampleOneofResp = map[int32]string{
	1: "TestOneof",
}