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

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

package example2

import (
	fmt "fmt"
	base "github.com/cloudwego/dynamicgo/testdata/kitex_gen/pb/base"
	fastpb "github.com/cloudwego/fastpb"
)

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

func (x *InnerBase2) FastRead(buf []byte, _type int8, number int32) (offset int, err error) {
	switch number {
	case 1:
		offset, err = x.fastReadField1(buf, _type)
		if err != nil {
			goto ReadFieldError
		}
	case 2:
		offset, err = x.fastReadField2(buf, _type)
		if err != nil {
			goto ReadFieldError
		}
	case 3:
		offset, err = x.fastReadField3(buf, _type)
		if err != nil {
			goto ReadFieldError
		}
	case 4:
		offset, err = x.fastReadField4(buf, _type)
		if err != nil {
			goto ReadFieldError
		}
	case 5:
		offset, err = x.fastReadField5(buf, _type)
		if err != nil {
			goto ReadFieldError
		}
	case 6:
		offset, err = x.fastReadField6(buf, _type)
		if err != nil {
			goto ReadFieldError
		}
	case 7:
		offset, err = x.fastReadField7(buf, _type)
		if err != nil {
			goto ReadFieldError
		}
	case 8:
		offset, err = x.fastReadField8(buf, _type)
		if err != nil {
			goto ReadFieldError
		}
	case 9:
		offset, err = x.fastReadField9(buf, _type)
		if err != nil {
			goto ReadFieldError
		}
	case 10:
		offset, err = x.fastReadField10(buf, _type)
		if err != nil {
			goto ReadFieldError
		}
	case 11:
		offset, err = x.fastReadField11(buf, _type)
		if err != nil {
			goto ReadFieldError
		}
	case 12:
		offset, err = x.fastReadField12(buf, _type)
		if err != nil {
			goto ReadFieldError
		}
	case 13:
		offset, err = x.fastReadField13(buf, _type)
		if err != nil {
			goto ReadFieldError
		}
	case 14:
		offset, err = x.fastReadField14(buf, _type)
		if err != nil {
			goto ReadFieldError
		}
	case 15:
		offset, err = x.fastReadField15(buf, _type)
		if err != nil {
			goto ReadFieldError
		}
	case 16:
		offset, err = x.fastReadField16(buf, _type)
		if err != nil {
			goto ReadFieldError
		}
	case 17:
		offset, err = x.fastReadField17(buf, _type)
		if err != nil {
			goto ReadFieldError
		}
	case 18:
		offset, err = x.fastReadField18(buf, _type)
		if err != nil {
			goto ReadFieldError
		}
	case 19:
		offset, err = x.fastReadField19(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
		}
	case 255:
		offset, err = x.fastReadField255(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_InnerBase2[number], err)
}

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

func (x *InnerBase2) fastReadField2(buf []byte, _type int8) (offset int, err error) {
	x.Uint32, offset, err = fastpb.ReadUint32(buf, _type)
	return offset, err
}

func (x *InnerBase2) fastReadField3(buf []byte, _type int8) (offset int, err error) {
	x.Uint64, offset, err = fastpb.ReadUint64(buf, _type)
	return offset, err
}

func (x *InnerBase2) fastReadField4(buf []byte, _type int8) (offset int, err error) {
	x.Int32, offset, err = fastpb.ReadInt32(buf, _type)
	return offset, err
}

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

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

func (x *InnerBase2) fastReadField7(buf []byte, _type int8) (offset int, err error) {
	x.String_, offset, err = fastpb.ReadString(buf, _type)
	return offset, err
}

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

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

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

func (x *InnerBase2) fastReadField11(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.Foo = FOO(v)
	return offset, nil
}

func (x *InnerBase2) fastReadField12(buf []byte, _type int8) (offset int, err error) {
	if x.MapInt32String == nil {
		x.MapInt32String = 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.MapInt32String[key] = value
	return offset, nil
}

func (x *InnerBase2) fastReadField13(buf []byte, _type int8) (offset int, err error) {
	x.Binary, offset, err = fastpb.ReadBytes(buf, _type)
	return offset, err
}

func (x *InnerBase2) fastReadField14(buf []byte, _type int8) (offset int, err error) {
	if x.MapUint32String == nil {
		x.MapUint32String = make(map[uint32]string)
	}
	var key uint32
	var value string
	offset, err = fastpb.ReadMapEntry(buf, _type,
		func(buf []byte, _type int8) (offset int, err error) {
			key, offset, err = fastpb.ReadUint32(buf, _type)
			return offset, err
		},
		func(buf []byte, _type int8) (offset int, err error) {
			value, offset, err = fastpb.ReadString(buf, _type)
			return offset, err
		})
	if err != nil {
		return offset, err
	}
	x.MapUint32String[key] = value
	return offset, nil
}

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

func (x *InnerBase2) fastReadField16(buf []byte, _type int8) (offset int, err error) {
	if x.MapInt64String == nil {
		x.MapInt64String = make(map[int64]string)
	}
	var key int64
	var value string
	offset, err = fastpb.ReadMapEntry(buf, _type,
		func(buf []byte, _type int8) (offset int, err error) {
			key, offset, err = fastpb.ReadInt64(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.MapInt64String[key] = value
	return offset, nil
}

func (x *InnerBase2) fastReadField17(buf []byte, _type int8) (offset int, err error) {
	if x.MapInt64Base == nil {
		x.MapInt64Base = make(map[int64]*base.Base)
	}
	var key int64
	var value *base.Base
	offset, err = fastpb.ReadMapEntry(buf, _type,
		func(buf []byte, _type int8) (offset int, err error) {
			key, offset, err = fastpb.ReadInt64(buf, _type)
			return offset, err
		},
		func(buf []byte, _type int8) (offset int, err error) {
			var v base.Base
			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.MapInt64Base[key] = value
	return offset, nil
}

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

func (x *InnerBase2) fastReadField19(buf []byte, _type int8) (offset int, err error) {
	var v base.Base
	offset, err = fastpb.ReadMessage(buf, _type, &v)
	if err != nil {
		return offset, err
	}
	x.ListBase = append(x.ListBase, &v)
	return offset, nil
}

func (x *InnerBase2) fastReadField20(buf []byte, _type int8) (offset int, err error) {
	if x.MapStringBase == nil {
		x.MapStringBase = make(map[string]*base.Base)
	}
	var key string
	var value *base.Base
	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 base.Base
			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.MapStringBase[key] = value
	return offset, nil
}

func (x *InnerBase2) fastReadField21(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.ListString = append(x.ListString, v)
	return offset, err
}

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

func (x *InnerBasePartial) 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 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 18:
		offset, err = x.fastReadField18(buf, _type)
		if err != nil {
			goto ReadFieldError
		}
	case 19:
		offset, err = x.fastReadField19(buf, _type)
		if err != nil {
			goto ReadFieldError
		}
	case 20:
		offset, err = x.fastReadField20(buf, _type)
		if err != nil {
			goto ReadFieldError
		}
	case 127:
		offset, err = x.fastReadField127(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_InnerBasePartial[number], err)
}

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

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

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

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

func (x *InnerBasePartial) fastReadField19(buf []byte, _type int8) (offset int, err error) {
	var v BasePartial
	offset, err = fastpb.ReadMessage(buf, _type, &v)
	if err != nil {
		return offset, err
	}
	x.ListBase = append(x.ListBase, &v)
	return offset, nil
}

func (x *InnerBasePartial) fastReadField20(buf []byte, _type int8) (offset int, err error) {
	if x.MapStringBase == nil {
		x.MapStringBase = make(map[string]*BasePartial)
	}
	var key string
	var value *BasePartial
	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 BasePartial
			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.MapStringBase[key] = value
	return offset, nil
}

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

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

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

func (x *ExampleReq) 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 255:
		offset, err = x.fastReadField255(buf, _type)
		if err != nil {
			goto ReadFieldError
		}
	case 32767:
		offset, err = x.fastReadField32767(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_ExampleReq[number], err)
}

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

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

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

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

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

func (x *ExampleSuper) 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 9:
		offset, err = x.fastReadField9(buf, _type)
		if err != nil {
			goto ReadFieldError
		}
	case 255:
		offset, err = x.fastReadField255(buf, _type)
		if err != nil {
			goto ReadFieldError
		}
	case 32767:
		offset, err = x.fastReadField32767(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_ExampleSuper[number], err)
}

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

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

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

func (x *ExampleSuper) fastReadField4(buf []byte, _type int8) (offset int, err error) {
	x.Ex1, offset, err = fastpb.ReadString(buf, _type)
	return offset, err
}

func (x *ExampleSuper) fastReadField5(buf []byte, _type int8) (offset int, err error) {
	x.Ex2, offset, err = fastpb.ReadString(buf, _type)
	return offset, err
}

func (x *ExampleSuper) fastReadField6(buf []byte, _type int8) (offset int, err error) {
	x.Ex3, offset, err = fastpb.ReadString(buf, _type)
	return offset, err
}

func (x *ExampleSuper) fastReadField7(buf []byte, _type int8) (offset int, err error) {
	x.Ex4, offset, err = fastpb.ReadString(buf, _type)
	return offset, err
}

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

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

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

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

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

func (x *ExampleReqPartial) 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
		}
	case 255:
		offset, err = x.fastReadField255(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_ExampleReqPartial[number], err)
}

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

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

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

func (x *ExampleResp) 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 255:
		offset, err = x.fastReadField255(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_ExampleResp[number], err)
}

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

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

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

func (x *ExampleRespPartial) 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
		}
	case 255:
		offset, err = x.fastReadField255(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_ExampleRespPartial[number], err)
}

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

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

