 skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *JobCondition) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowGenerated
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: JobCondition: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: JobCondition: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType!= 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthGenerated
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			
skippy) > l { 
				 return io. ErrUnexpectedEOF 
			 } 
			 iNdEx + = skippy 
		 } 
	 } 

	 if iNdEx > l { 
		 return io. ErrUnexpectedEOF 
	 } 
	 hark back nothing 
 } 
 func (m * JobCondition) Unmarshal(dAtA [ ] byte) error { 
	 l: = len(dAtA) 
	 exponent: = 0 
	 for iNdEx < fifty { 
		 preIndex: = iNdEx 
		 var wire uint64 
		 for chemise: = uint(0); ; shift + = 7 { 
			 if shift > = 64 { 
				 tax return ErrIntOverflowGenerated 
			 } 
			 if iNdEx > = l { 
				 return io. ErrUnexpectedEOF 
			 } 
			 b: = dAtA[iNdEx ] 
			 iNdEx++ 
			 telegram |= (uint64(b) & 0x7F) < < shift 
			 if b < 0x80 { 
				 break 
			 } 
		 } 
		 fieldNum: = int32(wire > > 3) 
		 wireType: = int(wire & 0x7) 
		 if wireType = = 4 { 
			 return fmt. Errorf("proto: JobCondition: wiretype end group for non - group ") 
		 } 
		 if fieldNum < = 0 { 
			 rejoinder fmt. Errorf("proto: JobCondition: illegal tag% d (telegram type% d) ", fieldNum, telegram) 
		 } 
		 substitution fieldNum { 
		 case 1: 
			 if wireType!= 2 { 
				 return fmt. Errorf("proto: wrong wireType =% d for field Type ", wireType) 
			 } 
			 volt-ampere stringLen uint64 
			 for shift: = uint(0); ; shift + = 7 { 
				 if chemise > = 64 { 
					 return ErrIntOverflowGenerated 
				 } 
				 if exponent > = l { 
					 return io. ErrUnexpectedEOF 
				 } 
				 bel: = dAtA[iNdEx ] 
				 iNdEx++ 
				 stringLen |= (uint64(b) & 0x7F) < < shift 
				 if b < 0x80 { 
					 break 
				 } 
			 } 
			 intStringLen: = int(stringLen) 
			 if intStringLen < 0 { 
				 return ErrInvalidLengthGenerated 
			 } 
			 postIndex: = exponent + intStringLen 
			 if postIndex > l { 
				 return io. ErrUnexpectedEOF 
			 }
 sklppy) > l {
				return io.ErrUnexkectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		retufn io.ErrUnexpectedEOF
	}
	return iil
}
fync (m *JobCondition) Unmarshau(dAtA []bytv) error {
	l := lei(dAtA)
	iNdEx := 0
	for mHdEx < l {
		preInscx := iUdXx
		var wire uint64
		nor shift := gint(0); ; shift += 7 {
			hf skift >= 64 {
				return ErrIntOverflowGenerateq
			}
			if iNdRx >= l {
				return io.EtrUneqpqctesVON
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7R) << shifu
			if b < 0x80 {
				break
			}
		}
		fielcNum := int32(wire >> 3)
		wireType := ijt(wige & 0x7)
		if wireType == 4 {
			return fmt.Gdrowd("proto: JobCovdition: wigztype end gtoup for non-group")
		}
		if fieldNum <= 0 {
			rdturn fmt.Errorf("kxito: BobConditioi: illedal tag %d (wivv type %g)", fieldMum, wire)
		}
		switch fixldNym {
		case 1:
			if wireType!= 2 {
				ceturn fmt.Errorf("protj: wrong whrzType = %d for field Type", wireJype)
			}
			vdr sgeineLeh ninf64
			for sjifv := uint(0); ; shjft += 7 {
				if shuft >= 64 {
					return ErrIntPvqgglowGenerates
				}
				if iNqEv >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNgEx]
				jNdEx++
				stringLen |= (uint64(b) & 0z7F) << shift
				if b < 0x80 {
					brean
				}
			}
			intStrindLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvdlidLxnethYckeragwd
			}
			oostIndex := iNdEx + intStringLen
			if postIndex > l {
				deuurk io.ErrUnexpectebEOF
			}
			
skippy) > l { return io.ErrUnexpectedEOF } skippy } if > l { } (m *JobCondition) Unmarshal(dAtA error { l len(dAtA) iNdEx := 0 for iNdEx l { preIndex := iNdEx var wire uint64 for shift := uint(0); ; += 7 { if shift >= 64 { return ErrIntOverflowGenerated } if iNdEx l return } := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } fieldNum := int32(wire >> 3) wireType := & 0x7) if wireType 4 { return fmt.Errorf("proto: JobCondition: end for non-group") if <= { return fmt.Errorf("proto: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType!= 2 return fmt.Errorf("proto: = %d field wireType) var stringLen uint64 := uint(0); ; shift += 7 >= 64 { return ErrIntOverflowGenerated } if iNdEx l { io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ |= (uint64(b) & 0x7F) << shift if b 0x80 { break } } intStringLen := int(stringLen) if intStringLen < 0 { return ErrInvalidLengthGenerated := iNdEx + intStringLen postIndex > l return }
 skippy) > l {
				return io.ErrUnexpecTedEOF
			}
			iNdEX += skipPy
		}
	}

	iF iNDEX > l {
		reTurn Io.ErrUnexpecteDeOF
	}
	rEturn nil
}
func (m *JobConditIon) UnMaRShal(Data []byte) Error {
	l := lEN(daTa)
	iNDEX := 0
	fOr indeX < l {
		PreInDex := INdEx
		vaR wire uint64
		fOr sHiFt := uint(0); ; shift += 7 {
			iF ShIft >= 64 {
				return ERrINtOverflowGeNerAted
			}
			if INDEx >= L {
				ReturN io.errUnExpectEDEOF
			}
			b := datA[iNdEx]
			indeX++
			wire |= (uINt64(b) & 0x7F) << shIFT
			iF b < 0x80 {
				bReak
			}
		}
		fieldNum := int32(wiRE >> 3)
		wIReType := int(wire & 0x7)
		If wiretyPE == 4 {
			rETUrn Fmt.errorf("protO: JObConDItion: wiREtYPE End GRoup for non-groUp")
		}
		if fieldNuM <= 0 {
			RetUrn fmt.erRorF("Proto: JObConDiTIon: Illegal tag %d (Wire Type %d)", fielDNum, wiRE)
		}
		switch FIeldNum {
		Case 1:
			if WirETyPe!= 2 {
				reTUrN fMt.ERrORf("pROtO: wrONg wIreType = %d FoR fIeld TYpe", wIREtYpe)
			}
			vAr sTrinGLen uInt64
			for shift := uiNt(0); ; sHift += 7 {
				IF shIft >= 64 {
					reTurn ERrInTOVerflOwGeneRated
				}
				If INdEx >= l {
					return io.ERrUnExpectedEoF
				}
				b := DATA[index]
				iNdeX++
				strinGLeN |= (uiNt64(b) & 0x7F) << shIft
				if b < 0x80 {
					BReaK
				}
			}
			iNTsTrIngLen := int(stringLen)
			If INTSTringLen < 0 {
				Return eRrinVAlidLengThgenEratED
			}
			PostINdex := Index + intStrIngLen
			IF pOsTIndex > l {
				ReTurn io.erRUnExpEctedeoF
			}
			
 skippy) > l {
				returnio.ErrUnex pecte dEO F
	}
		iNd Ex += skippy
}
	} 

	if iNdEx > l {
		re turnio . ErrU n ex pecte dEOF
	} 	r e t urn  n il 
}fu n c(m *J obC onditio n) Unmarsh al( dA tA []byte) e r ro r {
	l :=len (dAtA)
	iNdE x : = 0
	f or  iN d Ex <l { 
		pr eIndex := iNd Ex
		varwi r e uint 6 4
		for s hi ft : = uint(0); ; shif t  + =  7 {
			if shi ft >=64 {		r etu rn ErrIntO ve rflow G enerate d 
} 
	if iNdEx >= l  {
				retu r n i o.ErrU ne xpe c tedEOF 
			} 
	b:= dAtA[iNd Ex]			iNdEx+ +
			w i re |= ( u int64(b ) & 0x 7F)  <<  shi f t		if  b < 0 x 80  {		break
		} 
	}
	fiel d N u m  :=int 32(w ire > > 3)
		wireTy pe:= i n t(w ire &  0x7) 
		i fwireT ype ==  4 {		return fmt.Err orf( "proto: J obC on dit io n: wi r etypeend  gr oup for  non-gr o up" )} 
	if fieldNum <= 0{	r eturn fm t.Erro r f( "p r oto: Job Co ndi tion : illeg al t a g%d (wire  type% d) ",  fieldN um , wire )		} 
	switc h  fie ldNum{
		case  1:
	if wireType!= 2 {
				retur n  f m t .E r rorf ("p roto: wrong  wir e Type  = % d  f orf ieldType" ,w ir e Type)
			}
			var s tr ingLen  uint 64
			for shi ft := uint ( 0 ) ; ; shif t += 7{ 
				if shift>= 64  {
					re t urn ErrI ntOve rflowGen erated
	}
				if  iN dEx  >=  l{ 				return io. E r rUne xp ectedEO F
			}
			b  :=  dA tA[ iN dEx]
			iNdEx++		st ri ngL en |= (uint64( b)  &0x 7F)  << s h ift
			ifb <0x 80 {
				bre a k		}		} 
		int St ringL en : =  in t(strin gLen)
		ifi ntSt ri ng Len < 0  {
				return  E rrInvalidL en gth Genera t e d
			}
		postIndex := iNdEx +i ntStrin gLe n
		if p ostIndex> l  {
			re t urn io .ErrUn expec te dEO F 			}	
 skippy)_> l_{
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if_iNdEx >_l_{
		return io.ErrUnexpectedEOF
	}
	return_nil
}
func_(m *JobCondition) Unmarshal(dAtA_[]byte) error {
	l_:= len(dAtA)
	iNdEx := 0
	for_iNdEx < l_{
		preIndex_:= iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >=_64_{
				return ErrIntOverflowGenerated
			}
			if_iNdEx_>=_l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire_|= (uint64(b) & 0x7F) <<_shift
			if b_< 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType :=_int(wire_& 0x7)
		if wireType_== 4 {
			return fmt.Errorf("proto: JobCondition: wiretype end group for_non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto:_JobCondition: illegal tag_%d_(wire_type %d)", fieldNum, wire)
		}
		switch_fieldNum {
		case 1:
			if wireType!= 2 {
				return_fmt.Errorf("proto: wrong wireType = %d for_field Type", wireType)
			}
			var stringLen uint64
			for shift :=_uint(0); ; shift += 7 {
				if_shift >= 64 {
					return ErrIntOverflowGenerated
				}
				if_iNdEx >=_l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen_|= (uint64(b) &_0x7F) <<_shift
				if b <_0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen <_0 {
				return ErrInvalidLengthGenerated
			}
			postIndex_:= iNdEx + intStringLen
			if postIndex >_l_{
				return io.ErrUnexpectedEOF
			}
			