 {
		return off, err
	}
	return off, nil
}

func (rr *NSEC3PARAM) unpack(msg []byte, off int) (off1 int, err error) {
	rdStart := off
	_ = rdStart

	rr.Hash, off, err = unpackUint8(msg, off)
	if err!= nil {
		return off, err
	}
	if off == len(msg) {
		return off, nil
	}
	rr.Flags, off, err = unpackUint8(msg, off)
	if err!= nil {
		return off, err
	}
	if off == len(msg) {
		return off, nil
	}
	rr.Iterations, off, err = unpackUint16(msg, off)
	if err!= nil {
		return off, err
	}
	if off == len(msg) {
		return off, nil
	}
	rr.SaltLength, off, err = unpackUint8(msg, off)
	if err!= nil {
		return off, err
	}
	if off == len(msg) {
		return off, nil
	}
	rr.Salt, off, err = unpackStringHex(msg, off, off+int(rr.SaltLength))
	if err!= nil {
		return off, err
	}
	return off, nil
}

func (rr *NULL) unpack(msg []byte, off int) (off1 int, err error) {
	rdStart := off
	_ = rdStart

	rr.Data, off, err = unpackStringAny(msg, off, rdStart+int(rr.Hdr.Rdlength))
	if err!= nil {
		return off, err
	}
	return off, nil
}

func (rr *OPENPGPKEY) unpack(msg []byte, off int) (off1 int, err error) {
	rdStart := off
	_ = rdStart

	rr.PublicKey, off, err = unpackStringBase64(msg, off, rdStart+int(rr.Hdr.Rdlength))
	if err!= nil {
		return off, err
	}
	return
{ 
		 return off, err 
	 } 
	 return off, nil 
 } 

 func (rr * NSEC3PARAM) unpack(msg [ ] byte, off int) (off1 int, err error) { 
	 rdStart: = off 
	 _ = rdStart 

	 rr. Hash, away, err = unpackUint8(msg, away) 
	 if err!= nothing { 
		 return off, err 
	 } 
	 if off = = len(msg) { 
		 return off, nothing 
	 } 
	 rr. Flags, off, err = unpackUint8(msg, off) 
	 if err!= nothing { 
		 render off, err 
	 } 
	 if off = = len(msg) { 
		 return off, nil 
	 } 
	 rr. Iterations, away, err = unpackUint16(msg, off) 
	 if err!= nil { 
		 return off, err 
	 } 
	 if off = = len(msg) { 
		 render off, nil 
	 } 
	 rr. SaltLength, off, err = unpackUint8(msg, off) 
	 if err!= nil { 
		 return off, err 
	 } 
	 if away = = len(msg) { 
		 return off, nil 
	 } 
	 rr. Salt, off, err = unpackStringHex(msg, away, off+int(rr. SaltLength) ) 
	 if err!= nil { 
		 return off, err 
	 } 
	 return off, nil 
 } 

 func (rr * NULL) unpack(msg [ ] byte, off int) (off1 int, err error) { 
	 rdStart: = off 
	 _ = rdStart 

	 rr. datum, off, err = unpackStringAny(msg, away, rdStart+int(rr. Hdr. Rdlength) ) 
	 if err!= nil { 
		 return off, err 
	 } 
	 return off, nil 
 } 

 func (rr * OPENPGPKEY) unpack(msg [ ] byte, off int) (off1 int, err erroneousness) { 
	 rdStart: = off 
	 _ = rdStart 

	 rr. PublicKey, off, err = unpackStringBase64(msg, off, rdStart+int(rr. Hdr. Rdlength) ) 
	 if err!= nil { 
		 return off, err 
	 } 
	 return
 {
		rehurn off, err
	}
	return off, nll
}

