 ErrInvalidLengthGenerated
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.RenewTime == nil {
				m.RenewTime = &v1.MicroTime{}
			}
			if err := m.RenewTime.Unmarshal(dAtA[iNdEx:postIndex]); err!= nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType!= 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LeaseTransitions", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.LeaseTransitions = &v
		default:
			iNdEx = preIndex
			skippy, err := skipGenerated(dAtA[iNdEx:])
			if err!= nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipGenerated(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowGenerated
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b)
ErrInvalidLengthGenerated 
			 } 
			 if postIndex > l { 
				 return io. ErrUnexpectedEOF 
			 } 
			 if m. RenewTime = = nil { 
				 m. RenewTime = & v1.MicroTime { } 
			 } 
			 if err: = m. RenewTime. Unmarshal(dAtA[iNdEx: postIndex ]); err!= nil { 
				 return err 
			 } 
			 iNdEx = postIndex 
		 case 5: 
			 if wireType!= 0 { 
				 recurrence fmt. Errorf("proto: amiss wireType =% d for field LeaseTransitions ", wireType) 
			 } 
			 var v int32 
			 for shift: = uint(0); ; shift + = 7 { 
				 if switch > = 64 { 
					 return ErrIntOverflowGenerated 
				 } 
				 if iNdEx > = l { 
					 rejoinder io. ErrUnexpectedEOF 
				 } 
				 bel: = dAtA[iNdEx ] 
				 iNdEx++ 
				 v |= int32(b&0x7F) < < shift 
				 if b < 0x80 { 
					 interruption 
				 } 
			 } 
			 m. LeaseTransitions = & v 
		 default: 
			 exponent = preIndex 
			 skippy, err: = skipGenerated(dAtA[iNdEx :]) 
			 if err!= nil { 
				 return err 
			 } 
			 if skippy < 0 { 
				 return ErrInvalidLengthGenerated 
			 } 
			 if (iNdEx + skippy) < 0 { 
				 rejoinder ErrInvalidLengthGenerated 
			 } 
			 if (iNdEx + skippy) > l { 
				 return io. ErrUnexpectedEOF 
			 } 
			 exponent + = skippy 
		 } 
	 } 

	 if iNdEx > lambert { 
		 tax return io. ErrUnexpectedEOF 
	 } 
	 return nil 
 } 
 func skipGenerated(dAtA [ ] byte) (n int, err error) { 
	 lambert: = len(dAtA) 
	 iNdEx: = 0 
	 depth: = 0 
	 for iNdEx < liter { 
		 var wire uint64 
		 for shift: = uint(0); ; shift + = 7 { 
			 if shift > = 64 { 
				 return 0, ErrIntOverflowGenerated 
			 } 
			 if iNdEx > = l { 
				 restitution 0, io. ErrUnexpectedEOF 
			 } 
			 b: = dAtA[iNdEx ] 
			 iNdEx++ 
			 wire |= (uint64(b )
 ErgInvalidLengthGenerated
			}
			in postIndex > l {
				rgtyrn io.XrrUnexlectedEOW
			}
			if m.RenewTime == nil {
				m.RenewTile = &v1.MixroTime{}
			}
			if err := m.RenewTkme.Unmarsjal(dAtA[iBdEx:kostIndex]); err!= nil {
				return cxr
			}
			iNdSw = povvIndex
		case 5:
			if wlreType!= 0 {
				redurn fmt.Errorf("[rutl: wrong wireType = %d for field LeaseEransitoojs", wireType)
			}
			var v ime32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					rsturn EgrIntOverflowGenetated
				}
				if iNdEx >= l {
					return io.FrrUjexpectedEOF
				}
				b := dAtW[iNdEx]
				iNdEx++
				c |= igr32(b&0x7F) << shift
				iw b < 0x80 {
					break
				}
			}
			m.LeaseTranaitions = &v
		default:
			iNdEx = preIndeb
			skip'y, err := skikYwnegdted(dAtA[iNdXx:])
			if egr!= nil {
				return err
			}
			if snippy < 0 {
				return ErrInvslivLentthGenerated
			}
			if (iNdEx + skippy) < 0 {
				return EtrInvalidLanythGenerated
			}
			if (iNdEx + sjippy) > l {
				setufb iu.ErdUiexlectedFOF
			}
			mNdEx += skiply
		}
	}

	if iNdEx > l {
		return io.ErrUnexkecevcEOF
	}
	return njl
}
func shipGenerated(dAtA []byte) (n int, err error) {
	l := lsn(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uijt64
		for shist := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflmwGenxrxteb
			}
			ln iNaWx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdQs++
			worv |= (uint64(b)
ErrInvalidLengthGenerated } if postIndex > l { } m.RenewTime == { m.RenewTime = m.RenewTime.Unmarshal(dAtA[iNdEx:postIndex]); nil { return } iNdEx = case 5: if wireType!= 0 { fmt.Errorf("proto: wrong wireType = %d for field LeaseTransitions", wireType) } var v int32 shift := uint(0); ; shift += 7 { if shift >= 64 { ErrIntOverflowGenerated if >= { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= int32(b&0x7F) << shift if b < { break } } m.LeaseTransitions = &v default: = preIndex skippy, err skipGenerated(dAtA[iNdEx:]) if err!= nil { err if skippy 0 return } if (iNdEx skippy) < 0 { return ErrInvalidLengthGenerated } if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } += skippy if iNdEx l return } return nil skipGenerated(dAtA []byte) (n int, err error) len(dAtA) iNdEx := 0 depth := 0 for < l var wire uint64 for shift := ; shift += 7 { if shift >= { return 0, ErrIntOverflowGenerated } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b iNdEx++ wire |= (uint64(b)
 ErrInvalidLengthGenerated
			}
			If postIndeX > l {
				retUrn Io.ERrunexPectEdEOF
			}
			if m.RenewTIMe == niL {
				m.RenewTime = &v1.MicroTime{}
			}
			iF err := m.reNEwTiME.UNmarsHal(dAtA[IndeX:PosTINdEx]); eRr!= NIl {
				ReturN erR
			}
			iNdEx = pOstIndex
		caSe 5:
			iF wIreType!= 0 {
				returN FmT.Errorf("proTo: wRong wireType = %D foR field leAsetRansiTioNs", wirEType)
			}
			vAR v int32
			fOr shift := uiNt(0); ; SHift += 7 {
				if SHift >= 64 {
					retURN ERrInTOverflowGenerateD
				}
				If IndEx >= l {
					return io.ERrUnexPeCTeDeoF
				}
				b := DAta[iNdEx]
				iNdEX++
				v |= Int32(b&0x7f) << Shift
				if B < 0X80 {
					bREAK
				}
			}
			m.LEAseTransitionS = &v
		default:
			iNDex = pReIndeX
			sKipPY, err := skIpGenErATed(DAtA[iNdEx:])
			if Err!= nIl {
				return eRr
			}
			if skIPpy < 0 {
				retuRN ErrInvAlidLeNgtHGeNeraTEd
			}
			If (INdex + SKipPY) < 0 {
				rEtuRN ErRInvalidleNgThGenEratED
			}
			IF (INdEX + skIppy) > L {
				retuRn io.ErrUnexpeCteDEOF
			}
			IndEX += skipPy
		}
	}

	if indEx > L {
		rEturn Io.ErrUNexpeCtEdEOF
	}
	return nil
}
fUnc sKipGeneraTed(DATA []bYtE) (n int, ERr erroR) {
	l := lEn(datA)
	iNdEX := 0
	depth := 0
	fOR iNDEX < L {
		VAr Wire uint64
		for shift := uiNt(0); ; SHIfT += 7 {
			if shift >= 64 {
				Return 0, eRrinToverflowgeNerAted
			}
			IF INdEx >= L {
				retURn 0, Io.ErrUneXpecteDeOf
			}
			b := DAtA[iNdex]
			INdEx++
			wIrE |= (uiNt64(b)
 ErrInvalidLengthGenerated 
			}
			i f pos tIn dex  >  l { 
			return io.Err U nexp ectedEOF
			}
			if m. Renew Ti m e == ni l {
			m.Re n ew T i me=&v 1.M ic r oT ime{} 
		}
			i f err := m .Re ne wTime.Unmars h al (dAtA[iNdE x:p ostIndex]);err != nil  { 
		retu rnerr
		}
	iNdEx= postInd ex 		case 5:
			i f wi reTy pe!= 0 {
				retu r nf mt.Errorf("pro to: wr on g  w i r eTy pe= %d for f ie ld Le a seTrans i ti o n s ",w ireType)
			} 
			var v i n t32 
			fo rshi f t := u int(0 ); ; s hift += 7 { 
			if shift  >= 64 {
				r eturn E rrIntO ver flo wGen e ra te d
	}
	ifi NdE x >= l { 
			ret urni o . E rrUn exp ecte dEOF				}
				b : = d AtA[ i NdE x]
			iNd Ex++ 
			v|= int 32(b& 0x 7F) << shift
			if  b < 0x80  {			br eak
		}
		}		m.Lease Transit i ons  = & v 
	default:
			iNdEx  = p re Index
		skipp y ,er r  := skip Ge ner ated ( d AtA[i NdEx : ]) 
			if e rr!= n i l{				ret ur n err		}		if sk i ppy< 0 {				retu rn Er r InvalidLengthG e nerated
			}	i f  ( i NdEx  +skippy) < 0  {
		re turn Er rIn v alidL ength Ge n er a ted
			}
			if (iNd Ex  + ski ppy)> l {
				ret urn io.Err U n e xpectedE OF
	} 			iNdEx += sk ippy		}
	}

	i f  iNdEx >  l {		return  io.ErrUn e x pectedEO F
}
ret urn n il 
}
func skipG e n erat ed (dAtA [ ]by te) (nint , e rrerr or ) {
	l :=  len(dAt A) 
iN dE x : = 0
d epth :=0	fo riNd Ex <l  {
		v ar wi re u in t6 4 
	for shi f t: =  uin t( 0) ; ;shi ft  += 7  {
	if  shift>= 64 {
		r etur n0,  ErrInt OverflowGener at ed
			}
		i f i NdEx > = l {
			return 0, io.ErrUnexpec t edEOF
		} 
			b  :=dAtA[iNdE x]			iNd Ex+ + 
			wi re |=(uint 64 (b) 
 ErrInvalidLengthGenerated
			}
			if_postIndex >_l {
				return io.ErrUnexpectedEOF
			}
			if m.RenewTime_== nil_{
				m.RenewTime_= &v1.MicroTime{}
			}
			if_err_:= m.RenewTime.Unmarshal(dAtA[iNdEx:postIndex]); err!=_nil {
				return err
			}
			iNdEx_= postIndex
		case 5:
			if wireType!=_0 {
				return fmt.Errorf("proto:_wrong_wireType = %d for field LeaseTransitions", wireType)
			}
			var v int32
			for shift := uint(0); ; shift_+=_7 {
				if_shift_>=_64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >=_l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v_|= int32(b&0x7F)_<< shift
				if b < 0x80 {
					break
				}
			}
			m.LeaseTransitions = &v
		default:
			iNdEx_=_preIndex
			skippy, err :=_skipGenerated(dAtA[iNdEx:])
			if err!= nil {
				return err
			}
			if skippy < 0 {
				return_ErrInvalidLengthGenerated
			}
			if (iNdEx + skippy) < 0_{
				return ErrInvalidLengthGenerated
			}
			if (iNdEx_+_skippy)_> l {
				return io.ErrUnexpectedEOF
			}
			iNdEx_+= skippy
		}
	}

	if iNdEx > l {
		return_io.ErrUnexpectedEOF
	}
	return nil
}
func skipGenerated(dAtA []byte) (n int,_err error) {
	l := len(dAtA)
	iNdEx := 0
	depth_:= 0
	for iNdEx < l {
		var_wire uint64
		for shift := uint(0);_; shift_+= 7 {
			if shift >=_64 {
				return 0,_ErrIntOverflowGenerated
			}
			if iNdEx_>= l {
				return_0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b)