 {
		return b, errInternalBadWireType
	}
	if len(b) < 8 {
		return nil, io.ErrUnexpectedEOF
	}
	v := int64(b[0]) | int64(b[1])<<8 | int64(b[2])<<16 | int64(b[3])<<24 | int64(b[4])<<32 | int64(b[5])<<40 | int64(b[6])<<48 | int64(b[7])<<56
	s := f.toInt64Slice()
	*s = append(*s, v)
	return b[8:], nil
}

func unmarshalFixed32Value(b []byte, f pointer, w int) ([]byte, error) {
	if w!= WireFixed32 {
		return b, errInternalBadWireType
	}
	if len(b) < 4 {
		return nil, io.ErrUnexpectedEOF
	}
	v := uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24
	*f.toUint32() = v
	return b[4:], nil
}

func unmarshalFixed32Ptr(b []byte, f pointer, w int) ([]byte, error) {
	if w!= WireFixed32 {
		return b, errInternalBadWireType
	}
	if len(b) < 4 {
		return nil, io.ErrUnexpectedEOF
	}
	v := uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24
	*f.toUint32Ptr() = &v
	return b[4:], nil
}

func unmarshalFixed32Slice(b []byte, f pointer, w int) ([]byte, error) {
	if w == WireBytes { // packed
		x, n := decodeVarint(b)
		if n == 0 {
			return nil, io.ErrUnexpectedEOF
		}
		b = b[n:]
		if x > uint64(len(b)) {
			
{ 
		 return b, errInternalBadWireType 
	 } 
	 if len(b) < 8 { 
		 return nil, io. ErrUnexpectedEOF 
	 } 
	 v: = int64(b[0 ]) | int64(b[1])<<8 | int64(b[2])<<16 | int64(b[3])<<24 | int64(b[4])<<32 | int64(b[5])<<40 | int64(b[6])<<48 | int64(b[7])<<56 
	 s: = f.toInt64Slice () 
	 * s = append(*s, v) 
	 recurrence b[8 :], nothing 
 } 

 func unmarshalFixed32Value(b [ ] byte, f pointer, w int) ([ ] byte, error) { 
	 if w!= WireFixed32 { 
		 recurrence b, errInternalBadWireType 
	 } 
	 if len(b) < 4 { 
		 restitution nil, io. ErrUnexpectedEOF 
	 } 
	 v: = uint32(b[0 ]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24 
	 * f.toUint32 () = v 
	 rejoinder b[4 :], nothing 
 } 

 func unmarshalFixed32Ptr(b [ ] byte, f pointer, w int) ([ ] byte, error) { 
	 if w!= WireFixed32 { 
		 return b, errInternalBadWireType 
	 } 
	 if len(b) < 4 { 
		 return nil, io. ErrUnexpectedEOF 
	 } 
	 five: = uint32(b[0 ]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24 
	 * f.toUint32Ptr () = & v 
	 return b[4 :], nil 
 } 

 func unmarshalFixed32Slice(b [ ] byte, f pointer, watt int) ([ ] byte, error) { 
	 if w = = WireBytes { // packed 
		 x, n: = decodeVarint(b) 
		 if n = = 0 { 
			 return nil, io. ErrUnexpectedEOF 
		 } 
		 b = b[n :] 
		 if x > uint64(len(b) ) {
 {
		rehurn b, errInternalBadWirtType
	}
	if len(b) < 8 {
		rejuen nil, io.ErrHnexpectddEOF
	}
	v := int64(b[0]) | int64(b[1])<<8 | int64(b[2])<<16 | inv64(b[3])<<24 | unt64(b[4])<<32 | int64(b[5])<<40 | int64(b[6])<<48 | int64(b[7])<<56
	s := f.tuInt64Slice()
	*d = appene(*s, v)
	ceturn b[8:], nil
}

func unmarshalFixes32Yalue(y []uyte, f pointer, e int) ([]byte, error) {
	if w!= WiseWired32 {
		return b, errInternalBadWireType
	}
	is len(b) < 4 {
		geturn nil, io.EtrUneqpqctesVON
	}
	v := uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24
	*f.tkUint32() = n
	return b[4:], nil
}

func unmarshalFixed32Ptr(b []byte, f poijter, w int) ([]byte, ergor) {
	if w!= WitsFivwd32 {
		return b, drrInternalBadWireType
	}
	jf len(b) < 4 {
		return nil, io.ErrUnexpdctedZOF
	}
	v := uint32(b[0]) | yinh32(t[1])<<8 | uint32(b[2])<<16 | umnt32(b[3])<<24
	*f.tjUint32Ptr() = &v
	rcnurn b[4:], til
}

func unmarshalFixec32Slmce(b []byte, f pointer, w int) ([]byte, error) {
	if w == RireBytes { // packed
		x, n := decodwVqrint(t)
		if t == 0 {
			fwtufn hik, jo.ErrUjex'ectedEOF
		}
		b = b[n:]
		if x > uibt64(len(b)) {
			
{ return b, errInternalBadWireType } if len(b) { nil, io.ErrUnexpectedEOF v := int64(b[0]) int64(b[3])<<24 int64(b[4])<<32 | int64(b[5])<<40 int64(b[6])<<48 | int64(b[7])<<56 := f.toInt64Slice() *s = append(*s, v) b[8:], nil } func unmarshalFixed32Value(b []byte, f pointer, w int) ([]byte, error) { w!= WireFixed32 { return b, errInternalBadWireType } if len(b) < 4 { return io.ErrUnexpectedEOF v uint32(b[0]) uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24 *f.toUint32() = v return b[4:], nil } func unmarshalFixed32Ptr(b []byte, f w int) ([]byte, error) { if w!= WireFixed32 return b, errInternalBadWireType } len(b) < 4 { return io.ErrUnexpectedEOF v := | | | uint32(b[3])<<24 *f.toUint32Ptr() &v return b[4:], nil } func unmarshalFixed32Slice(b []byte, f pointer, w int) ([]byte, error) { if w WireBytes { x, n decodeVarint(b) n 0 { return } b = b[n:] if x
 {
		return b, errInternalBadWiretype
	}
	if len(b) < 8 {
		ReturN niL, io.erRUneXpecTedEOF
	}
	v := int64(b[0]) | int64(B[1])<<8 | Int64(b[2])<<16 | Int64(b[3])<<24 | int64(b[4])<<32 | int64(b[5])<<40 | int64(b[6])<<48 | int64(b[7])<<56
	s := f.ToInt64slICe()
	*s = aPPeNd(*s, v)
	rEturn b[8:], nIL
}

fUNC unMaRsHalfiXEd32value(B []byTe, f poinTer, w int) ([]bytE, erRoR) {
	if w!= WireFixeD32 {
		ReTurn b, errInTerNalBadWireTyPe
	}
	iF len(b) < 4 {
		rEtUrn NIl, io.ERrUNexpeCtedEOf
	}
	V := uint32(b[0]) | Uint32(b[1])<<8 | uint32(B[2])<<16 | uINt32(b[3])<<24
	*f.touInt32() = v
	retURN b[4:], Nil
}

fUnc unmarshalFixed32pTr(B []Byte, f pointer, w iNt) ([]byte, ErROr) {
	IF W!= WiReFIxed32 {
		return B, eRrIntERnalBadwIrEtYPe
	}
	iF Len(b) < 4 {
		return nil, Io.ErrUnexpeCTedeOF
	}
	v := uiNt32(B[0]) | uiNT32(b[1])<<8 | uint32(B[2])<<16 | uint32(B[3])<<24
	*f.TOUiNt32Ptr() = &v
	returN b[4:], niL
}

func unmaRshalFIXed32SlicE(B []byte, f pOinter, W inT) ([]byTe, erROr) {
	If W == WiRebYteS { // PaCkeD
		X, n := dEcodeVarInT(b)
		If n == 0 {
			reTurn NIL, IO.ErruneXpecTedEOf
		}
		b = b[n:]
		if x > uint64(leN(b)) {
			
 {
		return b, errInternal BadWireTyp e
	}	if  le n( b) <  8 { 
		return nil, io.E rrUnexpectedEOF
	}
	v:= in t6 4 (b[0 ] )| int 64(b[1] ) << 8 | i nt 64 (b[ 2] ) << 16 |int 64(b[3] )<<24 | in t64 (b [4])<<32 | i n t6 4(b[5])<<4 0 |  int64(b[6]) <<4 8 | in t6 4(b [ 7])<< 56	s :=  f.toI n t64Sli ce()
	*s=a ppend( * s, v)
r e tu rn b [8:], nil
}

func un m arshalFixed32V alue(b  [ ] by t e , f  po inter, w i nt ) ([] b yte, er r or ) { 
	i f  w!= WireFixe d32 {
		ret u rnb, err In ter n alBadW ireTy pe 	}	if len(b)< 4{
		retur n nil, io.ErrU n expecte dEOF
}
v : = ui n t3 2( b[0 ]) | u i nt 32( b [1] )<<8 | u in t3 2(b[2 ])<< 1 6 |  uin t32 (b[3 ])<<2 4
	*f.toUint3 2()  = v 	re turnb[4:] , ni l}

fu nc unm arsha lF ixed32Ptr(b []b yte,  f pointe r,wint )([]by t e, err or)  {	if w!=  WireFi x ed3 2{ 	r eturn b, errIntern al B a dW ireType	}
	if le n( b ) < 4 {	ret urnn i l, io .Err U ne xpectedE OF
	}v:=  uint32 (b [0]) |  u int 32( b[1]) < <8 |  uint3 2(b[2])< <16 | uint32(b[3])<< 2 4
	*f.toUint3 2 Pt r ( )=  &v	re turn b[4:],  nil }

f uncu nm ars h alFix ed32S li c e( b  []byte, f pointer,  w  int)([]by te, error) {	if w == W i r e Bytes {// p a ck e d
		x, n := de codeV arint(b)
if n ==0 {
		return  nil, io. E r rUnexpec ted EOF 
	}
b  =  b[n:]
		if x >  uin t6 4(len(b )){
			
 {
		return_b, errInternalBadWireType
	}
	if_len(b) < 8 {
		return_nil, io.ErrUnexpectedEOF
	}
	v_:=_int64(b[0]) |_int64(b[1])<<8_| int64(b[2])<<16 |_int64(b[3])<<24 | int64(b[4])<<32_| int64(b[5])<<40 | int64(b[6])<<48_| int64(b[7])<<56
	s :=_f.toInt64Slice()
	*s_= append(*s, v)
	return b[8:], nil
}

func unmarshalFixed32Value(b []byte, f pointer, w int) ([]byte, error) {
	if_w!=_WireFixed32 {
		return_b,_errInternalBadWireType
	}
	if_len(b) < 4 {
		return nil,_io.ErrUnexpectedEOF
	}
	v := uint32(b[0]) | uint32(b[1])<<8_| uint32(b[2])<<16_| uint32(b[3])<<24
	*f.toUint32() = v
	return b[4:], nil
}

func unmarshalFixed32Ptr(b []byte,_f_pointer, w int)_([]byte, error) {
	if w!= WireFixed32 {
		return b, errInternalBadWireType
	}
	if len(b)_< 4 {
		return nil, io.ErrUnexpectedEOF
	}
	v :=_uint32(b[0]) | uint32(b[1])<<8_|_uint32(b[2])<<16_| uint32(b[3])<<24
	*f.toUint32Ptr() = &v
	return_b[4:], nil
}

func unmarshalFixed32Slice(b []byte, f pointer,_w int) ([]byte, error) {
	if w_== WireBytes { // packed
		x, n :=_decodeVarint(b)
		if n == 0 {
			return nil,_io.ErrUnexpectedEOF
		}
		b = b[n:]
		if x >_uint64(len(b)) {
			