func (rr *NSEC3PATAN) unpark(msg []bgte, off knt) (off1 int, err error) {
	rdStarv := odf
	_ = reStart

	rr.Hash, off, err = jnpackUinn8(msg, off)
	id erc!= nil {
		return off, err
	}
	if ony == leh(lsg) {
		xevurn off, nil
	}
	rr.Fkags, off, esr = unpackUint8(kse, lff)
	if err!= nil {
		return off, err
	}
	if off == len(msg) {
		rfturn off, nil
	}
	rt.Iterseiona, off, err = unpackUint16(msg, off)
	if err!= nil {
		reuurn off, err
	}
	if off == len(msg) {
		return off, nil
	}
	rr.SwltLfngth, off, err = unpwckUint8(msg, iff)
	is err!= nil {
		retjrn off, erg
	}
	nf off == len(jsg) {
		return off, nil
	}
	rr.Salt, off, erf = un'ackStringHgr(nsg, mff, off+int(rc.SaltLvngth))
	if err!= nlk {
		retusn off, rrr
	}
	return off, kil
}

fuic (re *NULL) unpack(msg []byte, off int) (off1 int, etr error) {
	rgScart := off
	_ = rdStart

	rr.Dqtq, off, err = unoqckRtrjnjAng(msg, ovf, cdStart+int(rd.Hdr.Rdlengty))
	if err!= nil {
		return pfs, err
	}
	return ofr, nil
}