func (x *Exception) 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 255:
		offset, err = x.fastReadField255(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_Exception[number], err)
}

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

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

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

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

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

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

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

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

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

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

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

func (x *ExampleInt2Float) 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 32767:
		offset, err = x.fastReadField32767(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_ExampleInt2Float[number], err)
}

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

func (x *ExampleInt2Float) fastReadField2(buf []byte, _type int8) (offset int, err error) {
	x.Float64, offset, err = fastpb.ReadDouble(buf, _type)
	return offset, err
}

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

func (x *ExampleInt2Float) fastReadField4(buf []byte, _type int8) (offset int, err error) {
	x.Int64, offset, err = fastpb.ReadInt64(buf, _type)
	return offset, err
}

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

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

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

func (x *InnerBase2) fastWriteField2(buf []byte) (offset int) {
	if x.Uint32 == 0 {
		return offset
	}
	offset += fastpb.WriteUint32(buf[offset:], 2, x.GetUint32())
	return offset
}

func (x *InnerBase2) fastWriteField3(buf []byte) (offset int) {
	if x.Uint64 == 0 {
		return offset
	}
	offset += fastpb.WriteUint64(buf[offset:], 3, x.GetUint64())
	return offset
}

func (x *InnerBase2) fastWriteField4(buf []byte) (offset int) {
	if x.Int32 == 0 {
		return offset
	}
	offset += fastpb.WriteInt32(buf[offset:], 4, x.GetInt32())
	return offset
}

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

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

