text: // Protocol Buffers for Go with Gadgets
  //
  // Copyright (c) 2018, The GoGo Authors. All rights reserved.
  // http://github.com/gogo/protobuf
  //
  // Redistribution and use in source and binary forms, with or without
  // modification, are permitted provided that the following conditions are
  // met:
  //
  //     * Redistributions of source code must retain the above copyright
  // notice, this list of conditions and the following disclaimer.
  //     * Redistributions in binary form must reproduce the above
  // copyright notice, this list of conditions and the following disclaimer
  // in the documentation and/or other materials provided with the
  // distribution.
  //
  // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  
  package proto
  
  import (
  	"io"
  	"reflect"
  )
  
  func makeStdDoubleValueMarshaler(u *marshalInfo) (sizer, marshaler) {
  	return func(ptr pointer, tagsize int) int {
  			t := ptr.asPointerTo(u.typ).Interface().(*float64)
  			v := &float64Value{*t}
  			siz := Size(v)
  			return tagsize + SizeVarint(uint64(siz)) + siz
  		}, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
  			t := ptr.asPointerTo(u.typ).Interface().(*float64)
  			v := &float64Value{*t}
  			buf, err := Marshal(v)
  			if err != nil {
  				return nil, err
  			}
  			b = appendVarint(b, wiretag)
  			b = appendVarint(b, uint64(len(buf)))
  			b = append(b, buf...)
  			return b, nil
  		}
  }
  
  func makeStdDoubleValuePtrMarshaler(u *marshalInfo) (sizer, marshaler) {
  	return func(ptr pointer, tagsize int) int {
  			if ptr.isNil() {
  				return 0
  			}
  			t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*float64)
  			v := &float64Value{*t}
  			siz := Size(v)
  			return tagsize + SizeVarint(uint64(siz)) + siz
  		}, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
  			if ptr.isNil() {
  				return b, nil
  			}
  			t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*float64)
  			v := &float64Value{*t}
  			buf, err := Marshal(v)
  			if err != nil {
  				return nil, err
  			}
  			b = appendVarint(b, wiretag)
  			b = appendVarint(b, uint64(len(buf)))
  			b = append(b, buf...)
  			return b, nil
  		}
  }
  
  func makeStdDoubleValueSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
  	return func(ptr pointer, tagsize int) int {
  			s := ptr.getSlice(u.typ)
  			n := 0
  			for i := 0; i < s.Len(); i++ {
  				elem := s.Index(i)
  				t := elem.Interface().(float64)
  				v := &float64Value{t}
  				siz := Size(v)
  				n += siz + SizeVarint(uint64(siz)) + tagsize
  			}
  			return n
  		},
  		func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
  			s := ptr.getSlice(u.typ)
  			for i := 0; i < s.Len(); i++ {
  				elem := s.Index(i)
  				t := elem.Interface().(float64)
  				v := &float64Value{t}
  				siz := Size(v)
  				buf, err := Marshal(v)
  				if err != nil {
  					return nil, err
  				}
  				b = appendVarint(b, wiretag)
  				b = appendVarint(b, uint64(siz))
  				b = append(b, buf...)
  			}
  
  			return b, nil
  		}
  }
  
  func makeStdDoubleValuePtrSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
  	return func(ptr pointer, tagsize int) int {
  			s := ptr.getSlice(reflect.PtrTo(u.typ))
  			n := 0
  			for i := 0; i < s.Len(); i++ {
  				elem := s.Index(i)
  				t := elem.Interface().(*float64)
  				v := &float64Value{*t}
  				siz := Size(v)
  				n += siz + SizeVarint(uint64(siz)) + tagsize
  			}
  			return n
  		},
  		func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
  			s := ptr.getSlice(reflect.PtrTo(u.typ))
  			for i := 0; i < s.Len(); i++ {
  				elem := s.Index(i)
  				t := elem.Interface().(*float64)
  				v := &float64Value{*t}
  				siz := Size(v)
  				buf, err := Marshal(v)
  				if err != nil {
  					return nil, err
  				}
  				b = appendVarint(b, wiretag)
  				b = appendVarint(b, uint64(siz))
  				b = append(b, buf...)
  			}
  
  			return b, nil
  		}
  }
  
  func makeStdDoubleValueUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
  	return func(b []byte, f pointer, w int) ([]byte, error) {
  		if w != WireBytes {
  			return nil, errInternalBadWireType
  		}
  		x, n := decodeVarint(b)
  		if n == 0 {
  			return nil, io.ErrUnexpectedEOF
  		}
  		b = b[n:]
  		if x > uint64(len(b)) {
  			return nil, io.ErrUnexpectedEOF
  		}
  		m := &float64Value{}
  		if err := Unmarshal(b[:x], m); err != nil {
  			return nil, err
  		}
  		s := f.asPointerTo(sub.typ).Elem()
  		s.Set(reflect.ValueOf(m.Value))
  		return b[x:], nil
  	}
  }
  
  func makeStdDoubleValuePtrUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
  	return func(b []byte, f pointer, w int) ([]byte, error) {
  		if w != WireBytes {
  			return nil, errInternalBadWireType
  		}
  		x, n := decodeVarint(b)
  		if n == 0 {
  			return nil, io.ErrUnexpectedEOF
  		}
  		b = b[n:]
  		if x > uint64(len(b)) {
  			return nil, io.ErrUnexpectedEOF
  		}
  		m := &float64Value{}
  		if err := Unmarshal(b[:x], m); err != nil {
  			return nil, err
  		}
  		s := f.asPointerTo(reflect.PtrTo(sub.typ)).Elem()
  		s.Set(reflect.ValueOf(&m.Value))
  		return b[x:], nil
  	}
  }
  
  func makeStdDoubleValuePtrSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
  	return func(b []byte, f pointer, w int) ([]byte, error) {
  		if w != WireBytes {
  			return nil, errInternalBadWireType
  		}
  		x, n := decodeVarint(b)
  		if n == 0 {
  			return nil, io.ErrUnexpectedEOF
  		}
  		b = b[n:]
  		if x > uint64(len(b)) {
  			return nil, io.ErrUnexpectedEOF
  		}
  		m := &float64Value{}
  		if err := Unmarshal(b[:x], m); err != nil {
  			return nil, err
  		}
  		slice := f.getSlice(reflect.PtrTo(sub.typ))
  		newSlice := reflect.Append(slice, reflect.ValueOf(&m.Value))
  		slice.Set(newSlice)
  		return b[x:], nil
  	}
  }
  
  func makeStdDoubleValueSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
  	return func(b []byte, f pointer, w int) ([]byte, error) {
  		if w != WireBytes {
  			return nil, errInternalBadWireType
  		}
  		x, n := decodeVarint(b)
  		if n == 0 {
  			return nil, io.ErrUnexpectedEOF
  		}
  		b = b[n:]
  		if x > uint64(len(b)) {
  			return nil, io.ErrUnexpectedEOF
  		}
  		m := &float64Value{}
  		if err := Unmarshal(b[:x], m); err != nil {
  			return nil, err
  		}
  		slice := f.getSlice(sub.typ)
  		newSlice := reflect.Append(slice, reflect.ValueOf(m.Value))
  		slice.Set(newSlice)
  		return b[x:], nil
  	}
  }
  
  func makeStdFloatValueMarshaler(u *marshalInfo) (sizer, marshaler) {
  	return func(ptr pointer, tagsize int) int {
  			t := ptr.asPointerTo(u.typ).Interface().(*float32)
  			v := &float32Value{*t}
  			siz := Size(v)
  			return tagsize + SizeVarint(uint64(siz)) + siz
  		}, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
  			t := ptr.asPointerTo(u.typ).Interface().(*float32)
  			v := &float32Value{*t}
  			buf, err := Marshal(v)
  			if err != nil {
  				return nil, err
  			}
  			b = appendVarint(b, wiretag)
  			b = appendVarint(b, uint64(len(buf)))
  			b = append(b, buf...)
  			return b, nil
  		}
  }
  
  func makeStdFloatValuePtrMarshaler(u *marshalInfo) (sizer, marshaler) {
  	return func(ptr pointer, tagsize int) int {
  			if ptr.isNil() {
  				return 0
  			}
  			t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*float32)
  			v := &float32Value{*t}
  			siz := Size(v)
  			return tagsize + SizeVarint(uint64(siz)) + siz
  		}, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
  			if ptr.isNil() {
  				return b, nil
  			}
  			t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*float32)
  			v := &float32Value{*t}
  			buf, err := Marshal(v)
  			if err != nil {
  				return nil, err
  			}
  			b = appendVarint(b, wiretag)
  			b = appendVarint(b, uint64(len(buf)))
  			b = append(b, buf...)
  			return b, nil
  		}
  }
  
  func makeStdFloatValueSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
  	return func(ptr pointer, tagsize int) int {
  			s := ptr.getSlice(u.typ)
  			n := 0
  			for i := 0; i < s.Len(); i++ {
  				elem := s.Index(i)
  				t := elem.Interface().(float32)
  				v := &float32Value{t}
  				siz := Size(v)
  				n += siz + SizeVarint(uint64(siz)) + tagsize
  			}
  			return n
  		},
  		func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
  			s := ptr.getSlice(u.typ)
  			for i := 0; i < s.Len(); i++ {
  				elem := s.Index(i)
  				t := elem.Interface().(float32)
  				v := &float32Value{t}
  				siz := Size(v)
  				buf, err := Marshal(v)
  				if err != nil {
  					return nil, err
  				}
  				b = appendVarint(b, wiretag)
  				b = appendVarint(b, uint64(siz))
  				b = append(b, buf...)
  			}
  
  			return b, nil
  		}
  }
  
  func makeStdFloatValuePtrSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
  	return func(ptr pointer, tagsize int) int {
  			s := ptr.getSlice(reflect.PtrTo(u.typ))
  			n := 0
  			for i := 0; i < s.Len(); i++ {
  				elem := s.Index(i)
  				t := elem.Interface().(*float32)
  				v := &float32Value{*t}
  				siz := Size(v)
  				n += siz + SizeVarint(uint64(siz)) + tagsize
  			}
  			return n
  		},
  		func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
  			s := ptr.getSlice(reflect.PtrTo(u.typ))
  			for i := 0; i < s.Len(); i++ {
  				elem := s.Index(i)
  				t := elem.Interface().(*float32)
  				v := &float32Value{*t}
  				siz := Size(v)
  				buf, err := Marshal(v)
  				if err != nil {
  					return nil, err
  				}
  				b = appendVarint(b, wiretag)
  				b = appendVarint(b, uint64(siz))
  				b = append(b, buf...)
  			}
  
  			return b, nil
  		}
  }
  
  func makeStdFloatValueUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
  	return func(b []byte, f pointer, w int) ([]byte, error) {
  		if w != WireBytes {
  			return nil, errInternalBadWireType
  		}
  		x, n := decodeVarint(b)
  		if n == 0 {
  			return nil, io.ErrUnexpectedEOF
  		}
  		b = b[n:]
  		if x > uint64(len(b)) {
  			return nil, io.ErrUnexpectedEOF
  		}
  		m := &float32Value{}
  		if err := Unmarshal(b[:x], m); err != nil {
  			return nil, err
  		}
  		s := f.asPointerTo(sub.typ).Elem()
  		s.Set(reflect.ValueOf(m.Value))
  		return b[x:], nil
  	}
  }
  
  func makeStdFloatValuePtrUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
  	return func(b []byte, f pointer, w int) ([]byte, error) {
  		if w != WireBytes {
  			return nil, errInternalBadWireType
  		}
  		x, n := decodeVarint(b)
  		if n == 0 {
  			return nil, io.ErrUnexpectedEOF
  		}
  		b = b[n:]
  		if x > uint64(len(b)) {
  			return nil, io.ErrUnexpectedEOF
  		}
  		m := &float32Value{}
  		if err := Unmarshal(b[:x], m); err != nil {
  			return nil, err
  		}
  		s := f.asPointerTo(reflect.PtrTo(sub.typ)).Elem()
  		s.Set(reflect.ValueOf(&m.Value))
  		return b[x:], nil
  	}
  }
  
  func makeStdFloatValuePtrSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
  	return func(b []byte, f pointer, w int) ([]byte, error) {
  		if w != WireBytes {
  			return nil, errInternalBadWireType
  		}
  		x, n := decodeVarint(b)
  		if n == 0 {
  			return nil, io.ErrUnexpectedEOF
  		}
  		b = b[n:]
  		if x > uint64(len(b)) {
  			return nil, io.ErrUnexpectedEOF
  		}
  		m := &float32Value{}
  		if err := Unmarshal(b[:x], m); err != nil {
  			return nil, err
  		}
  		slice := f.getSlice(reflect.PtrTo(sub.typ))
  		newSlice := reflect.Append(slice, reflect.ValueOf(&m.Value))
  		slice.Set(newSlice)
  		return b[x:], nil
  	}
  }
  
  func makeStdFloatValueSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
  	return func(b []byte, f pointer, w int) ([]byte, error) {
  		if w != WireBytes {
  			return nil, errInternalBadWireType
  		}
  		x, n := decodeVarint(b)
  		if n == 0 {
  			return nil, io.ErrUnexpectedEOF
  		}
  		b = b[n:]
  		if x > uint64(len(b)) {
  			return nil, io.ErrUnexpectedEOF
  		}
  		m := &float32Value{}
  		if err := Unmarshal(b[:x], m); err != nil {
  			return nil, err
  		}
  		slice := f.getSlice(sub.typ)
  		newSlice := reflect.Append(slice, reflect.ValueOf(m.Value))
  		slice.Set(newSlice)
  		return b[x:], nil
  	}
  }
  
  func makeStdInt64ValueMarshaler(u *marshalInfo) (sizer, marshaler) {
  	return func(ptr pointer, tagsize int) int {
  			t := ptr.asPointerTo(u.typ).Interface().(*int64)
  			v := &int64Value{*t}
  			siz := Size(v)
  			return tagsize + SizeVarint(uint64(siz)) + siz
  		}, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
  			t := ptr.asPointerTo(u.typ).Interface().(*int64)
  			v := &int64Value{*t}
  			buf, err := Marshal(v)
  			if err != nil {
  				return nil, err
  			}
  			b = appendVarint(b, wiretag)
  			b = appendVarint(b, uint64(len(buf)))
  			b = append(b, buf...)
  			return b, nil
  		}
  }
  
  func makeStdInt64ValuePtrMarshaler(u *marshalInfo) (sizer, marshaler) {
  	return func(ptr pointer, tagsize int) int {
  			if ptr.isNil() {
  				return 0
  			}
  			t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*int64)
  			v := &int64Value{*t}
  			siz := Size(v)
  			return tagsize + SizeVarint(uint64(siz)) + siz
  		}, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
  			if ptr.isNil() {
  				return b, nil
  			}
  			t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*int64)
  			v := &int64Value{*t}
  			buf, err := Marshal(v)
  			if err != nil {
  				return nil, err
  			}
  			b = appendVarint(b, wiretag)
  			b = appendVarint(b, uint64(len(buf)))
  			b = append(b, buf...)
  			return b, nil
  		}
  }
  
  func makeStdInt64ValueSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
  	return func(ptr pointer, tagsize int) int {
  			s := ptr.getSlice(u.typ)
  			n := 0
  			for i := 0; i < s.Len(); i++ {
  				elem := s.Index(i)
  				t := elem.Interface().(int64)
  				v := &int64Value{t}
  				siz := Size(v)
  				n += siz + SizeVarint(uint64(siz)) + tagsize
  			}
  			return n
  		},
  		func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
  			s := ptr.getSlice(u.typ)
  			for i := 0; i < s.Len(); i++ {
  				elem := s.Index(i)
  				t := elem.Interface().(int64)
  				v := &int64Value{t}
  				siz := Size(v)
  				buf, err := Marshal(v)
  				if err != nil {
  					return nil, err
  				}
  				b = appendVarint(b, wiretag)
  				b = appendVarint(b, uint64(siz))
  				b = append(b, buf...)
  			}
  
  			return b, nil
  		}
  }
  
  func makeStdInt64ValuePtrSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
  	return func(ptr pointer, tagsize int) int {
  			s := ptr.getSlice(reflect.PtrTo(u.typ))
  			n := 0
  			for i := 0; i < s.Len(); i++ {
  				elem := s.Index(i)
  				t := elem.Interface().(*int64)
  				v := &int64Value{*t}
  				siz := Size(v)
  				n += siz + SizeVarint(uint64(siz)) + tagsize
  			}
  			return n
  		},
  		func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
  			s := ptr.getSlice(reflect.PtrTo(u.typ))
  			for i := 0; i < s.Len(); i++ {
  				elem := s.Index(i)
  				t := elem.Interface().(*int64)
  				v := &int64Value{*t}
  				siz := Size(v)
  				buf, err := Marshal(v)
  				if err != nil {
  					return nil, err
  				}
  				b = appendVarint(b, wiretag)
  				b = appendVarint(b, uint64(siz))
  				b = append(b, buf...)
  			}
  
  			return b, nil
  		}
  }
  
  func makeStdInt64ValueUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
  	return func(b []byte, f pointer, w int) ([]byte, error) {
  		if w != WireBytes {
  			return nil, errInternalBadWireType
  		}
  		x, n := decodeVarint(b)
  		if n == 0 {
  			return nil, io.ErrUnexpectedEOF
  		}
  		b = b[n:]
  		if x > uint64(len(b)) {
  			return nil, io.ErrUnexpectedEOF
  		}
  		m := &int64Value{}
  		if err := Unmarshal(b[:x], m); err != nil {
  			return nil, err
  		}
  		s := f.asPointerTo(sub.typ).Elem()
  		s.Set(reflect.ValueOf(m.Value))
  		return b[x:], nil
  	}
  }
  
  func makeStdInt64ValuePtrUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
  	return func(b []byte, f pointer, w int) ([]byte, error) {
  		if w != WireBytes {
  			return nil, errInternalBadWireType
  		}
  		x, n := decodeVarint(b)
  		if n == 0 {
  			return nil, io.ErrUnexpectedEOF
  		}
  		b = b[n:]
  		if x > uint64(len(b)) {
  			return nil, io.ErrUnexpectedEOF
  		}
  		m := &int64Value{}
  		if err := Unmarshal(b[:x], m); err != nil {
  			return nil, err
  		}
  		s := f.asPointerTo(reflect.PtrTo(sub.typ)).Elem()
  		s.Set(reflect.ValueOf(&m.Value))
  		return b[x:], nil
  	}
  }
  
  func makeStdInt64ValuePtrSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
  	return func(b []byte, f pointer, w int) ([]byte, error) {
  		if w != WireBytes {
  			return nil, errInternalBadWireType
  		}
  		x, n := decodeVarint(b)
  		if n == 0 {
  			return nil, io.ErrUnexpectedEOF
  		}
  		b = b[n:]
  		if x > uint64(len(b)) {
  			return nil, io.ErrUnexpectedEOF
  		}
  		m := &int64Value{}
  		if err := Unmarshal(b[:x], m); err != nil {
  			return nil, err
  		}
  		slice := f.getSlice(reflect.PtrTo(sub.typ))
  		newSlice := reflect.Append(slice, reflect.ValueOf(&m.Value))
  		slice.Set(newSlice)
  		return b[x:], nil
  	}
  }
  
  func makeStdInt64ValueSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
  	return func(b []byte, f pointer, w int) ([]byte, error) {
  		if w != WireBytes {
  			return nil, errInternalBadWireType
  		}
  		x, n := decodeVarint(b)
  		if n == 0 {
  			return nil, io.ErrUnexpectedEOF
  		}
  		b = b[n:]
  		if x > uint64(len(b)) {
  			return nil, io.ErrUnexpectedEOF
  		}
  		m := &int64Value{}
  		if err := Unmarshal(b[:x], m); err != nil {
  			return nil, err
  		}
  		slice := f.getSlice(sub.typ)
  		newSlice := reflect.Append(slice, reflect.ValueOf(m.Value))
  		slice.Set(newSlice)
  		return b[x:], nil
  	}
  }
  
  func makeStdUInt64ValueMarshaler(u *marshalInfo) (sizer, marshaler) {
  	return func(ptr pointer, tagsize int) int {
  			t := ptr.asPointerTo(u.typ).Interface().(*uint64)
  			v := &uint64Value{*t}
  			siz := Size(v)
  			return tagsize + SizeVarint(uint64(siz)) + siz
  		}, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
  			t := ptr.asPointerTo(u.typ).Interface().(*uint64)
  			v := &uint64Value{*t}
  			buf, err := Marshal(v)
  			if err != nil {
  				return nil, err
  			}
  			b = appendVarint(b, wiretag)
  			b = appendVarint(b, uint64(len(buf)))
  			b = append(b, buf...)
  			return b, nil
  		}
  }
  
  func makeStdUInt64ValuePtrMarshaler(u *marshalInfo) (sizer, marshaler) {
  	return func(ptr pointer, tagsize int) int {
  			if ptr.isNil() {
  				return 0
  			}
  			t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*uint64)
  			v := &uint64Value{*t}
  			siz := Size(v)
  			return tagsize + SizeVarint(uint64(siz)) + siz
  		}, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
  			if ptr.isNil() {
  				return b, nil
  			}
  			t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*uint64)
  			v := &uint64Value{*t}
  			buf, err := Marshal(v)
  			if err != nil {
  				return nil, err
  			}
  			b = appendVarint(b, wiretag)
  			b = appendVarint(b, uint64(len(buf)))
  			b = append(b, buf...)
  			return b, nil
  		}
  }
  
  func makeStdUInt64ValueSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
  	return func(ptr pointer, tagsize int) int {
  			s := ptr.getSlice(u.typ)
  			n := 0
  			for i := 0; i < s.Len(); i++ {
  				elem := s.Index(i)
  				t := elem.Interface().(uint64)
  				v := &uint64Value{t}
  				siz := Size(v)
  				n += siz + SizeVarint(uint64(siz)) + tagsize
  			}
  			return n
  		},
  		func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
  			s := ptr.getSlice(u.typ)
  			for i := 0; i < s.Len(); i++ {
  				elem := s.Index(i)
  				t := elem.Interface().(uint64)
  				v := &uint64Value{t}
  				siz := Size(v)
  				buf, err := Marshal(v)
  				if err != nil {
  					return nil, err
  				}
  				b = appendVarint(b, wiretag)
  				b = appendVarint(b, uint64(siz))
  				b = append(b, buf...)
  			}
  
  			return b, nil
  		}
  }
  
  func makeStdUInt64ValuePtrSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
  	return func(ptr pointer, tagsize int) int {
  			s := ptr.getSlice(reflect.PtrTo(u.typ))
  			n := 0
  			for i := 0; i < s.Len(); i++ {
  				elem := s.Index(i)
  				t := elem.Interface().(*uint64)
  				v := &uint64Value{*t}
  				siz := Size(v)
  				n += siz + SizeVarint(uint64(siz)) + tagsize
  			}
  			return n
  		},
  		func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
  			s := ptr.getSlice(reflect.PtrTo(u.typ))
  			for i := 0; i < s.Len(); i++ {
  				elem := s.Index(i)
  				t := elem.Interface().(*uint64)
  				v := &uint64Value{*t}
  				siz := Size(v)
  				buf, err := Marshal(v)
  				if err != nil {
  					return nil, err
  				}
  				b = appendVarint(b, wiretag)
  				b = appendVarint(b, uint64(siz))
  				b = append(b, buf...)
  			}
  
  			return b, nil
  		}
  }
  
  func makeStdUInt64ValueUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
  	return func(b []byte, f pointer, w int) ([]byte, error) {
  		if w != WireBytes {
  			return nil, errInternalBadWireType
  		}
  		x, n := decodeVarint(b)
  		if n == 0 {
  			return nil, io.ErrUnexpectedEOF
  		}
  		b = b[n:]
  		if x > uint64(len(b)) {
  			return nil, io.ErrUnexpectedEOF
  		}
  		m := &uint64Value{}
  		if err := Unmarshal(b[:x], m); err != nil {
  			return nil, err
  		}
  		s := f.asPointerTo(sub.typ).Elem()
  		s.Set(reflect.ValueOf(m.Value))
  		return b[x:], nil
  	}
  }
  
  func makeStdUInt64ValuePtrUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
  	return func(b []byte, f pointer, w int) ([]byte, error) {
  		if w != WireBytes {
  			return nil, errInternalBadWireType
  		}
  		x, n := decodeVarint(b)
  		if n == 0 {
  			return nil, io.ErrUnexpectedEOF
  		}
  		b = b[n:]
  		if x > uint64(len(b)) {
  			return nil, io.ErrUnexpectedEOF
  		}
  		m := &uint64Value{}
  		if err := Unmarshal(b[:x], m); err != nil {
  			return nil, err
  		}
  		s := f.asPointerTo(reflect.PtrTo(sub.typ)).Elem()
  		s.Set(reflect.ValueOf(&m.Value))
  		return b[x:], nil
  	}
  }
  
  func makeStdUInt64ValuePtrSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
  	return func(b []byte, f pointer, w int) ([]byte, error) {
  		if w != WireBytes {
  			return nil, errInternalBadWireType
  		}
  		x, n := decodeVarint(b)
  		if n == 0 {
  			return nil, io.ErrUnexpectedEOF
  		}
  		b = b[n:]
  		if x > uint64(len(b)) {
  			return nil, io.ErrUnexpectedEOF
  		}
  		m := &uint64Value{}
  		if err := Unmarshal(b[:x], m); err != nil {
  			return nil, err
  		}
  		slice := f.getSlice(reflect.PtrTo(sub.typ))
  		newSlice := reflect.Append(slice, reflect.ValueOf(&m.Value))
  		slice.Set(newSlice)
  		return b[x:], nil
  	}
  }
  
  func makeStdUInt64ValueSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
  	return func(b []byte, f pointer, w int) ([]byte, error) {
  		if w != WireBytes {
  			return nil, errInternalBadWireType
  		}
  		x, n := decodeVarint(b)
  		if n == 0 {
  			return nil, io.ErrUnexpectedEOF
  		}
  		b = b[n:]
  		if x > uint64(len(b)) {
  			return nil, io.ErrUnexpectedEOF
  		}
  		m := &uint64Value{}
  		if err := Unmarshal(b[:x], m); err != nil {
  			return nil, err
  		}
  		slice := f.getSlice(sub.typ)
  		newSlice := reflect.Append(slice, reflect.ValueOf(m.Value))
  		slice.Set(newSlice)
  		return b[x:], nil
  	}
  }
  
  func makeStdInt32ValueMarshaler(u *marshalInfo) (sizer, marshaler) {
  	return func(ptr pointer, tagsize int) int {
  			t := ptr.asPointerTo(u.typ).Interface().(*int32)
  			v := &int32Value{*t}
  			siz := Size(v)
  			return tagsize + SizeVarint(uint64(siz)) + siz
  		}, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
  			t := ptr.asPointerTo(u.typ).Interface().(*int32)
  			v := &int32Value{*t}
  			buf, err := Marshal(v)
  			if err != nil {
  				return nil, err
  			}
  			b = appendVarint(b, wiretag)
  			b = appendVarint(b, uint64(len(buf)))
  			b = append(b, buf...)
  			return b, nil
  		}
  }
  
  func makeStdInt32ValuePtrMarshaler(u *marshalInfo) (sizer, marshaler) {
  	return func(ptr pointer, tagsize int) int {
  			if ptr.isNil() {
  				return 0
  			}
  			t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*int32)
  			v := &int32Value{*t}
  			siz := Size(v)
  			return tagsize + SizeVarint(uint64(siz)) + siz
  		}, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
  			if ptr.isNil() {
  				return b, nil
  			}
  			t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*int32)
  			v := &int32Value{*t}
  			buf, err := Marshal(v)
  			if err != nil {
  				return nil, err
  			}
  			b = appendVarint(b, wiretag)
  			b = appendVarint(b, uint64(len(buf)))
  			b = append(b, buf...)
  			return b, nil
  		}
  }
  
  func makeStdInt32ValueSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
  	return func(ptr pointer, tagsize int) int {
  			s := ptr.getSlice(u.typ)
  			n := 0
  			for i := 0; i < s.Len(); i++ {
  				elem := s.Index(i)
  				t := elem.Interface().(int32)
  				v := &int32Value{t}
  				siz := Size(v)
  				n += siz + SizeVarint(uint64(siz)) + tagsize
  			}
  			return n
  		},
  		func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
  			s := ptr.getSlice(u.typ)
  			for i := 0; i < s.Len(); i++ {
  				elem := s.Index(i)
  				t := elem.Interface().(int32)
  				v := &int32Value{t}
  				siz := Size(v)
  				buf, err := Marshal(v)
  				if err != nil {
  					return nil, err
  				}
  				b = appendVarint(b, wiretag)
  				b = appendVarint(b, uint64(siz))
  				b = append(b, buf...)
  			}
  
  			return b, nil
  		}
  }
  
  func makeStdInt32ValuePtrSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
  	return func(ptr pointer, tagsize int) int {
  			s := ptr.getSlice(reflect.PtrTo(u.typ))
  			n := 0
  			for i := 0; i < s.Len(); i++ {
  				elem := s.Index(i)
  				t := elem.Interface().(*int32)
  				v := &int32Value{*t}
  				siz := Size(v)
  				n += siz + SizeVarint(uint64(siz)) + tagsize
  			}
  			return n
  		},
  		func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
  			s := ptr.getSlice(reflect.PtrTo(u.typ))
  			for i := 0; i < s.Len(); i++ {
  				elem := s.Index(i)
  				t := elem.Interface().(*int32)
  				v := &int32Value{*t}
  				siz := Size(v)
  				buf, err := Marshal(v)
  				if err != nil {
  					return nil, err
  				}
  				b = appendVarint(b, wiretag)
  				b = appendVarint(b, uint64(siz))
  				b = append(b, buf...)
  			}
  
  			return b, nil
  		}
  }
  
  func makeStdInt32ValueUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
  	return func(b []byte, f pointer, w int) ([]byte, error) {
  		if w != WireBytes {
  			return nil, errInternalBadWireType
  		}
  		x, n := decodeVarint(b)
  		if n == 0 {
  			return nil, io.ErrUnexpectedEOF
  		}
  		b = b[n:]
  		if x > uint64(len(b)) {
  			return nil, io.ErrUnexpectedEOF
  		}
  		m := &int32Value{}
  		if err := Unmarshal(b[:x], m); err != nil {
  			return nil, err
  		}
  		s := f.asPointerTo(sub.typ).Elem()
  		s.Set(reflect.ValueOf(m.Value))
  		return b[x:], nil
  	}
  }
  
  func makeStdInt32ValuePtrUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
  	return func(b []byte, f pointer, w int) ([]byte, error) {
  		if w != WireBytes {
  			return nil, errInternalBadWireType
  		}
  		x, n := decodeVarint(b)
  		if n == 0 {
  			return nil, io.ErrUnexpectedEOF
  		}
  		b = b[n:]
  		if x > uint64(len(b)) {
  			return nil, io.ErrUnexpectedEOF
  		}
  		m := &int32Value{}
  		if err := Unmarshal(b[:x], m); err != nil {
  			return nil, err
  		}
  		s := f.asPointerTo(reflect.PtrTo(sub.typ)).Elem()
  		s.Set(reflect.ValueOf(&m.Value))
  		return b[x:], nil
  	}
  }
  
  func makeStdInt32ValuePtrSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
  	return func(b []byte, f pointer, w int) ([]byte, error) {
  		if w != WireBytes {
  			return nil, errInternalBadWireType
  		}
  		x, n := decodeVarint(b)
  		if n == 0 {
  			return nil, io.ErrUnexpectedEOF
  		}
  		b = b[n:]
  		if x > uint64(len(b)) {
  			return nil, io.ErrUnexpectedEOF
  		}
  		m := &int32Value{}
  		if err := Unmarshal(b[:x], m); err != nil {
  			return nil, err
  		}
  		slice := f.getSlice(reflect.PtrTo(sub.typ))
  		newSlice := reflect.Append(slice, reflect.ValueOf(&m.Value))
  		slice.Set(newSlice)
  		return b[x:], nil
  	}
  }
  
  func makeStdInt32ValueSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
  	return func(b []byte, f pointer, w int) ([]byte, error) {
  		if w != WireBytes {
  			return nil, errInternalBadWireType
  		}
  		x, n := decodeVarint(b)
  		if n == 0 {
  			return nil, io.ErrUnexpectedEOF
  		}
  		b = b[n:]
  		if x > uint64(len(b)) {
  			return nil, io.ErrUnexpectedEOF
  		}
  		m := &int32Value{}
  		if err := Unmarshal(b[:x], m); err != nil {
  			return nil, err
  		}
  		slice := f.getSlice(sub.typ)
  		newSlice := reflect.Append(slice, reflect.ValueOf(m.Value))
  		slice.Set(newSlice)
  		return b[x:], nil
  	}
  }
  
  func makeStdUInt32ValueMarshaler(u *marshalInfo) (sizer, marshaler) {
  	return func(ptr pointer, tagsize int) int {
  			t := ptr.asPointerTo(u.typ).Interface().(*uint32)
  			v := &uint32Value{*t}
  			siz := Size(v)
  			return tagsize + SizeVarint(uint64(siz)) + siz
  		}, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
  			t := ptr.asPointerTo(u.typ).Interface().(*uint32)
  			v := &uint32Value{*t}
  			buf, err := Marshal(v)
  			if err != nil {
  				return nil, err
  			}
  			b = appendVarint(b, wiretag)
  			b = appendVarint(b, uint64(len(buf)))
  			b = append(b, buf...)
  			return b, nil
  		}
  }
  
  func makeStdUInt32ValuePtrMarshaler(u *marshalInfo) (sizer, marshaler) {
  	return func(ptr pointer, tagsize int) int {
  			if ptr.isNil() {
  				return 0
  			}
  			t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*uint32)
  			v := &uint32Value{*t}
  			siz := Size(v)
  			return tagsize + SizeVarint(uint64(siz)) + siz
  		}, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
  			if ptr.isNil() {
  				return b, nil
  			}
  			t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*uint32)
  			v := &uint32Value{*t}
  			buf, err := Marshal(v)
  			if err != nil {
  				return nil, err
  			}
  			b = appendVarint(b, wiretag)
  			b = appendVarint(b, uint64(len(buf)))
  			b = append(b, buf...)
  			return b, nil
  		}
  }
  
  func makeStdUInt32ValueSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
  	return func(ptr pointer, tagsize int) int {
  			s := ptr.getSlice(u.typ)
  			n := 0
  			for i := 0; i < s.Len(); i++ {
  				elem := s.Index(i)
  				t := elem.Interface().(uint32)
  				v := &uint32Value{t}
  				siz := Size(v)
  				n += siz + SizeVarint(uint64(siz)) + tagsize
  			}
  			return n
  		},
  		func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
  			s := ptr.getSlice(u.typ)
  			for i := 0; i < s.Len(); i++ {
  				elem := s.Index(i)
  				t := elem.Interface().(uint32)
  				v := &uint32Value{t}
  				siz := Size(v)
  				buf, err := Marshal(v)
  				if err != nil {
  					return nil, err
  				}
  				b = appendVarint(b, wiretag)
  				b = appendVarint(b, uint64(siz))
  				b = append(b, buf...)
  			}
  
  			return b, nil
  		}
  }
  
  func makeStdUInt32ValuePtrSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
  	return func(ptr pointer, tagsize int) int {
  			s := ptr.getSlice(reflect.PtrTo(u.typ))
  			n := 0
  			for i := 0; i < s.Len(); i++ {
  				elem := s.Index(i)
  				t := elem.Interface().(*uint32)
  				v := &uint32Value{*t}
  				siz := Size(v)
  				n += siz + SizeVarint(uint64(siz)) + tagsize
  			}
  			return n
  		},
  		func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
  			s := ptr.getSlice(reflect.PtrTo(u.typ))
  			for i := 0; i < s.Len(); i++ {
  				elem := s.Index(i)
  				t := elem.Interface().(*uint32)
  				v := &uint32Value{*t}
  				siz := Size(v)
  				buf, err := Marshal(v)
  				if err != nil {
  					return nil, err
  				}
  				b = appendVarint(b, wiretag)
  				b = appendVarint(b, uint64(siz))
  				b = append(b, buf...)
  			}
  
  			return b, nil
  		}
  }
  
  func makeStdUInt32ValueUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
  	return func(b []byte, f pointer, w int) ([]byte, error) {
  		if w != WireBytes {
  			return nil, errInternalBadWireType
  		}
  		x, n := decodeVarint(b)
  		if n == 0 {
  			return nil, io.ErrUnexpectedEOF
  		}
  		b = b[n:]
  		if x > uint64(len(b)) {
  			return nil, io.ErrUnexpectedEOF
  		}
  		m := &uint32Value{}
  		if err := Unmarshal(b[:x], m); err != nil {
  			return nil, err
  		}
  		s := f.asPointerTo(sub.typ).Elem()
  		s.Set(reflect.ValueOf(m.Value))
  		return b[x:], nil
  	}
  }
  
  func makeStdUInt32ValuePtrUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
  	return func(b []byte, f pointer, w int) ([]byte, error) {
  		if w != WireBytes {
  			return nil, errInternalBadWireType
  		}
  		x, n := decodeVarint(b)
  		if n == 0 {
  			return nil, io.ErrUnexpectedEOF
  		}
  		b = b[n:]
  		if x > uint64(len(b)) {
  			return nil, io.ErrUnexpectedEOF
  		}
  		m := &uint32Value{}
  		if err := Unmarshal(b[:x], m); err != nil {
  			return nil, err
  		}
  		s := f.asPointerTo(reflect.PtrTo(sub.typ)).Elem()
  		s.Set(reflect.ValueOf(&m.Value))
  		return b[x:], nil
  	}
  }
  
  func makeStdUInt32ValuePtrSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
  	return func(b []byte, f pointer, w int) ([]byte, error) {
  		if w != WireBytes {
  			return nil, errInternalBadWireType
  		}
  		x, n := decodeVarint(b)
  		if n == 0 {
  			return nil, io.ErrUnexpectedEOF
  		}
  		b = b[n:]
  		if x > uint64(len(b)) {
  			return nil, io.ErrUnexpectedEOF
  		}
  		m := &uint32Value{}
  		if err := Unmarshal(b[:x], m); err != nil {
  			return nil, err
  		}
  		slice := f.getSlice(reflect.PtrTo(sub.typ))
  		newSlice := reflect.Append(slice, reflect.ValueOf(&m.Value))
  		slice.Set(newSlice)
  		return b[x:], nil
  	}
  }
  
  func makeStdUInt32ValueSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
  	return func(b []byte, f pointer, w int) ([]byte, error) {
  		if w != WireBytes {
  			return nil, errInternalBadWireType
  		}
  		x, n := decodeVarint(b)
  		if n == 0 {
  			return nil, io.ErrUnexpectedEOF
  		}
  		b = b[n:]
  		if x > uint64(len(b)) {
  			return nil, io.ErrUnexpectedEOF
  		}
  		m := &uint32Value{}
  		if err := Unmarshal(b[:x], m); err != nil {
  			return nil, err
  		}
  		slice := f.getSlice(sub.typ)
  		newSlice := reflect.Append(slice, reflect.ValueOf(m.Value))
  		slice.Set(newSlice)
  		return b[x:], nil
  	}
  }
  
  func makeStdBoolValueMarshaler(u *marshalInfo) (sizer, marshaler) {
  	return func(ptr pointer, tagsize int) int {
  			t := ptr.asPointerTo(u.typ).Interface().(*bool)
  			v := &boolValue{*t}
  			siz := Size(v)
  			return tagsize + SizeVarint(uint64(siz)) + siz
  		}, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
  			t := ptr.asPointerTo(u.typ).Interface().(*bool)
  			v := &boolValue{*t}
  			buf, err := Marshal(v)
  			if err != nil {
  				return nil, err
  			}
  			b = appendVarint(b, wiretag)
  			b = appendVarint(b, uint64(len(buf)))
  			b = append(b, buf...)
  			return b, nil
  		}
  }
  
  func makeStdBoolValuePtrMarshaler(u *marshalInfo) (sizer, marshaler) {
  	return func(ptr pointer, tagsize int) int {
  			if ptr.isNil() {
  				return 0
  			}
  			t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*bool)
  			v := &boolValue{*t}
  			siz := Size(v)
  			return tagsize + SizeVarint(uint64(siz)) + siz
  		}, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
  			if ptr.isNil() {
  				return b, nil
  			}
  			t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*bool)
  			v := &boolValue{*t}
  			buf, err := Marshal(v)
  			if err != nil {
  				return nil, err
  			}
  			b = appendVarint(b, wiretag)
  			b = appendVarint(b, uint64(len(buf)))
  			b = append(b, buf...)
  			return b, nil
  		}
  }
  
  func makeStdBoolValueSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
  	return func(ptr pointer, tagsize int) int {
  			s := ptr.getSlice(u.typ)
  			n := 0
  			for i := 0; i < s.Len(); i++ {
  				elem := s.Index(i)
  				t := elem.Interface().(bool)
  				v := &boolValue{t}
  				siz := Size(v)
  				n += siz + SizeVarint(uint64(siz)) + tagsize
  			}
  			return n
  		},
  		func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
  			s := ptr.getSlice(u.typ)
  			for i := 0; i < s.Len(); i++ {
  				elem := s.Index(i)
  				t := elem.Interface().(bool)
  				v := &boolValue{t}
  				siz := Size(v)
  				buf, err := Marshal(v)
  				if err != nil {
  					return nil, err
  				}
  				b = appendVarint(b, wiretag)
  				b = appendVarint(b, uint64(siz))
  				b = append(b, buf...)
  			}
  
  			return b, nil
  		}
  }
  
  func makeStdBoolValuePtrSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
  	return func(ptr pointer, tagsize int) int {
  			s := ptr.getSlice(reflect.PtrTo(u.typ))
  			n := 0
  			for i := 0; i < s.Len(); i++ {
  				elem := s.Index(i)
  				t := elem.Interface().(*bool)
  				v := &boolValue{*t}
  				siz := Size(v)
  				n += siz + SizeVarint(uint64(siz)) + tagsize
  			}
  			return n
  		},
  		func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
  			s := ptr.getSlice(reflect.PtrTo(u.typ))
  			for i := 0; i < s.Len(); i++ {
  				elem := s.Index(i)
  				t := elem.Interface().(*bool)
  				v := &boolValue{*t}
  				siz := Size(v)
  				buf, err := Marshal(v)
  				if err != nil {
  					return nil, err
  				}
  				b = appendVarint(b, wiretag)
  				b = appendVarint(b, uint64(siz))
  				b = append(b, buf...)
  			}
  
  			return b, nil
  		}
  }
  
  func makeStdBoolValueUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
  	return func(b []byte, f pointer, w int) ([]byte, error) {
  		if w != WireBytes {
  			return nil, errInternalBadWireType
  		}
  		x, n := decodeVarint(b)
  		if n == 0 {
  			return nil, io.ErrUnexpectedEOF
  		}
  		b = b[n:]
  		if x > uint64(len(b)) {
  			return nil, io.ErrUnexpectedEOF
  		}
  		m := &boolValue{}
  		if err := Unmarshal(b[:x], m); err != nil {
  			return nil, err
  		}
  		s := f.asPointerTo(sub.typ).Elem()
  		s.Set(reflect.ValueOf(m.Value))
  		return b[x:], nil
  	}
  }
  
  func makeStdBoolValuePtrUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
  	return func(b []byte, f pointer, w int) ([]byte, error) {
  		if w != WireBytes {
  			return nil, errInternalBadWireType
  		}
  		x, n := decodeVarint(b)
  		if n == 0 {
  			return nil, io.ErrUnexpectedEOF
  		}
  		b = b[n:]
  		if x > uint64(len(b)) {
  			return nil, io.ErrUnexpectedEOF
  		}
  		m := &boolValue{}
  		if err := Unmarshal(b[:x], m); err != nil {
  			return nil, err
  		}
  		s := f.asPointerTo(reflect.PtrTo(sub.typ)).Elem()
  		s.Set(reflect.ValueOf(&m.Value))
  		return b[x:], nil
  	}
  }
  
  func makeStdBoolValuePtrSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
  	return func(b []byte, f pointer, w int) ([]byte, error) {
  		if w != WireBytes {
  			return nil, errInternalBadWireType
  		}
  		x, n := decodeVarint(b)
  		if n == 0 {
  			return nil, io.ErrUnexpectedEOF
  		}
  		b = b[n:]
  		if x > uint64(len(b)) {
  			return nil, io.ErrUnexpectedEOF
  		}
  		m := &boolValue{}
  		if err := Unmarshal(b[:x], m); err != nil {
  			return nil, err
  		}
  		slice := f.getSlice(reflect.PtrTo(sub.typ))
  		newSlice := reflect.Append(slice, reflect.ValueOf(&m.Value))
  		slice.Set(newSlice)
  		return b[x:], nil
  	}
  }
  
  func makeStdBoolValueSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
  	return func(b []byte, f pointer, w int) ([]byte, error) {
  		if w != WireBytes {
  			return nil, errInternalBadWireType
  		}
  		x, n := decodeVarint(b)
  		if n == 0 {
  			return nil, io.ErrUnexpectedEOF
  		}
  		b = b[n:]
  		if x > uint64(len(b)) {
  			return nil, io.ErrUnexpectedEOF
  		}
  		m := &boolValue{}
  		if err := Unmarshal(b[:x], m); err != nil {
  			return nil, err
  		}
  		slice := f.getSlice(sub.typ)
  		newSlice := reflect.Append(slice, reflect.ValueOf(m.Value))
  		slice.Set(newSlice)
  		return b[x:], nil
  	}
  }
  
  func makeStdStringValueMarshaler(u *marshalInfo) (sizer, marshaler) {
  	return func(ptr pointer, tagsize int) int {
  			t := ptr.asPointerTo(u.typ).Interface().(*string)
  			v := &stringValue{*t}
  			siz := Size(v)
  			return tagsize + SizeVarint(uint64(siz)) + siz
  		}, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
  			t := ptr.asPointerTo(u.typ).Interface().(*string)
  			v := &stringValue{*t}
  			buf, err := Marshal(v)
  			if err != nil {
  				return nil, err
  			}
  			b = appendVarint(b, wiretag)
  			b = appendVarint(b, uint64(len(buf)))
  			b = append(b, buf...)
  			return b, nil
  		}
  }
  
  func makeStdStringValuePtrMarshaler(u *marshalInfo) (sizer, marshaler) {
  	return func(ptr pointer, tagsize int) int {
  			if ptr.isNil() {
  				return 0
  			}
  			t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*string)
  			v := &stringValue{*t}
  			siz := Size(v)
  			return tagsize + SizeVarint(uint64(siz)) + siz
  		}, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
  			if ptr.isNil() {
  				return b, nil
  			}
  			t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*string)
  			v := &stringValue{*t}
  			buf, err := Marshal(v)
  			if err != nil {
  				return nil, err
  			}
  			b = appendVarint(b, wiretag)
  			b = appendVarint(b, uint64(len(buf)))
  			b = append(b, buf...)
  			return b, nil
  		}
  }
  
  func makeStdStringValueSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
  	return func(ptr pointer, tagsize int) int {
  			s := ptr.getSlice(u.typ)
  			n := 0
  			for i := 0; i < s.Len(); i++ {
  				elem := s.Index(i)
  				t := elem.Interface().(string)
  				v := &stringValue{t}
  				siz := Size(v)
  				n += siz + SizeVarint(uint64(siz)) + tagsize
  			}
  			return n
  		},
  		func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
  			s := ptr.getSlice(u.typ)
  			for i := 0; i < s.Len(); i++ {
  				elem := s.Index(i)
  				t := elem.Interface().(string)
  				v := &stringValue{t}
  				siz := Size(v)
  				buf, err := Marshal(v)
  				if err != nil {
  					return nil, err
  				}
  				b = appendVarint(b, wiretag)
  				b = appendVarint(b, uint64(siz))
  				b = append(b, buf...)
  			}
  
  			return b, nil
  		}
  }
  
  func makeStdStringValuePtrSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
  	return func(ptr pointer, tagsize int) int {
  			s := ptr.getSlice(reflect.PtrTo(u.typ))
  			n := 0
  			for i := 0; i < s.Len(); i++ {
  				elem := s.Index(i)
  				t := elem.Interface().(*string)
  				v := &stringValue{*t}
  				siz := Size(v)
  				n += siz + SizeVarint(uint64(siz)) + tagsize
  			}
  			return n
  		},
  		func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
  			s := ptr.getSlice(reflect.PtrTo(u.typ))
  			for i := 0; i < s.Len(); i++ {
  				elem := s.Index(i)
  				t := elem.Interface().(*string)
  				v := &stringValue{*t}
  				siz := Size(v)
  				buf, err := Marshal(v)
  				if err != nil {
  					return nil, err
  				}
  				b = appendVarint(b, wiretag)
  				b = appendVarint(b, uint64(siz))
  				b = append(b, buf...)
  			}
  
  			return b, nil
  		}
  }
  
  func makeStdStringValueUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
  	return func(b []byte, f pointer, w int) ([]byte, error) {
  		if w != WireBytes {
  			return nil, errInternalBadWireType
  		}
  		x, n := decodeVarint(b)
  		if n == 0 {
  			return nil, io.ErrUnexpectedEOF
  		}
  		b = b[n:]
  		if x > uint64(len(b)) {
  			return nil, io.ErrUnexpectedEOF
  		}
  		m := &stringValue{}
  		if err := Unmarshal(b[:x], m); err != nil {
  			return nil, err
  		}
  		s := f.asPointerTo(sub.typ).Elem()
  		s.Set(reflect.ValueOf(m.Value))
  		return b[x:], nil
  	}
  }
  
  func makeStdStringValuePtrUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
  	return func(b []byte, f pointer, w int) ([]byte, error) {
  		if w != WireBytes {
  			return nil, errInternalBadWireType
  		}
  		x, n := decodeVarint(b)
  		if n == 0 {
  			return nil, io.ErrUnexpectedEOF
  		}
  		b = b[n:]
  		if x > uint64(len(b)) {
  			return nil, io.ErrUnexpectedEOF
  		}
  		m := &stringValue{}
  		if err := Unmarshal(b[:x], m); err != nil {
  			return nil, err
  		}
  		s := f.asPointerTo(reflect.PtrTo(sub.typ)).Elem()
  		s.Set(reflect.ValueOf(&m.Value))
  		return b[x:], nil
  	}
  }
  
  func makeStdStringValuePtrSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
  	return func(b []byte, f pointer, w int) ([]byte, error) {
  		if w != WireBytes {
  			return nil, errInternalBadWireType
  		}
  		x, n := decodeVarint(b)
  		if n == 0 {
  			return nil, io.ErrUnexpectedEOF
  		}
  		b = b[n:]
  		if x > uint64(len(b)) {
  			return nil, io.ErrUnexpectedEOF
  		}
  		m := &stringValue{}
  		if err := Unmarshal(b[:x], m); err != nil {
  			return nil, err
  		}
  		slice := f.getSlice(reflect.PtrTo(sub.typ))
  		newSlice := reflect.Append(slice, reflect.ValueOf(&m.Value))
  		slice.Set(newSlice)
  		return b[x:], nil
  	}
  }
  
  func makeStdStringValueSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
  	return func(b []byte, f pointer, w int) ([]byte, error) {
  		if w != WireBytes {
  			return nil, errInternalBadWireType
  		}
  		x, n := decodeVarint(b)
  		if n == 0 {
  			return nil, io.ErrUnexpectedEOF
  		}
  		b = b[n:]
  		if x > uint64(len(b)) {
  			return nil, io.ErrUnexpectedEOF
  		}
  		m := &stringValue{}
  		if err := Unmarshal(b[:x], m); err != nil {
  			return nil, err
  		}
  		slice := f.getSlice(sub.typ)
  		newSlice := reflect.Append(slice, reflect.ValueOf(m.Value))
  		slice.Set(newSlice)
  		return b[x:], nil
  	}
  }
  
  func makeStdBytesValueMarshaler(u *marshalInfo) (sizer, marshaler) {
  	return func(ptr pointer, tagsize int) int {
  			t := ptr.asPointerTo(u.typ).Interface().(*[]byte)
  			v := &bytesValue{*t}
  			siz := Size(v)
  			return tagsize + SizeVarint(uint64(siz)) + siz
  		}, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
  			t := ptr.asPointerTo(u.typ).Interface().(*[]byte)
  			v := &bytesValue{*t}
  			buf, err := Marshal(v)
  			if err != nil {
  				return nil, err
  			}
  			b = appendVarint(b, wiretag)
  			b = appendVarint(b, uint64(len(buf)))
  			b = append(b, buf...)
  			return b, nil
  		}
  }
  
  func makeStdBytesValuePtrMarshaler(u *marshalInfo) (sizer, marshaler) {
  	return func(ptr pointer, tagsize int) int {
  			if ptr.isNil() {
  				return 0
  			}
  			t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*[]byte)
  			v := &bytesValue{*t}
  			siz := Size(v)
  			return tagsize + SizeVarint(uint64(siz)) + siz
  		}, func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
  			if ptr.isNil() {
  				return b, nil
  			}
  			t := ptr.asPointerTo(reflect.PtrTo(u.typ)).Elem().Interface().(*[]byte)
  			v := &bytesValue{*t}
  			buf, err := Marshal(v)
  			if err != nil {
  				return nil, err
  			}
  			b = appendVarint(b, wiretag)
  			b = appendVarint(b, uint64(len(buf)))
  			b = append(b, buf...)
  			return b, nil
  		}
  }
  
  func makeStdBytesValueSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
  	return func(ptr pointer, tagsize int) int {
  			s := ptr.getSlice(u.typ)
  			n := 0
  			for i := 0; i < s.Len(); i++ {
  				elem := s.Index(i)
  				t := elem.Interface().([]byte)
  				v := &bytesValue{t}
  				siz := Size(v)
  				n += siz + SizeVarint(uint64(siz)) + tagsize
  			}
  			return n
  		},
  		func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
  			s := ptr.getSlice(u.typ)
  			for i := 0; i < s.Len(); i++ {
  				elem := s.Index(i)
  				t := elem.Interface().([]byte)
  				v := &bytesValue{t}
  				siz := Size(v)
  				buf, err := Marshal(v)
  				if err != nil {
  					return nil, err
  				}
  				b = appendVarint(b, wiretag)
  				b = appendVarint(b, uint64(siz))
  				b = append(b, buf...)
  			}
  
  			return b, nil
  		}
  }
  
  func makeStdBytesValuePtrSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
  	return func(ptr pointer, tagsize int) int {
  			s := ptr.getSlice(reflect.PtrTo(u.typ))
  			n := 0
  			for i := 0; i < s.Len(); i++ {
  				elem := s.Index(i)
  				t := elem.Interface().(*[]byte)
  				v := &bytesValue{*t}
  				siz := Size(v)
  				n += siz + SizeVarint(uint64(siz)) + tagsize
  			}
  			return n
  		},
  		func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
  			s := ptr.getSlice(reflect.PtrTo(u.typ))
  			for i := 0; i < s.Len(); i++ {
  				elem := s.Index(i)
  				t := elem.Interface().(*[]byte)
  				v := &bytesValue{*t}
  				siz := Size(v)
  				buf, err := Marshal(v)
  				if err != nil {
  					return nil, err
  				}
  				b = appendVarint(b, wiretag)
  				b = appendVarint(b, uint64(siz))
  				b = append(b, buf...)
  			}
  
  			return b, nil
  		}
  }
  
  func makeStdBytesValueUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
  	return func(b []byte, f pointer, w int) ([]byte, error) {
  		if w != WireBytes {
  			return nil, errInternalBadWireType
  		}
  		x, n := decodeVarint(b)
  		if n == 0 {
  			return nil, io.ErrUnexpectedEOF
  		}
  		b = b[n:]
  		if x > uint64(len(b)) {
  			return nil, io.ErrUnexpectedEOF
  		}
  		m := &bytesValue{}
  		if err := Unmarshal(b[:x], m); err != nil {
  			return nil, err
  		}
  		s := f.asPointerTo(sub.typ).Elem()
  		s.Set(reflect.ValueOf(m.Value))
  		return b[x:], nil
  	}
  }
  
  func makeStdBytesValuePtrUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
  	return func(b []byte, f pointer, w int) ([]byte, error) {
  		if w != WireBytes {
  			return nil, errInternalBadWireType
  		}
  		x, n := decodeVarint(b)
  		if n == 0 {
  			return nil, io.ErrUnexpectedEOF
  		}
  		b = b[n:]
  		if x > uint64(len(b)) {
  			return nil, io.ErrUnexpectedEOF
  		}
  		m := &bytesValue{}
  		if err := Unmarshal(b[:x], m); err != nil {
  			return nil, err
  		}
  		s := f.asPointerTo(reflect.PtrTo(sub.typ)).Elem()
  		s.Set(reflect.ValueOf(&m.Value))
  		return b[x:], nil
  	}
  }
  
  func makeStdBytesValuePtrSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
  	return func(b []byte, f pointer, w int) ([]byte, error) {
  		if w != WireBytes {
  			return nil, errInternalBadWireType
  		}
  		x, n := decodeVarint(b)
  		if n == 0 {
  			return nil, io.ErrUnexpectedEOF
  		}
  		b = b[n:]
  		if x > uint64(len(b)) {
  			return nil, io.ErrUnexpectedEOF
  		}
  		m := &bytesValue{}
  		if err := Unmarshal(b[:x], m); err != nil {
  			return nil, err
  		}
  		slice := f.getSlice(reflect.PtrTo(sub.typ))
  		newSlice := reflect.Append(slice, reflect.ValueOf(&m.Value))
  		slice.Set(newSlice)
  		return b[x:], nil
  	}
  }
  
  func makeStdBytesValueSliceUnmarshaler(sub *unmarshalInfo, name string) unmarshaler {
  	return func(b []byte, f pointer, w int) ([]byte, error) {
  		if w != WireBytes {
  			return nil, errInternalBadWireType
  		}
  		x, n := decodeVarint(b)
  		if n == 0 {
  			return nil, io.ErrUnexpectedEOF
  		}
  		b = b[n:]
  		if x > uint64(len(b)) {
  			return nil, io.ErrUnexpectedEOF
  		}
  		m := &bytesValue{}
  		if err := Unmarshal(b[:x], m); err != nil {
  			return nil, err
  		}
  		slice := f.getSlice(sub.typ)
  		newSlice := reflect.Append(slice, reflect.ValueOf(m.Value))
  		slice.Set(newSlice)
  		return b[x:], nil
  	}
  }
  