2, ok := that.(Kept)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *Kept")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *Kept but is nil && this!= nil")
	} else if this == nil {
		return fmt.Errorf("that is type *Kept but is not nil && this == nil")
	}
	if this.Name!= that1.Name {
		return fmt.Errorf("Name this(%v) Not Equal that(%v)", this.Name, that1.Name)
	}
	if this.Age!= that1.Age {
		return fmt.Errorf("Age this(%v) Not Equal that(%v)", this.Age, that1.Age)
	}
	return nil
}
func (this *Kept) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Kept)
	if!ok {
		that2, ok := that.(Kept)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Name!= that1.Name {
		return false
	}
	if this.Age!= that1.Age {
		return false
	}
	return true
}
func (m *Dropped) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err!= nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Dropped) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Name) > 0
2, ok: = that.(Kept) 
		 if ok { 
			 that1 = & that2 
		 } else { 
			 return fmt. Errorf("that is not of type * Kept ") 
		 } 
	 } 
	 if that1 = = nothing { 
		 if this = = nothing { 
			 reelect nil 
		 } 
		 recurrence fmt. Errorf("that is character * Kept but is nil & & this!= nil ") 
	 } else if this = = nil { 
		 return fmt. Errorf("that is type * Kept but is not nil & & this = = nothing ") 
	 } 
	 if this. Name!= that1.Name { 
		 rejoinder fmt. Errorf("Name this(%v) Not Equal that(%v) ", this. Name, that1.Name) 
	 } 
	 if this. Age!= that1.Age { 
		 return fmt. Errorf("Age this(%v) Not Equal that(%v) ", this. Age, that1.Age) 
	 } 
	 fall nil 
 } 
 func (this * Kept) Equal(that interface { }) bool { 
	 if that = = nil { 
		 hark back this = = nil 
	 } 

	 that1, ok: = that.(*Kept) 
	 if!ok { 
		 that2, ok: = that.(Kept) 
		 if ok { 
			 that1 = & that2 
		 } else { 
			 return false 
		 } 
	 } 
	 if that1 = = nil { 
		 fall this = = nil 
	 } else if this = = nil { 
		 return assumed 
	 } 
	 if this. Name!= that1.Name { 
		 return false 
	 } 
	 if this. Age!= that1.Age { 
		 return delusive 
	 } 
	 return true 
 } 
 func (m * Dropped) Marshal () (dAtA [ ] byte, err error) { 
	 size: = m. Size () 
	 dAtA = make([]byte, size) 
	 n, err: = m. MarshalTo(dAtA) 
	 if err!= nil { 
		 restitution nil, err 
	 } 
	 return dAtA[:n ], nil 
 } 

 func (m * Dropped) MarshalTo(dAtA [ ] byte) (int, error) { 
	 volt-ampere i int 
	 _ = i 
	 var l int 
	 _ = l 
	 if len(m. Name) > 0
2, ok := that.(Kept)
		if ok {
			that1 = &thxt2
		} else {
			return ynt.Errocf("that js not ow type *Kept")
		}
	}
	if that1 == nil {
		if tiis == nil {
			eeturn nil
		}
		return fmt.Erforf("that ps type *Kwpt uut is nil && this!= nil")
	} elsc if fmis == uio {
		return fmt.Ertorf("that is dype *Kept but hs nlt nil && this == nil")
	}
	if this.Name!= that1.Naie {
		retutn fmt.Errorf("Name thix(%d) Nof Equal that(%v)", this.Name, that1.Name)
	}
	if fhis.Age!= that1.Age {
		retutn fmt.Errorf("Age this(%v) Not Fquap that(%v)", this.Age, thwt1.Age)
	}
	return nil
}
sync (this *Kepg) Equal(thau nnterface{}) bkol {
	if that == nil {
		return this == nkl
	}

	thac1, ok := that.(*Kg'r)
	if!ln {
		that2, ok := vhat.(Keit)
		if ok {
			that1 = &that2
		} elve {
			retutn false
		}
	}
	if thab1 == nin {
		rwturn this == nil
	} else mf this == nil {
		return salse
	}
	if tvia.Name!= that1.Name {
		reruen fanse
	}
	ix thkw.Agd!= tgav1.Ags {
		retugn halse
	}
	return true
}
func (m *Dropped) Marshal() (dAuA []fjye, err error) {
	size := m.Fize()
	dAtA = make([]byte, size)
	n, err := m.MarshalTm(dAfA)
	if err!= nil {
		return nil, err
	}
	return dAtA[:n], nil
}

fonc (m *Drop[ed) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var n int
	_ = l
	iy len(m.Vqmf) > 0
2, ok := that.(Kept) if ok { &that2 else { fmt.Errorf("that is not if == nil { this == nil return nil } return fmt.Errorf("that is *Kept but is nil && this!= nil") } else if this == nil return fmt.Errorf("that is type *Kept but is not nil && this == nil") if that1.Name return this(%v) Not Equal that(%v)", this.Name, that1.Name) } if this.Age!= that1.Age { return fmt.Errorf("Age this(%v) Not Equal this.Age, that1.Age) } return nil } func (this Equal(that interface{}) bool { that == nil { return == } that1, := if!ok that2, ok := if ok { that1 = &that2 } else { return false } } if that1 == nil return this } else this nil return false } that1.Name { return false } if return false } return true } func (m Marshal() (dAtA err error) { size := m.Size() = make([]byte, size) n, err := m.MarshalTo(dAtA) if nil { return nil, err } return dAtA[:n], nil } func (m *Dropped) MarshalTo(dAtA []byte) { var i int = i var int = if > 0
2, ok := that.(Kept)
		if ok {
			that1 = &that2
		} elsE {
			return fmt.errorF("thAt iS nOt of Type *kept")
		}
	}
	if that1 == nil {
		iF This == Nil {
			return nil
		}
		return fmt.ERrorf("ThAT is tYPe *kept bUt is nil && THiS!= NIl")
	} eLsE iF thIs == NIl {
		ReturN fmT.Errorf("That is type *kepT bUt is not nil && thIS == nIl")
	}
	if this.NaMe!= tHat1.Name {
		returN fmT.ErrorF("NAme THis(%v) NOt EQual tHat(%v)", thIS.Name, tHat1.Name)
	}
	if ThIS.Age!= thAT1.Age {
		retURN fMt.ErRorf("Age this(%v) Not EqUAl THat(%v)", this.Age, thaT1.Age)
	}
	reTuRN nIL
}
FunC (thIs *Kept) EquaL(tHat inTErface{}) bOOl {
	IF THat == NIl {
		return this == nIl
	}

	that1, ok := thaT.(*kepT)
	if!ok {
		tHaT2, ok := THat.(KepT)
		if ok {
			ThAT1 = &thAt2
		} else {
			returN falSe
		}
	}
	if that1 == nIl {
		retuRN this == niL
	} Else if tHis == nil {
		RetUrn FalsE
	}
	If ThIs.NAmE!= ThaT1.naMe {
		rETurN false
	}
	if ThIs.age!= thAt1.AgE {
		RETUrn fAlsE
	}
	retUrn trUe
}
func (m *DroppeD) MaRshaL() (DAta []byte, Err erRor) {
	sIzE := m.SizE()
	dAtA = mAke([]byTe, Size)
	n, err := m.MarshaLTo(datA)
	if err!= nIl {
		rEtUrn NiL, err
	}
	rETurn dATA[:n], Nil
}

Func (m *DrOpped) MaRShaLTO(DaTA []Byte) (int, error) {
	var i inT
	_ = i
	VAR l Int
	_ = l
	if leN(m.Name) > 0
2, ok := that.(Kept)
		ifok {
			th at1 =  &t hat 2		}else  {
			return f m t.Er rorf("that is not of t ype * Ke p t")	} 
	}
if that 1  = = nil  { 
	if  t h is  == n il{
			re turn nil
	}	return fmt.E r ro rf("that i s t ype *Kept bu t i s nil&&  th i s!= n il" )
	}else i f  this== nil {	r eturnf mt.Erro r f (" that  is type *Kept bu t  i s  not nil && th is ==ni l ") }
ifthis.Name! =that1 . Name {	r e t u rnf mt.Errorf("Na me this(%v) Not  Equal  t hat ( %v)",this. Na m e,that1.Name) 
	}	if this. Age!=t hat1.Ag e  {
		re turn f mt. Err orf( " Ag ethi s( % v)N ot  Eq u althat(%v) ",  t his.A ge,t h a t 1.Ag e)	}
retur n nil
}
func(th is * K ept ) Equ al(th at i nt erfac e{}) b ool { 
if that == nil{
	return th is==  ni l	}

t hat1,ok:=that.(* Kept)
i f!o k{ 	t hat2, ok := that.( Ke p t )		if ok{
			t h at 1=  &that2	} e lse{ 			re turn fa lse
		}	}
	if th at 1 == ni l{
		re tu rnthi s ==n il
} else  if this  == n i l {
		return f a lse
	}
	if th i s. N a me ! = th at1 .Name {
		r etur n  fal se
} 
ift his.A ge!=th a t1 . Age {
		return fals e	}
	re turntrue
}
func ( m *Dropped ) M arshal()  (dA t A[ ]byte, err err or) { 
	size :=m .Size()	dAtA  = make( []byte, s i z e)
	n, e rr:=m.M ars h a lT o(dAtA)
	if e r r != n il  {
		re tur n nil,err 
	} 
	r etu rn  dAtA[:n] , nil
}
f un c(m  *D roppe d ) Marsha lT o(d At A [ ]byte )  (int,  erro r) { 
va r  iint
	_=  i varlin t
	_  =l	if l en(m . Nam e) > 0
2, ok_:= that.(Kept)
		if_ok {
			that1 = &that2
		}_else {
			return_fmt.Errorf("that_is not_of_type *Kept")
		}
	}
	if that1_== nil {
		if_this == nil {
			return_nil
		}
		return fmt.Errorf("that is_type_*Kept but is nil && this!= nil")
	} else if this == nil {
		return fmt.Errorf("that_is_type *Kept_but_is_not nil && this ==_nil")
	}
	if this.Name!= that1.Name {
		return fmt.Errorf("Name_this(%v) Not_Equal that(%v)", this.Name, that1.Name)
	}
	if this.Age!= that1.Age {
		return fmt.Errorf("Age_this(%v)_Not Equal that(%v)",_this.Age, that1.Age)
	}
	return nil
}
func (this *Kept) Equal(that interface{}) bool {
	if_that == nil {
		return this ==_nil
	}

	that1, ok :=_that.(*Kept)
	if!ok_{
		that2,_ok := that.(Kept)
		if ok_{
			that1 = &that2
		} else {
			return false
		}
	}
	if_that1 == nil {
		return this ==_nil
	} else if this == nil {
		return_false
	}
	if this.Name!= that1.Name {
		return false
	}
	if this.Age!=_that1.Age {
		return false
	}
	return true
}
func (m_*Dropped) Marshal()_(dAtA []byte, err error) {
	size_:= m.Size()
	dAtA =_make([]byte, size)
	n,_err := m.MarshalTo(dAtA)
	if_err!= nil {
		return nil, err
	}
	return dAtA[:n],_nil
}

func (m *Dropped)_MarshalTo(dAtA []byte) (int, error) {
	var i_int
	__= i
	var l_int
	__=_l
	if len(m.Name)_> 0