func (x *InnerBase2) fastWriteField7(buf []byte) (offset int) {
	if x.String_ == "" {
		return offset
	}
	offset += fastpb.WriteString(buf[offset:], 7, x.GetString_())
	return offset
}

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

func (x *InnerBase2) fastWriteField9(buf []byte) (offset int) {
	if x.MapStringString == nil {
		return offset
	}
	for k, v := range x.GetMapStringString() {
		offset += fastpb.WriteMapEntry(buf[offset:], 9,
			func(buf []byte, numTagOrKey, numIdxOrVal int32) int {
				offset := 0
				offset += fastpb.WriteString(buf[offset:], numTagOrKey, k)
				offset += fastpb.WriteString(buf[offset:], numIdxOrVal, v)
				return offset
			})
	}
	return offset
}

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

func (x *InnerBase2) fastWriteField11(buf []byte) (offset int) {
	if x.Foo == 0 {
		return offset
	}
	offset += fastpb.WriteInt32(buf[offset:], 11, int32(x.GetFoo()))
	return offset
}

func (x *InnerBase2) fastWriteField12(buf []byte) (offset int) {
	if x.MapInt32String == nil {
		return offset
	}
	for k, v := range x.GetMapInt32String() {
		offset += fastpb.WriteMapEntry(buf[offset:], 12,
			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 *InnerBase2) fastWriteField13(buf []byte) (offset int) {
	if len(x.Binary) == 0 {
		return offset
	}
	offset += fastpb.WriteBytes(buf[offset:], 13, x.GetBinary())
	return offset
}

func (x *InnerBase2) fastWriteField14(buf []byte) (offset int) {
	if x.MapUint32String == nil {
		return offset
	}
	for k, v := range x.GetMapUint32String() {
		offset += fastpb.WriteMapEntry(buf[offset:], 14,
			func(buf []byte, numTagOrKey, numIdxOrVal int32) int {
				offset := 0
				offset += fastpb.WriteUint32(buf[offset:], numTagOrKey, k)
				offset += fastpb.WriteString(buf[offset:], numIdxOrVal, v)
				return offset
			})
	}
	return offset
}

func (x *InnerBase2) fastWriteField15(buf []byte) (offset int) {
	if x.MapUint64String == nil {
		return offset
	}
	for k, v := range x.GetMapUint64String() {
		offset += fastpb.WriteMapEntry(buf[offset:], 15,
			func(buf []byte, numTagOrKey, numIdxOrVal int32) int {
				offset := 0
				offset += fastpb.WriteUint64(buf[offset:], numTagOrKey, k)
				offset += fastpb.WriteString(buf[offset:], numIdxOrVal, v)
				return offset
			})
	}
	return offset
}

func (x *InnerBase2) fastWriteField16(buf []byte) (offset int) {
	if x.MapInt64String == nil {
		return offset
	}
	for k, v := range x.GetMapInt64String() {
		offset += fastpb.WriteMapEntry(buf[offset:], 16,
			func(buf []byte, numTagOrKey, numIdxOrVal int32) int {
				offset := 0
				offset += fastpb.WriteInt64(buf[offset:], numTagOrKey, k)
				offset += fastpb.WriteString(buf[offset:], numIdxOrVal, v)
				return offset
			})
	}
	return offset
}

func (x *InnerBase2) fastWriteField17(buf []byte) (offset int) {
	if x.MapInt64Base == nil {
		return offset
	}
	for k, v := range x.GetMapInt64Base() {
		offset += fastpb.WriteMapEntry(buf[offset:], 17,
			func(buf []byte, numTagOrKey, numIdxOrVal int32) int {
				offset := 0
				offset += fastpb.WriteInt64(buf[offset:], numTagOrKey, k)
				offset += fastpb.WriteMessage(buf[offset:], numIdxOrVal, v)
				return offset
			})
	}
	return offset
}

func (x *InnerBase2) fastWriteField18(buf []byte) (offset int) {
	if x.ListInnerBase == nil {
		return offset
	}
	for i := range x.GetListInnerBase() {
		offset += fastpb.WriteMessage(buf[offset:], 18, x.GetListInnerBase()[i])
	}
	return offset
}

func (x *InnerBase2) fastWriteField19(buf []byte) (offset int) {
	if x.ListBase == nil {
		return offset
	}
	for i := range x.GetListBase() {
		offset += fastpb.WriteMessage(buf[offset:], 19, x.GetListBase()[i])
	}
	return offset
}

func (x *InnerBase2) fastWriteField20(buf []byte) (offset int) {
	if x.MapStringBase == nil {
		return offset
	}
	for k, v := range x.GetMapStringBase() {
		offset += fastpb.WriteMapEntry(buf[offset:], 20,
			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 *InnerBase2) fastWriteField21(buf []byte) (offset int) {
	if len(x.ListString) == 0 {
		return offset
	}
	for i := range x.GetListString() {
		offset += fastpb.WriteString(buf[offset:], 21, x.GetListString()[i])
	}
	return offset
}

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

func (x *InnerBasePartial) FastWrite(buf []byte) (offset int) {
	if x == nil {
		return offset
	}
	offset += x.fastWriteField1(buf[offset:])
	offset += x.fastWriteField8(buf[offset:])
	offset += x.fastWriteField9(buf[offset:])
	offset += x.fastWriteField18(buf[offset:])
	offset += x.fastWriteField19(buf[offset:])
	offset += x.fastWriteField20(buf[offset:])
	offset += x.fastWriteField127(buf[offset:])
	return offset
}

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

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

func (x *InnerBasePartial) fastWriteField9(buf []byte) (offset int) {
	if x.MapStringString == nil {
		return offset
	}
	for k, v := range x.GetMapStringString() {
		offset += fastpb.WriteMapEntry(buf[offset:], 9,
			func(buf []byte, numTagOrKey, numIdxOrVal int32) int {
				offset := 0
				offset += fastpb.WriteString(buf[offset:], numTagOrKey, k)
				offset += fastpb.WriteString(buf[offset:], numIdxOrVal, v)
				return offset
			})
	}
	return offset
}

func (x *InnerBasePartial) fastWriteField18(buf []byte) (offset int) {
	if x.ListInnerBase == nil {
		return offset
	}
	for i := range x.GetListInnerBase() {
		offset += fastpb.WriteMessage(buf[offset:], 18, x.GetListInnerBase()[i])
	}
	return offset
}

func (x *InnerBasePartial) fastWriteField19(buf []byte) (offset int) {
	if x.ListBase == nil {
		return offset
	}
	for i := range x.GetListBase() {
		offset += fastpb.WriteMessage(buf[offset:], 19, x.GetListBase()[i])
	}
	return offset
}

func (x *InnerBasePartial) fastWriteField20(buf []byte) (offset int) {
	if x.MapStringBase == nil {
		return offset
	}
	for k, v := range x.GetMapStringBase() {
		offset += fastpb.WriteMapEntry(buf[offset:], 20,
			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 *InnerBasePartial) fastWriteField127(buf []byte) (offset int) {
	if x.MapStringString2 == nil {
		return offset
	}
	for k, v := range x.GetMapStringString2() {
		offset += fastpb.WriteMapEntry(buf[offset:], 127,
			func(buf []byte, numTagOrKey, numIdxOrVal int32) int {
				offset := 0
				offset += fastpb.WriteString(buf[offset:], numTagOrKey, k)
				offset += fastpb.WriteString(buf[offset:], numIdxOrVal, v)
				return offset
			})
	}
	return offset
}

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

func (x *BasePartial) fastWriteField5(buf []byte) (offset int) {
	if x.TrafficEnv == nil {
		return offset
	}
	offset += fastpb.WriteMessage(buf[offset:], 5, x.GetTrafficEnv())
	return offset
}

func (x *ExampleReq) 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.fastWriteField255(buf[offset:])
	offset += x.fastWriteField32767(buf[offset:])
	return offset
}

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

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

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

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

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

func (x *ExampleSuper) 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.fastWriteField9(buf[offset:])
	offset += x.fastWriteField255(buf[offset:])
	offset += x.fastWriteField32767(buf[offset:])
	return offset
}

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

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

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

func (x *ExampleSuper) fastWriteField4(buf []byte) (offset int) {
	if x.Ex1 == "" {
		return offset
	}
	offset += fastpb.WriteString(buf[offset:], 4, x.GetEx1())
	return offset
}

func (x *ExampleSuper) fastWriteField5(buf []byte) (offset int) {
	if x.Ex2 == "" {
		return offset
	}
	offset += fastpb.WriteString(buf[offset:], 5, x.GetEx2())
	return offset
}

func (x *ExampleSuper) fastWriteField6(buf []byte) (offset int) {
	if x.Ex3 == "" {
		return offset
	}
	offset += fastpb.WriteString(buf[offset:], 6, x.GetEx3())
	return offset
}

func (x *ExampleSuper) fastWriteField7(buf []byte) (offset int) {
	if x.Ex4 == "" {
		return offset
	}
	offset += fastpb.WriteString(buf[offset:], 7, x.GetEx4())
	return offset
}

func (x *ExampleSuper) fastWriteField9(buf []byte) (offset int) {
	if x.SelfRef == nil {
		return offset
	}
	offset += fastpb.WriteMessage(buf[offset:], 9, x.GetSelfRef())
	return offset
}

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

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

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

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

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

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

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

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

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

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

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

func (x *ExampleResp) fastWriteField255(buf []byte) (offset int) {
	if x.BaseResp == nil {
		return offset
	}
	offset += fastpb.WriteMessage(buf[offset:], 255, x.GetBaseResp())
	return offset
}

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

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

func (x *ExampleRespPartial) fastWriteField255(buf []byte) (offset int) {
	if x.BaseResp == nil {
		return offset
	}
	offset += fastpb.WriteMessage(buf[offset:], 255, x.GetBaseResp())
	return offset
}

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

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

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

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

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

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

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

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

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

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

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

func (x *VoidResponse) FastWrite(buf []byte) (offset int) {
	if x == nil {
		return offset
	}
	return offset
}

func (x *ExampleInt2Float) 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.fastWriteField32767(buf[offset:])
	return offset
}

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

func (x *ExampleInt2Float) fastWriteField2(buf []byte) (offset int) {
	if x.Float64 == 0 {
		return offset
	}
	offset += fastpb.WriteDouble(buf[offset:], 2, x.GetFloat64())
	return offset
}

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

func (x *ExampleInt2Float) fastWriteField4(buf []byte) (offset int) {
	if x.Int64 == 0 {
		return offset
	}
	offset += fastpb.WriteInt64(buf[offset:], 4, x.GetInt64())
	return offset
}

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

func (x *InnerBase2) Size() (n int) {
	if x == nil {
		return n
	}
	n += x.sizeField1()
	n += x.sizeField2()
	n += x.sizeField3()
	n += x.sizeField4()
	n += x.sizeField5()
	n += x.sizeField6()
	n += x.sizeField7()
	n += x.sizeField8()
	n += x.sizeField9()
	n += x.sizeField10()
	n += x.sizeField11()
	n += x.sizeField12()
	n += x.sizeField13()
	n += x.sizeField14()
	n += x.sizeField15()
	n += x.sizeField16()
	n += x.sizeField17()
	n += x.sizeField18()
	n += x.sizeField19()
	n += x.sizeField20()
	n += x.sizeField21()
	n += x.sizeField255()
	return n
}

func (x *InnerBase2) sizeField1() (n int) {
	if !x.Bool {
		return n
	}
	n += fastpb.SizeBool(1, x.GetBool())
	return n
}

func (x *InnerBase2) sizeField2() (n int) {
	if x.Uint32 == 0 {
		return n
	}
	n += fastpb.SizeUint32(2, x.GetUint32())
	return n
}

func (x *InnerBase2) sizeField3() (n int) {
	if x.Uint64 == 0 {
		return n
	}
	n += fastpb.SizeUint64(3, x.GetUint64())
	return n
}

func (x *InnerBase2) sizeField4() (n int) {
	if x.Int32 == 0 {
		return n
	}
	n += fastpb.SizeInt32(4, x.GetInt32())
	return n
}

func (x *InnerBase2) sizeField5() (n int) {
	if x.Int64 == 0 {
		return n
	}
	n += fastpb.SizeInt64(5, x.GetInt64())
	return n
}

func (x *InnerBase2) sizeField6() (n int) {
	if x.Double == 0 {
		return n
	}
	n += fastpb.SizeDouble(6, x.GetDouble())
	return n
}

func (x *InnerBase2) sizeField7() (n int) {
	if x.String_ == "" {
		return n
	}
	n += fastpb.SizeString(7, x.GetString_())
	return n
}

func (x *InnerBase2) sizeField8() (n int) {
	if len(x.ListInt32) == 0 {
		return n
	}
	n += fastpb.SizeListPacked(8, len(x.GetListInt32()),
		func(numTagOrKey, numIdxOrVal int32) int {
			n := 0
			n += fastpb.SizeInt32(numTagOrKey, x.GetListInt32()[numIdxOrVal])
			return n
		})
	return n
}

func (x *InnerBase2) sizeField9() (n int) {
	if x.MapStringString == nil {
		return n
	}
	for k, v := range x.GetMapStringString() {
		n += fastpb.SizeMapEntry(9,
			func(numTagOrKey, numIdxOrVal int32) int {
				n := 0
				n += fastpb.SizeString(numTagOrKey, k)
				n += fastpb.SizeString(numIdxOrVal, v)
				return n
			})
	}
	return n
}

func (x *InnerBase2) sizeField10() (n int) {
	if len(x.SetInt32) == 0 {
		return n
	}
	n += fastpb.SizeListPacked(10, len(x.GetSetInt32()),
		func(numTagOrKey, numIdxOrVal int32) int {
			n := 0
			n += fastpb.SizeInt32(numTagOrKey, x.GetSetInt32()[numIdxOrVal])
			return n
		})
	return n
}

func (x *InnerBase2) sizeField11() (n int) {
	if x.Foo == 0 {
		return n
	}
	n += fastpb.SizeInt32(11, int32(x.GetFoo()))
	return n
}

func (x *InnerBase2) sizeField12() (n int) {
	if x.MapInt32String == nil {
		return n
	}
	for k, v := range x.GetMapInt32String() {
		n += fastpb.SizeMapEntry(12,
			func(numTagOrKey, numIdxOrVal int32) int {
				n := 0
				n += fastpb.SizeInt32(numTagOrKey, k)
				n += fastpb.SizeString(numIdxOrVal, v)
				return n
			})
	}
	return n
}

func (x *InnerBase2) sizeField13() (n int) {
	if len(x.Binary) == 0 {
		return n
	}
	n += fastpb.SizeBytes(13, x.GetBinary())
	return n
}

func (x *InnerBase2) sizeField14() (n int) {
	if x.MapUint32String == nil {
		return n
	}
	for k, v := range x.GetMapUint32String() {
		n += fastpb.SizeMapEntry(14,
			func(numTagOrKey, numIdxOrVal int32) int {
				n := 0
				n += fastpb.SizeUint32(numTagOrKey, k)
				n += fastpb.SizeString(numIdxOrVal, v)
				return n
			})
	}
	return n
}

func (x *InnerBase2) sizeField15() (n int) {
	if x.MapUint64String == nil {
		return n
	}
	for k, v := range x.GetMapUint64String() {
		n += fastpb.SizeMapEntry(15,
			func(numTagOrKey, numIdxOrVal int32) int {
				n := 0
				n += fastpb.SizeUint64(numTagOrKey, k)
				n += fastpb.SizeString(numIdxOrVal, v)
				return n
			})
	}
	return n
}

func (x *InnerBase2) sizeField16() (n int) {
	if x.MapInt64String == nil {
		return n
	}
	for k, v := range x.GetMapInt64String() {
		n += fastpb.SizeMapEntry(16,
			func(numTagOrKey, numIdxOrVal int32) int {
				n := 0
				n += fastpb.SizeInt64(numTagOrKey, k)
				n += fastpb.SizeString(numIdxOrVal, v)
				return n
			})
	}
	return n
}

func (x *InnerBase2) sizeField17() (n int) {
	if x.MapInt64Base == nil {
		return n
	}
	for k, v := range x.GetMapInt64Base() {
		n += fastpb.SizeMapEntry(17,
			func(numTagOrKey, numIdxOrVal int32) int {
				n := 0
				n += fastpb.SizeInt64(numTagOrKey, k)
				n += fastpb.SizeMessage(numIdxOrVal, v)
				return n
			})
	}
	return n
}

func (x *InnerBase2) sizeField18() (n int) {
	if x.ListInnerBase == nil {
		return n
	}
	for i := range x.GetListInnerBase() {
		n += fastpb.SizeMessage(18, x.GetListInnerBase()[i])
	}
	return n
}

func (x *InnerBase2) sizeField19() (n int) {
	if x.ListBase == nil {
		return n
	}
	for i := range x.GetListBase() {
		n += fastpb.SizeMessage(19, x.GetListBase()[i])
	}
	return n
}

func (x *InnerBase2) sizeField20() (n int) {
	if x.MapStringBase == nil {
		return n
	}
	for k, v := range x.GetMapStringBase() {
		n += fastpb.SizeMapEntry(20,
			func(numTagOrKey, numIdxOrVal int32) int {
				n := 0
				n += fastpb.SizeString(numTagOrKey, k)
				n += fastpb.SizeMessage(numIdxOrVal, v)
				return n
			})
	}
	return n
}

func (x *InnerBase2) sizeField21() (n int) {
	if len(x.ListString) == 0 {
		return n
	}
	for i := range x.GetListString() {
		n += fastpb.SizeString(21, x.GetListString()[i])
	}
	return n
}

func (x *InnerBase2) sizeField255() (n int) {
	if x.Base == nil {
		return n
	}
	n += fastpb.SizeMessage(255, x.GetBase())
	return n
}

func (x *InnerBasePartial) Size() (n int) {
	if x == nil {
		return n
	}
	n += x.sizeField1()
	n += x.sizeField8()
	n += x.sizeField9()
	n += x.sizeField18()
	n += x.sizeField19()
	n += x.sizeField20()
	n += x.sizeField127()
	return n
}

func (x *InnerBasePartial) sizeField1() (n int) {
	if !x.Bool {
		return n
	}
	n += fastpb.SizeBool(1, x.GetBool())
	return n
}

func (x *InnerBasePartial) sizeField8() (n int) {
	if len(x.ListInt32) == 0 {
		return n
	}
	n += fastpb.SizeListPacked(8, len(x.GetListInt32()),
		func(numTagOrKey, numIdxOrVal int32) int {
			n := 0
			n += fastpb.SizeInt32(numTagOrKey, x.GetListInt32()[numIdxOrVal])
			return n
		})
	return n
}

func (x *InnerBasePartial) sizeField9() (n int) {
	if x.MapStringString == nil {
		return n
	}
	for k, v := range x.GetMapStringString() {
		n += fastpb.SizeMapEntry(9,
			func(numTagOrKey, numIdxOrVal int32) int {
				n := 0
				n += fastpb.SizeString(numTagOrKey, k)
				n += fastpb.SizeString(numIdxOrVal, v)
				return n
			})
	}
	return n
}

func (x *InnerBasePartial) sizeField18() (n int) {
	if x.ListInnerBase == nil {
		return n
	}
	for i := range x.GetListInnerBase() {
		n += fastpb.SizeMessage(18, x.GetListInnerBase()[i])
	}
	return n
}

func (x *InnerBasePartial) sizeField19() (n int) {
	if x.ListBase == nil {
		return n
	}
	for i := range x.GetListBase() {
		n += fastpb.SizeMessage(19, x.GetListBase()[i])
	}
	return n
}

func (x *InnerBasePartial) sizeField20() (n int) {
	if x.MapStringBase == nil {
		return n
	}
	for k, v := range x.GetMapStringBase() {
		n += fastpb.SizeMapEntry(20,
			func(numTagOrKey, numIdxOrVal int32) int {
				n := 0
				n += fastpb.SizeString(numTagOrKey, k)
				n += fastpb.SizeMessage(numIdxOrVal, v)
				return n
			})
	}
	return n
}

func (x *InnerBasePartial) sizeField127() (n int) {
	if x.MapStringString2 == nil {
		return n
	}
	for k, v := range x.GetMapStringString2() {
		n += fastpb.SizeMapEntry(127,
			func(numTagOrKey, numIdxOrVal int32) int {
				n := 0
				n += fastpb.SizeString(numTagOrKey, k)
				n += fastpb.SizeString(numIdxOrVal, v)
				return n
			})
	}
	return n
}

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

func (x *BasePartial) sizeField5() (n int) {
	if x.TrafficEnv == nil {
		return n
	}
	n += fastpb.SizeMessage(5, x.GetTrafficEnv())
	return n
}

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

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

func (x *ExampleReq) sizeField2() (n int) {
	if x.A == 0 {
		return n
	}
	n += fastpb.SizeInt32(2, x.GetA())
	return n
}

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

func (x *ExampleReq) sizeField255() (n int) {
	if x.Base == nil {
		return n
	}
	n += fastpb.SizeMessage(255, x.GetBase())
	return n
}

func (x *ExampleReq) sizeField32767() (n int) {
	if x.Subfix == 0 {
		return n
	}
	n += fastpb.SizeDouble(32767, x.GetSubfix())
	return n
}

func (x *ExampleSuper) 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.sizeField9()
	n += x.sizeField255()
	n += x.sizeField32767()
	return n
}

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

func (x *ExampleSuper) sizeField2() (n int) {
	if x.A == 0 {
		return n
	}
	n += fastpb.SizeInt32(2, x.GetA())
	return n
}

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

func (x *ExampleSuper) sizeField4() (n int) {
	if x.Ex1 == "" {
		return n
	}
	n += fastpb.SizeString(4, x.GetEx1())
	return n
}

func (x *ExampleSuper) sizeField5() (n int) {
	if x.Ex2 == "" {
		return n
	}
	n += fastpb.SizeString(5, x.GetEx2())
	return n
}

func (x *ExampleSuper) sizeField6() (n int) {
	if x.Ex3 == "" {
		return n
	}
	n += fastpb.SizeString(6, x.GetEx3())
	return n
}

func (x *ExampleSuper) sizeField7() (n int) {
	if x.Ex4 == "" {
		return n
	}
	n += fastpb.SizeString(7, x.GetEx4())
	return n
}

func (x *ExampleSuper) sizeField9() (n int) {
	if x.SelfRef == nil {
		return n
	}
	n += fastpb.SizeMessage(9, x.GetSelfRef())
	return n
}

func (x *ExampleSuper) sizeField255() (n int) {
	if x.Base == nil {
		return n
	}
	n += fastpb.SizeMessage(255, x.GetBase())
	return n
}

func (x *ExampleSuper) sizeField32767() (n int) {
	if x.Subfix == 0 {
		return n
	}
	n += fastpb.SizeDouble(32767, x.GetSubfix())
	return n
}

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

func (x *SelfRef) sizeField1() (n int) {
	if x.Self == nil {
		return n
	}
	n += fastpb.SizeMessage(1, x.GetSelf())
	return n
}

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

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

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

func (x *ExampleReqPartial) sizeField255() (n int) {
	if x.Base == nil {
		return n
	}
	n += fastpb.SizeMessage(255, x.GetBase())
	return n
}

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

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

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

func (x *ExampleResp) sizeField255() (n int) {
	if x.BaseResp == nil {
		return n
	}
	n += fastpb.SizeMessage(255, x.GetBaseResp())
	return n
}

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

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

func (x *ExampleRespPartial) sizeField255() (n int) {
	if x.BaseResp == nil {
		return n
	}
	n += fastpb.SizeMessage(255, x.GetBaseResp())
	return n
}

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

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

func (x *Exception) sizeField255() (n int) {
	if x.Msg == "" {
		return n
	}
	n += fastpb.SizeString(255, x.GetMsg())
	return n
}

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

func (x *A) sizeField1() (n int) {
	if x.Self == nil {
		return n
	}
	n += fastpb.SizeMessage(1, x.GetSelf())
	return n
}

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

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

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

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

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

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

func (x *VoidResponse) Size() (n int) {
	if x == nil {
		return n
	}
	return n
}

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

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

func (x *ExampleInt2Float) sizeField2() (n int) {
	if x.Float64 == 0 {
		return n
	}
	n += fastpb.SizeDouble(2, x.GetFloat64())
	return n
}

func (x *ExampleInt2Float) sizeField3() (n int) {
	if x.String_ == "" {
		return n
	}
	n += fastpb.SizeString(3, x.GetString_())
	return n
}

func (x *ExampleInt2Float) sizeField4() (n int) {
	if x.Int64 == 0 {
		return n
	}
	n += fastpb.SizeInt64(4, x.GetInt64())
	return n
}

func (x *ExampleInt2Float) sizeField32767() (n int) {
	if x.Subfix == 0 {
		return n
	}
	n += fastpb.SizeDouble(32767, x.GetSubfix())
	return n
}

var fieldIDToName_InnerBase2 = map[int32]string{
	1:   "Bool",
	2:   "Uint32",
	3:   "Uint64",
	4:   "Int32",
	5:   "Int64",
	6:   "Double",
	7:   "String_",
	8:   "ListInt32",
	9:   "MapStringString",
	10:  "SetInt32",
	11:  "Foo",
	12:  "MapInt32String",
	13:  "Binary",
	14:  "MapUint32String",
	15:  "MapUint64String",
	16:  "MapInt64String",
	17:  "MapInt64Base",
	18:  "ListInnerBase",
	19:  "ListBase",
	20:  "MapStringBase",
	21:  "ListString",
	255: "Base",
}

var fieldIDToName_InnerBasePartial = map[int32]string{
	1:   "Bool",
	8:   "ListInt32",
	9:   "MapStringString",
	18:  "ListInnerBase",
	19:  "ListBase",
	20:  "MapStringBase",
	127: "MapStringString2",
}

var fieldIDToName_BasePartial = map[int32]string{
	5: "TrafficEnv",
}

var fieldIDToName_ExampleReq = map[int32]string{
	1:     "Msg",
	2:     "A",
	3:     "InnerBase2",
	255:   "Base",
	32767: "Subfix",
}

var fieldIDToName_ExampleSuper = map[int32]string{
	1:     "Msg",
	2:     "A",
	3:     "InnerBase2",
	4:     "Ex1",
	5:     "Ex2",
	6:     "Ex3",
	7:     "Ex4",
	9:     "SelfRef",
	255:   "Base",
	32767: "Subfix",
}

var fieldIDToName_SelfRef = map[int32]string{
	1: "Self",
}

var fieldIDToName_ExampleReqPartial = map[int32]string{
	1:   "Msg",
	3:   "InnerBase2",
	255: "Base",
}

var fieldIDToName_ExampleResp = map[int32]string{
	1:   "Msg",
	2:   "RequiredField",
	255: "BaseResp",
}

var fieldIDToName_ExampleRespPartial = map[int32]string{
	2:   "RequiredField",
	255: "BaseResp",
}

var fieldIDToName_Exception = map[int32]string{
	1:   "Code",
	255: "Msg",
}

var fieldIDToName_A = map[int32]string{
	1: "Self",
}

var fieldIDToName_PingResponse = map[int32]string{
	1: "Message",
}

var fieldIDToName_OnewayRequest = map[int32]string{
	1: "Msg",
}

var fieldIDToName_VoidRequest = map[int32]string{
	1: "Msg",
}

var fieldIDToName_VoidResponse = map[int32]string{}

var fieldIDToName_ExampleInt2Float = map[int32]string{
	1:     "Int32",
	2:     "Float64",
	3:     "String_",
	4:     "Int64",
	32767: "Subfix",
}

var _ = base.File_base_proto