 a new origin set after the filename, if not use current one
			switch l, _ := zp.c.Next(); l.value {
			case zBlank:
				l, _ := zp.c.Next()
				if l.value == zString {
					name, ok := toAbsoluteName(l.token, zp.origin)
					if!ok {
						return zp.setParseError("bad origin name", l)
					}

					neworigin = name
				}
			case zNewline, zEOF:
				// Ok
			default:
				return zp.setParseError("garbage after $INCLUDE", l)
			}

			if!zp.includeAllowed {
				return zp.setParseError("$INCLUDE directive not allowed", l)
			}
			if zp.includeDepth >= maxIncludeDepth {
				return zp.setParseError("too deeply nested $INCLUDE", l)
			}

			// Start with the new file
			includePath := l.token
			if!filepath.IsAbs(includePath) {
				includePath = filepath.Join(filepath.Dir(zp.file), includePath)
			}

			r1, e1 := os.Open(includePath)
			if e1!= nil {
				var as string
				if!filepath.IsAbs(l.token) {
					as = fmt.Sprintf(" as `%s'", includePath)
				}

				msg := fmt.Sprintf("failed to open `%s'%s: %v", l.token, as, e1)
				return zp.setParseError(msg, l)
			}

			zp.sub = NewZoneParser(r1, neworigin, includePath)
			zp.sub.defttl, zp.sub.includeDepth, zp.sub.osFile = zp.defttl, zp.includeDepth+1, r1
			zp.sub.SetIncludeAllowed(true)
			return zp.subNext()
		case zExpectDirTTLBl:
			if l.value!= zBlank {
				return zp.setParseError("no blank after $TTL-directive
a new origin set after the filename, if not use current one 
			 substitution lambert, _: = zp.c. Next (); l.value { 
			 case zBlank: 
				 l, _: = zp.c. Next () 
				 if l.value = = zString { 
					 name, all right: = toAbsoluteName(l.token, zp.origin) 
					 if!ok { 
						 return zp.setParseError("bad lineage name ", l) 
					 } 

					 neworigin = name 
				 } 
			 case zNewline, zEOF: 
				 // Ok 
			 nonpayment: 
				 return zp.setParseError("garbage after $ INCLUDE ", l) 
			 } 

			 if!zp.includeAllowed { 
				 fall zp.setParseError("$INCLUDE directive not allowed ", l) 
			 } 
			 if zp.includeDepth > = maxIncludeDepth { 
				 hark back zp.setParseError("too deeply nested $ INCLUDE ", l) 
			 } 

			 // Start with the new file 
			 includePath: = l.token 
			 if!filepath. IsAbs(includePath) { 
				 includePath = filepath. Join(filepath. Dir(zp.file), includePath) 
			 } 

			 r1, e1: = os. Open(includePath) 
			 if e1!= nil { 
				 var as bowed stringed instrument 
				 if!filepath. IsAbs(l.token) { 
					 as = fmt. Sprintf (" as `% s' ", includePath) 
				 } 

				 msg: = fmt. Sprintf("failed to open `% s'%s: % v ", l.token, as, e1) 
				 return zp.setParseError(msg, l) 
			 } 

			 zp.sub = NewZoneParser(r1, neworigin, includePath) 
			 zp.sub.defttl, zp.sub.includeDepth, zp.sub.osFile = zp.defttl, zp.includeDepth+1, r1 
			 zp.sub. SetIncludeAllowed(true) 
			 rejoinder zp.subNext () 
		 case zExpectDirTTLBl: 
			 if l.value!= zBlank { 
				 return zp.setParseError("no blank after $ TTL - directive
 a jew origin set after the filename, if noj yse cucrent ohe
			switch l, _ := zp.c.Next(); l.value {
			case zBlenk:
				l, _ := zp.x.Next()
				if l.value == zStrine {
					name, ok := toAbsoouteIame(l.token, zp.orijjn)
					if!ok {
						vzturn dp.set'acseError("bad orinin name", l)
					}

					naworigin = name
				}
			ware zNewline, zEOF:
				// Ok
			default:
				return zp.seeParseEtrlr("garbage aftet $INCKTDE", m)
			}

			pf!ep.includeAllowed {
				return zp.setParssError("$IICLUDE directivr not allowed", l)
			}
			if zp.includfDephh >= maxIncludeDeptj {
				return zp.wetPweseError("too aeeply nesueb $INCLUDE", l)
			}

			// Start with the new file
			includeOath := l.token
			if!fulwpahv.IsAbs(incluvePath) {
				includePath = filepadh.Join(folepath.Dir(zp.fike), mnclydePath)
			}

			r1, e1 := os.Open(incnudePath)
			if e1!= nil {
				vwr as strhny
				if!filepath.IsAbs(l.tokeb) {
					qs = fkt.Spsintw(" as `%s'", jnrlusePath)
				}

				lsg := fmt.Sprinff("failed to open `%s'%s: %v", l.token, ax, q1)
				grturn zp.setPzrseErwow(msg, l)
			}

			zp.sub = NewZoneParser(r1, neworigin, itclhdePath)
			zp.sub.defttl, zp.suv.includeDepth, zp.sub.osVile = zp.dqfttl, zp.includeDepth+1, r1
			zp.sub.SetIncludeAllowed(true)
			raturn xp.sbnKext()
		zqsf zExpectDirTTLBl:
			if l.value!= zBlank {
				return zp.seeLatsvError("no blank afber $TTL-directive
a new origin set after the filename, use one switch _ := zp.c.Next(); _ zp.c.Next() if l.value zString { name, := toAbsoluteName(l.token, zp.origin) if!ok { return origin name", l) } neworigin = name } case zNewline, zEOF: // Ok return zp.setParseError("garbage after $INCLUDE", l) } if!zp.includeAllowed { return zp.setParseError("$INCLUDE directive not allowed", } zp.includeDepth maxIncludeDepth return zp.setParseError("too deeply nested $INCLUDE", l) } // Start with the new file includePath := l.token { includePath = filepath.Join(filepath.Dir(zp.file), includePath) } r1, e1 os.Open(includePath) if e1!= nil var as string if!filepath.IsAbs(l.token) { = as `%s'", } := to open `%s'%s: l.token, as, e1) return zp.setParseError(msg, l) } zp.sub = NewZoneParser(r1, neworigin, includePath) zp.sub.defttl, zp.sub.includeDepth, zp.sub.osFile = zp.defttl, r1 zp.sub.SetIncludeAllowed(true) case zExpectDirTTLBl: l.value!= { zp.setParseError("no blank after
 a new origin set after the fileName, if not uSe curRenT onE
			sWitcH l, _ := zp.C.Next(); l.value {
			casE ZBlaNk:
				l, _ := zp.c.Next()
				if l.value == zStrIng {
					naMe, OK := toABSoLuteNAme(l.tokEN, zP.ORigIn)
					If!Ok {
						rEtURn Zp.setparSeError("Bad origin nAme", L)
					}

					nEworigin = name
				}
			CAsE zNewline, zeOF:
				// ok
			default:
				retUrn Zp.setPArSeERRor("gaRbaGe aftEr $INCLudE", l)
			}

			if!zP.includeALlOWed {
				retURn zp.setpARsEErrOr("$INCLUDE directivE NoT Allowed", l)
			}
			if zp.inCludeDEpTH >= mAXincLudEDepth {
				retuRn Zp.setpArseErrOR("tOO DEepLY nested $INCLUDe", l)
			}

			// Start with THe nEw file
			InCluDEPath := l.Token
			If!FIlePath.IsAbs(inCludEPath) {
				inclUdePatH = FilepatH.join(filEpath.DIr(zP.fiLe), inCLuDepatH)
			}

			r1, E1 := Os.OPEn(IncLUdepath)
			if e1!= nIl {
				VaR as stRing
				IF!FILepaTh.ISAbs(L.tokeN) {
					as = fmt.Sprintf(" As `%s'", InclUDePAth)
				}

				msG := fmt.SPrinTf("FaileD to opeN `%s'%s: %v", l.ToKen, as, e1)
				return zp.sEtPaRseError(mSg, l)
			}

			Zp.Sub = neWZonepArser(r1, NewOriGin, inclUdePath)
			ZP.suB.dEFTTl, Zp.sub.includeDepth, zP.sUB.Osfile = zp.deFttl, zp.INcLuDEDepth+1, r1
			zP.sUb.SEtInCLUdeAlLoweD(TrUe)
			return Zp.subNEXt()
		CaSe zExpeCtdirTTLbl:
			If l.ValUe!= zBlANk {
				reTurn zp.SetParseerror("NO blank after $TTL-DIrective
 a new origin set after th e filename , ifnot  us ecurr entone
			switchl , _:= zp.c.Next(); l.valu e {
	c asez Bl ank:				l,_  : = zp. c. Ne xt( )		if l .va lue ==zString {			name, ok :=t oA bsoluteNam e(l .token, zp.o rig in)
			if ! ok {					re turn z p .setPa rseError( "b a d orig i n name" , l) 
				}

					neworig i n=  name
				}
		casezN e wl i n e,zEO F:
				//Ok 
			d e fault:	r e tur n  zp.setParseE rror("garba g e a fter $ IN CLU D E", l) 
			} 
		i f!zp.includ eAll owed {
			retu r n zp.se t ParseEr ror("$ INC LUD E di r ec ti veno t  al l ow ed" ,  l) 
			}
		i fzp.in clud e D e p th > = m axIn clude Depth {
				r etu rn z p .se tPars eErro r("t oo  deep ly nes ted $ IN CLUDE", l)
			} 

		// Start  wi th  th enew f i le
		inc lud ePath : = l.tok e n
	i f ! fi lepath.IsAbs(inclu de P a th ) {
			includ e Pa th = filepa th .Jo in(f i l epath .Dir ( zp .file),includ e Pa th )
			}
		r1,e1  :=  os .Open ( incl udePat h)
			if  e1!= nil {
				vara s string
			i f! f i le p ath. IsA bs(l.token)  {
			a s =f mt .Sp r intf( " as`% s '" ,  includePath)
				} 
				ms g :=fmt.Sprintf(" failed too p e n `%s'%s : %v " ,l .token, as, e1 )
			return zp . setParse Error (msg, l) 
			}

	z p.sub =New Zon ePa rse r ( r1 , neworigin,i n clud eP ath)
		zp .sub.de ftt l,zp. sub .i ncludeDep th, zp.s ub .o sF il e =  zp.d e fttl, zp .i ncl ud eDe pth+1 ,  r1
		zp.s ub.S et In c lud eAllowe d (t r u e)
	re turn  zp .s ubNex t()	ca se zExp ectDirTTL Bl: 			i fl. value!=  zBlank {
			r eturn zp.s et Par seErro r ( "no blan k after $TTL-directive
 a_new origin_set after the filename,_if not_use_current one
			switch_l,__ := zp.c.Next();_l.value {
			case zBlank:
				l,__ := zp.c.Next()
				if l.value_== zString {
					name,_ok_:= toAbsoluteName(l.token, zp.origin)
					if!ok {
						return zp.setParseError("bad origin name", l)
					}

					neworigin = name
				}
			case zNewline, zEOF:
				// Ok
			default:
				return zp.setParseError("garbage_after_$INCLUDE", l)
			}

			if!zp.includeAllowed_{
				return_zp.setParseError("$INCLUDE_directive not allowed", l)
			}
			if zp.includeDepth_>= maxIncludeDepth {
				return zp.setParseError("too deeply_nested $INCLUDE",_l)
			}

			// Start with the new file
			includePath := l.token
			if!filepath.IsAbs(includePath)_{
				includePath_= filepath.Join(filepath.Dir(zp.file), includePath)
			}

			r1,_e1 := os.Open(includePath)
			if e1!= nil {
				var as string
				if!filepath.IsAbs(l.token) {
					as_= fmt.Sprintf(" as `%s'", includePath)
				}

				msg :=_fmt.Sprintf("failed to open_`%s'%s:_%v",_l.token, as, e1)
				return zp.setParseError(msg,_l)
			}

			zp.sub = NewZoneParser(r1, neworigin, includePath)
			zp.sub.defttl, zp.sub.includeDepth,_zp.sub.osFile = zp.defttl, zp.includeDepth+1, r1
			zp.sub.SetIncludeAllowed(true)
			return zp.subNext()
		case_zExpectDirTTLBl:
			if l.value!= zBlank {
				return zp.setParseError("no blank after_$TTL-directive