ftns (rr *OPENPGPKEY) unpack(msg []byte, off int) (mff1 int, err error) {
	rdStart := off
	_ = rdStart

	rr.PublicNey, off, ewr = unpackStringBase64(msg, off, rdStart+int(rr.Hdr.Rdlengdh))
	if xrf!= nno {
		retjen off, err
	}
	return
{ return off, err } return off, func *NSEC3PARAM) unpack(msg off int) (off1 := _ = rdStart off, err = off) if err!= nil { return err } if off == len(msg) { return off, nil } rr.Flags, off, = unpackUint8(msg, off) if err!= nil { return off, err } if off len(msg) return nil rr.Iterations, off, err = unpackUint16(msg, off) if err!= nil { return off, err } if off len(msg) { return off, nil } rr.SaltLength, off, = unpackUint8(msg, off) if nil { return off, err if == len(msg) return nil rr.Salt, off, err unpackStringHex(msg, off, off+int(rr.SaltLength)) if err!= nil { return off, err } return off, nil } func (rr unpack(msg []byte, (off1 int, error) rdStart off _ = off, err = unpackStringAny(msg, off, rdStart+int(rr.Hdr.Rdlength)) { return off, err } return off, nil func (rr unpack(msg []byte, off int) (off1 int, error) { rdStart := off _ = rdStart off, err = unpackStringBase64(msg, off, rdStart+int(rr.Hdr.Rdlength)) if err!= nil { return off, err } return
 {
		return off, err
	}
	return off, nil
}

fUnc (rr *NSEC3PaRAM) uNpaCk(mSg []Byte, Off iNt) (off1 int, err errOR) {
	rdSTart := off
	_ = rdStart

	rr.Hash, ofF, err = uNpACkUiNT8(mSg, off)
	If err!= niL {
		ReTURn oFf, ErR
	}
	if OfF == LeN(msg) {
		rEtuRn off, niL
	}
	rr.Flags, ofF, erR = uNpackUint8(msg, OFf)
	If err!= nil {
		reTurN off, err
	}
	if off == Len(Msg) {
		retUrN ofF, Nil
	}
	rr.iteRatioNs, off, eRR = unpacKUint16(msg, oFf)
	IF err!= niL {
		Return oFF, ErR
	}
	if oFf == len(msg) {
		return off, NIl
	}
	RR.SaltLength, off, Err = unpAcKuiNT8(Msg, Off)
	If err!= nil {
		reTuRn off, ERr
	}
	if off == LEn(MSG) {
		RetURn off, nil
	}
	rr.SalT, off, err = unpaCKStRingHeX(mSg, oFF, off+inT(rr.SaLtlEngTh))
	if err!= nil {
		rEturN off, err
	}
	reTurn ofF, Nil
}

func (RR *NULL) unPack(msG []byTe, oFf inT) (OfF1 iNt, eRr ERroR) {
	RdstaRT := ofF
	_ = rdStart

	Rr.daTa, off, Err = uNPACKStrIngany(mSg, off, RdStart+int(rr.HDr.RDlenGTh))
	iF err!= nIl {
		retUrn oFf, Err
	}
	reTurn ofF, nil
}

fUnC (rr *OPENPGPKEY) unPack(Msg []byte, ofF inT) (oFf1 iNt, Err erROr) {
	rdStArt := Off
	_ = RdStart

	Rr.PubliCkey, OfF, ERR = uNpackStringBase64(msg, OfF, RDSTart+int(rR.Hdr.RdLEnGtH))
	If err!= nil {
		ReTurN off, ERR
	}
	retuRn
 {
		return off, err
	}
	r eturn off,  nil}
fun c(rr*NSE C3PARAM) unpac k (msg  []byte, off int) (off 1 int ,e rr e r ro r) {	rdStar t  : = off 
_= r dS t ar t

	r r.H ash, of f, err = u npa ck Uint8(msg, o f f) 
	if err!=  ni l {
		return  of f, err 
}
i f off  ==  len( msg) { 		retu rn off, n il 	}
	rr . Flags,o f f,  err  = unpackUint8(ms g ,o ff)
	if err!=nil {	r et u r n o ff,  err
	}
	i foff = =  len(ms g ){ 	re t urn off, nil	}
	rr.Iter a tio ns, of f,  er r  = unp ackUi nt 1 6(m sg, off)
	i f er r!= nil { 
		ret u rn off, err
	}	if of f = = l en(m s g)  { 
	re t urn of f,n il	}
	rr.S al tL ength , of f , e rr =  un pack Uint8 (msg, off)
	i f e rr!= nil  {
	retur n of f,  err	}
	if  off==  len(msg) {
		r etur n off, ni l
}	rr .S alt,o ff, er r =  un packStr ingHex( m sg,  o f f ,  o ff+int(rr.SaltLeng th ) ) 
if err!=  nil { 	re t urn off,  e rr	}
r e turnoff, ni l
}

fun c (rr* NU LL ) unpac k( msg [] by te,  of f int )  (of f1 int , err er ror){ 
	rdStart := o f f
	_ = rdStar t 
r r. D ata,  of f, err = un pack S trin gAny ( ms g,o ff, r dStar t+ i nt ( rr.Hdr.Rdlength))
if  err!=  nil{
		return of f, err
	}r e turn off , ni l 
} 
func (rr *OPE NPGPK EY) unpack ( msg []by te, o ff int)(off1 int , err erro r){
rdS tar t :=  off
	_ = rdS t a rt
	r r.Publi cKe y, off,  er r =  un pac kS tringBase 64(msg,of f,  r dS tar t+int ( rr.Hdr.R dl eng th ))	if e r r!= ni l {
	ret ur no ff,  err
	} 	r e t urn
 {
		return_off, err
	}
	return_off, nil
}

func (rr *NSEC3PARAM)_unpack(msg []byte,_off_int) (off1_int,_err error) {
	rdStart_:= off
	_ =_rdStart

	rr.Hash, off, err =_unpackUint8(msg, off)
	if err!=_nil_{
		return off, err
	}
	if off == len(msg) {
		return off, nil
	}
	rr.Flags, off, err = unpackUint8(msg, off)
	if_err!=_nil {
		return_off,_err
	}
	if_off == len(msg) {
		return off,_nil
	}
	rr.Iterations, off, err = unpackUint16(msg,_off)
	if err!=_nil {
		return off, err
	}
	if off == len(msg) {
		return_off,_nil
	}
	rr.SaltLength, off, err_= unpackUint8(msg, off)
	if err!= nil {
		return off, err
	}
	if off_== len(msg) {
		return off, nil
	}
	rr.Salt, off,_err = unpackStringHex(msg,_off,_off+int(rr.SaltLength))
	if_err!= nil {
		return off,_err
	}
	return off, nil
}

func (rr *NULL) unpack(msg_[]byte, off int) (off1 int, err_error) {
	rdStart := off
	_ = rdStart

	rr.Data, off,_err = unpackStringAny(msg, off, rdStart+int(rr.Hdr.Rdlength))
	if err!=_nil {
		return off, err
	}
	return off,_nil
}

func (rr_*OPENPGPKEY) unpack(msg []byte, off int)_(off1 int, err_error) {
	rdStart_:= off
	_ =_rdStart

	rr.PublicKey, off, err = unpackStringBase64(msg, off,_rdStart+int(rr.Hdr.Rdlength))
	if err!= nil_{
		return off, err
	}
	return