diff --git a/zparse.go b/zparse.go
deleted file mode 100644
index 5b313a87..00000000
--- a/zparse.go
+++ /dev/null
@@ -1,3762 +0,0 @@
-// line 1 "zparse.rl"
-package dns
-
-// Parse RRs
-// With the thankful help of gdnsd and the Go examples for Ragel.
-
-import (
-	"strings"
-)
-
-const _IOBUF = MaxMsgSize
-
-// A Parser represents a DNS parser for a 
-// particular input stream. 
-type Parser struct {
-	// nothing here yet
-	buf []byte
-}
-
-// First will return the first RR found when parsing.
-func (zp *Parser) First() (RR, error) {
-	// defer close something
-	return nil, nil
-}
-
-
-// Return the rdata fields as a string slice. 
-// All starting whitespace is deleted.
-// If i is 0 no spaces are deleted from the final rdfs.
-func fields(s string, i int) (rdf []string) {
-	rdf = strings.Fields(s)
-	for i, _ := range rdf {
-		rdf[i] = strings.TrimSpace(rdf[i])
-	}
-	if i > 0 && len(rdf) > i {
-		// The last rdf contained embedded spaces, glue it back together.
-		for j := i; j < len(rdf); j++ {
-			rdf[i-1] += rdf[j]
-		}
-	}
-	return
-}
-
-// line 86 "zparse.go"
-var z_start int = 141
-var z_first_final int = 141
-var z_error int = 0
-
-var z_en_main int = 141
-
-// line 85 "zparse.rl"
-
-// Zone parses an DNS master zone file.
-func (zp *Parser) Zone() (err error) {
-	/*
-		z = NewZone()
-		data := string(zp.buf)
-		cs, p, pe := 0, 0, len(data)
-		eof := len(data)
-
-		//        brace := false
-		l := 1 // or... 0?
-		mark := 0
-		var hdr RR_Header
-
-		// line 119 "zparse.go"
-		cs = z_start
-
-		// line 122 "zparse.go"
-		{
-			if p == pe {
-				goto _test_eof
-			}
-			switch cs {
-			case -666: // i am a hack D:
-			tr33:
-				// line 3 "types.rl"
-				{
-					rdf := fields(data[mark:p], 1)
-					rr := new(RR_A)
-					rr.Hdr = hdr
-					rr.Hdr.Rrtype = TypeA
-					rr.A = net.ParseIP(rdf[0])
-					if rr.A == nil {
-						return z, &ParseError{Error: "bad A", name: rdf[0], line: l}
-					}
-					z.PushRR(rr)
-				}
-				// line 112 "zparse.rl"
-				{
-					l++
-				}
-				goto st141
-			tr40:
-				// line 15 "types.rl"
-				{
-					rdf := fields(data[mark:p], 1)
-					rr := new(RR_AAAA)
-					rr.Hdr = hdr
-					rr.Hdr.Rrtype = TypeAAAA
-					rr.AAAA = net.ParseIP(rdf[0])
-					if rr.AAAA == nil {
-						return z, &ParseError{Error: "bad AAAA", name: rdf[0], line: l}
-					}
-					z.PushRR(rr)
-				}
-				// line 112 "zparse.rl"
-				{
-					l++
-				}
-				goto st141
-			tr50:
-				// line 342 "types.rl"
-				{
-				}
-				// line 112 "zparse.rl"
-				{
-					l++
-				}
-				goto st141
-			tr61:
-				// line 53 "types.rl"
-				{
-					rdf := fields(data[mark:p], 1)
-					rr := new(RR_CNAME)
-					rr.Hdr = hdr
-					rr.Hdr.Rrtype = TypeCNAME
-					rr.Cname = rdf[0]
-					if !IsDomainName(rdf[0]) {
-						return z, &ParseError{Error: "bad CNAME", name: rdf[0], line: l}
-					}
-					z.PushRR(rr)
-				}
-				// line 112 "zparse.rl"
-				{
-					l++
-				}
-				goto st141
-			tr70:
-				// line 122 "types.rl"
-				{
-					var (
-						i uint
-						e os.Error
-					)
-					rdf := fields(data[mark:p], 4)
-					rr := new(RR_DLV)
-					rr.Hdr = hdr
-					rr.Hdr.Rrtype = TypeDLV
-					if i, e = strconv.Atoui(rdf[0]); e != nil {
-						return z, &ParseError{Error: "bad DS", name: rdf[0], line: l}
-					}
-					rr.KeyTag = uint16(i)
-					if i, e = strconv.Atoui(rdf[1]); e != nil {
-						return z, &ParseError{Error: "bad DS", name: rdf[1], line: l}
-					}
-					rr.Algorithm = uint8(i)
-					if i, e = strconv.Atoui(rdf[2]); e != nil {
-						return z, &ParseError{Error: "bad DS", name: rdf[2], line: l}
-					}
-					rr.DigestType = uint8(i)
-					rr.Digest = rdf[3]
-					z.PushRR(rr)
-				}
-				// line 112 "zparse.rl"
-				{
-					l++
-				}
-				goto st141
-			tr79:
-				// line 348 "types.rl"
-				{
-				}
-				// line 112 "zparse.rl"
-				{
-					l++
-				}
-				goto st141
-			tr87:
-				// line 172 "types.rl"
-				{
-					var (
-						i uint
-						e os.Error
-					)
-					rdf := fields(data[mark:p], 4)
-					rr := new(RR_DNSKEY)
-					rr.Hdr = hdr
-					rr.Hdr.Rrtype = TypeDNSKEY
-
-					if i, e = strconv.Atoui(rdf[0]); e != nil {
-						return z, &ParseError{Error: "bad DNSKEY", name: rdf[0], line: l}
-					}
-					rr.Flags = uint16(i)
-					if i, e = strconv.Atoui(rdf[1]); e != nil {
-						return z, &ParseError{Error: "bad DNSKEY", name: rdf[1], line: l}
-					}
-					rr.Protocol = uint8(i)
-					if i, e = strconv.Atoui(rdf[2]); e != nil {
-						return z, &ParseError{Error: "bad DNSKEY", name: rdf[2], line: l}
-					}
-					rr.Algorithm = uint8(i)
-					rr.PublicKey = rdf[3]
-					z.PushRR(rr)
-				}
-				// line 112 "zparse.rl"
-				{
-					l++
-				}
-				goto st141
-			tr92:
-				// line 97 "types.rl"
-				{
-					var (
-						i uint
-						e os.Error
-					)
-					rdf := fields(data[mark:p], 4)
-					rr := new(RR_DS)
-					rr.Hdr = hdr
-					rr.Hdr.Rrtype = TypeDS
-					if i, e = strconv.Atoui(rdf[0]); e != nil {
-						return z, &ParseError{Error: "bad DS", name: rdf[0], line: l}
-					}
-					rr.KeyTag = uint16(i)
-					if i, e = strconv.Atoui(rdf[1]); e != nil {
-						return z, &ParseError{Error: "bad DS", name: rdf[1], line: l}
-					}
-					rr.Algorithm = uint8(i)
-					if i, e = strconv.Atoui(rdf[2]); e != nil {
-						return z, &ParseError{Error: "bad DS", name: rdf[2], line: l}
-					}
-					rr.DigestType = uint8(i)
-					rr.Digest = rdf[3]
-					z.PushRR(rr)
-				}
-				// line 112 "zparse.rl"
-				{
-					l++
-				}
-				goto st141
-			tr98:
-				// line 39 "types.rl"
-				{
-					rdf := fields(data[mark:p], 2)
-					rr := new(RR_MX)
-					rr.Hdr = hdr
-					rr.Hdr.Rrtype = TypeMX
-					i, err := strconv.Atoui(rdf[0])
-					rr.Pref = uint16(i)
-					rr.Mx = rdf[1]
-					if err != nil {
-						return z, &ParseError{Error: "bad MX", name: rdf[0], line: l}
-					}
-					z.PushRR(rr)
-				}
-				// line 112 "zparse.rl"
-				{
-					l++
-				}
-				goto st141
-			tr108:
-				// line 351 "types.rl"
-				{
-				}
-				// line 112 "zparse.rl"
-				{
-					l++
-				}
-				goto st141
-			tr114:
-				// line 27 "types.rl"
-				{
-					rdf := fields(data[mark:p], 1)
-					rr := new(RR_NS)
-					rr.Hdr = hdr
-					rr.Hdr.Rrtype = TypeNS
-					rr.Ns = rdf[0]
-					if !IsDomainName(rdf[0]) {
-						return z, &ParseError{Error: "bad NS", name: rdf[0], line: l}
-					}
-					z.PushRR(rr)
-				}
-				// line 112 "zparse.rl"
-				{
-					l++
-				}
-				goto st141
-			tr121:
-				// line 250 "types.rl"
-				{
-					rdf := fields(data[mark:p], 0)
-					rr := new(RR_NSEC)
-					rr.Hdr = hdr
-					rr.Hdr.Rrtype = TypeNSEC
-					rr.NextDomain = rdf[0]
-					rr.TypeBitMap = make([]uint16, len(rdf)-1)
-					// Fill the Type Bit Map
-					for i := 1; i < len(rdf); i++ {
-						// Check if its there in the map TODO
-						rr.TypeBitMap[i-1] = str_rr[strings.ToUpper(rdf[i])]
-					}
-					z.PushRR(rr)
-				}
-				// line 112 "zparse.rl"
-				{
-					l++
-				}
-				goto st141
-			tr127:
-				// line 265 "types.rl"
-				{
-					var (
-						i uint
-						e os.Error
-					)
-					rdf := fields(data[mark:p], 0)
-					rr := new(RR_NSEC3)
-					rr.Hdr = hdr
-					rr.Hdr.Rrtype = TypeNSEC3
-
-					if i, e = strconv.Atoui(rdf[0]); e != nil {
-						return z, &ParseError{Error: "bad NSEC3", name: rdf[0], line: l}
-					}
-					rr.Hash = uint8(i)
-					if i, e = strconv.Atoui(rdf[1]); e != nil {
-						return z, &ParseError{Error: "bad NSEC3", name: rdf[1], line: l}
-					}
-					rr.Flags = uint8(i)
-					if i, e = strconv.Atoui(rdf[2]); e != nil {
-						return z, &ParseError{Error: "bad NSEC3", name: rdf[2], line: l}
-					}
-					rr.Iterations = uint16(i)
-					rr.SaltLength = uint8(len(rdf[3]))
-					rr.Salt = rdf[3]
-
-					rr.HashLength = uint8(len(rdf[4]))
-					rr.NextDomain = rdf[4]
-					rr.TypeBitMap = make([]uint16, len(rdf)-5)
-					// Fill the Type Bit Map
-					for i := 5; i < len(rdf); i++ {
-						// Check if its there in the map TODO
-						rr.TypeBitMap[i-5] = str_rr[strings.ToUpper(rdf[i])]
-					}
-					z.PushRR(rr)
-				}
-				// line 112 "zparse.rl"
-				{
-					l++
-				}
-				goto st141
-			tr136:
-				// line 301 "types.rl"
-				{
-					var (
-						i int
-						e os.Error
-					)
-					rdf := fields(data[mark:p], 4)
-					rr := new(RR_NSEC3PARAM)
-					rr.Hdr = hdr
-					rr.Hdr.Rrtype = TypeNSEC3PARAM
-					if i, e = strconv.Atoi(rdf[0]); e != nil {
-						return z, &ParseError{Error: "bad NSEC3PARAM", name: rdf[0], line: l}
-					}
-					rr.Hash = uint8(i)
-					if i, e = strconv.Atoi(rdf[1]); e != nil {
-						return z, &ParseError{Error: "bad NSEC3PARAM", name: rdf[1], line: l}
-					}
-					rr.Flags = uint8(i)
-					if i, e = strconv.Atoi(rdf[2]); e != nil {
-						return z, &ParseError{Error: "bad NSEC3PARAM", name: rdf[2], line: l}
-					}
-					rr.Iterations = uint16(i)
-					rr.Salt = rdf[3]
-					rr.SaltLength = uint8(len(rr.Salt))
-					z.PushRR(rr)
-				}
-				// line 112 "zparse.rl"
-				{
-					l++
-				}
-				goto st141
-			tr143:
-				// line 345 "types.rl"
-				{
-				}
-				// line 112 "zparse.rl"
-				{
-					l++
-				}
-				goto st141
-			tr152:
-				// line 198 "types.rl"
-				{
-					var (
-						i   uint
-						j   uint32
-						err os.Error
-					)
-					rdf := fields(data[mark:p], 9)
-					rr := new(RR_RRSIG)
-					rr.Hdr = hdr
-					rr.Hdr.Rrtype = TypeRRSIG
-
-					if _, ok := str_rr[strings.ToUpper(rdf[0])]; !ok {
-						return z, &ParseError{Error: "bad RRSIG", name: rdf[0], line: l}
-					}
-					rr.TypeCovered = str_rr[strings.ToUpper(rdf[0])]
-
-					if i, err = strconv.Atoui(rdf[1]); err != nil {
-						return z, &ParseError{Error: "bad RRSIG", name: rdf[1], line: l}
-					}
-					rr.Algorithm = uint8(i)
-					if i, err = strconv.Atoui(rdf[2]); err != nil {
-						return z, &ParseError{Error: "bad RRSIG", name: rdf[2], line: l}
-					}
-					rr.Labels = uint8(i)
-					if i, err = strconv.Atoui(rdf[3]); err != nil {
-						return z, &ParseError{Error: "bad RRSIG", name: rdf[3], line: l}
-					}
-					rr.OrigTtl = uint32(i)
-
-					if j, err = dateToTime(rdf[4]); err != nil {
-						return z, &ParseError{Error: "bad RRSIG", name: rdf[4], line: l}
-					}
-					rr.Expiration = j
-					if j, err = dateToTime(rdf[5]); err != nil {
-						return z, &ParseError{Error: "bad RRSIG", name: rdf[5], line: l}
-					}
-					rr.Inception = j
-
-					if i, err = strconv.Atoui(rdf[6]); err != nil {
-						return z, &ParseError{Error: "bad RRSIG", name: rdf[3], line: l}
-					}
-					rr.KeyTag = uint16(i)
-
-					rr.SignerName = rdf[7]
-					if !IsDomainName(rdf[7]) {
-						return z, &ParseError{Error: "bad RRSIG", name: rdf[7], line: l}
-					}
-					// Check base64 TODO
-					rr.Signature = rdf[8]
-					z.PushRR(rr)
-				}
-				// line 112 "zparse.rl"
-				{
-					l++
-				}
-				goto st141
-			tr161:
-				// line 65 "types.rl"
-				{
-					var (
-						i   uint
-						err os.Error
-					)
-					rdf := fields(data[mark:p], 7)
-					rr := new(RR_SOA)
-					rr.Hdr = hdr
-					rr.Hdr.Rrtype = TypeSOA
-					rr.Ns = rdf[0]
-					rr.Mbox = rdf[1]
-					if !IsDomainName(rdf[0]) {
-						return z, &ParseError{Error: "bad SOA", name: rdf[0], line: l}
-					}
-					if !IsDomainName(rdf[1]) {
-						return z, &ParseError{Error: "bad SOA", name: rdf[1], line: l}
-					}
-					for j, s := range rdf[2:7] {
-						if i, err = strconv.Atoui(s); err != nil {
-							return z, &ParseError{Error: "bad SOA", name: s, line: l}
-						}
-						switch j {
-						case 0:
-							rr.Serial = uint32(i)
-						case 1:
-							rr.Refresh = uint32(i)
-						case 2:
-							rr.Retry = uint32(i)
-						case 3:
-							rr.Expire = uint32(i)
-						case 4:
-							rr.Minttl = uint32(i)
-						}
-					}
-					z.PushRR(rr)
-				}
-				// line 112 "zparse.rl"
-				{
-					l++
-				}
-				goto st141
-			tr167:
-				// line 339 "types.rl"
-				{
-				}
-				// line 112 "zparse.rl"
-				{
-					l++
-				}
-				goto st141
-			tr175:
-				// line 354 "types.rl"
-				{
-					var (
-						i int
-						e os.Error
-					)
-					rdf := fields(data[mark:p], 3)
-					rr := new(RR_SSHFP)
-					rr.Hdr = hdr
-					rr.Hdr.Rrtype = TypeSSHFP
-					if i, e = strconv.Atoi(rdf[0]); e != nil {
-						return z, &ParseError{Error: "bad SSHFP", name: rdf[0], line: l}
-					}
-					rr.Algorithm = uint8(i)
-					if i, e = strconv.Atoi(rdf[1]); e != nil {
-						return z, &ParseError{Error: "bad SSHFP", name: rdf[1], line: l}
-					}
-					rr.Type = uint8(i)
-					rr.FingerPrint = rdf[2]
-					z.PushRR(rr)
-				}
-				// line 112 "zparse.rl"
-				{
-					l++
-				}
-				goto st141
-			tr182:
-				// line 147 "types.rl"
-				{
-					var (
-						i uint
-						e os.Error
-					)
-					rdf := fields(data[mark:p], 4)
-					rr := new(RR_TA)
-					rr.Hdr = hdr
-					rr.Hdr.Rrtype = TypeTA
-					if i, e = strconv.Atoui(rdf[0]); e != nil {
-						return z, &ParseError{Error: "bad DS", name: rdf[0], line: l}
-					}
-					rr.KeyTag = uint16(i)
-					if i, e = strconv.Atoui(rdf[1]); e != nil {
-						return z, &ParseError{Error: "bad DS", name: rdf[1], line: l}
-					}
-					rr.Algorithm = uint8(i)
-					if i, e = strconv.Atoui(rdf[2]); e != nil {
-						return z, &ParseError{Error: "bad DS", name: rdf[2], line: l}
-					}
-					rr.DigestType = uint8(i)
-					rr.Digest = rdf[3]
-					z.PushRR(rr)
-				}
-				// line 112 "zparse.rl"
-				{
-					l++
-				}
-				goto st141
-			tr188:
-				// line 330 "types.rl"
-				{
-					rdf := fields(data[mark:p], 1)
-					rr := new(RR_TXT)
-					rr.Hdr = hdr
-					rr.Hdr.Rrtype = TypeTXT
-					rr.Txt = rdf[0]
-					z.PushRR(rr)
-				}
-				// line 112 "zparse.rl"
-				{
-					l++
-				}
-				goto st141
-			tr198:
-				// line 112 "zparse.rl"
-				{
-					l++
-				}
-				goto st141
-			st141:
-				p++
-				if p == pe {
-					goto _test_eof141
-				}
-				fallthrough
-			case 141:
-				// line 589 "zparse.go"
-				switch data[p] {
-				case 9:
-					goto st1
-				case 10:
-					goto tr198
-				case 32:
-					goto st1
-				case 42:
-					goto tr199
-				case 59:
-					goto st140
-				case 95:
-					goto tr199
-				}
-				if data[p] < 48 {
-					if 45 <= data[p] && data[p] <= 46 {
-						goto tr199
-					}
-				} else if data[p] > 57 {
-					if data[p] > 90 {
-						if 97 <= data[p] && data[p] <= 122 {
-							goto tr199
-						}
-					} else if data[p] >= 65 {
-						goto tr199
-					}
-				} else {
-					goto tr199
-				}
-				goto st0
-			st0:
-				cs = 0
-				goto _out
-			tr195:
-				// line 113 "zparse.rl"
-				{
-					if !IsDomainName(data[mark:p]) {
-						return z, &ParseError{Error: "bad qname: " + data[mark:p], line: l}
-					}
-					hdr.Name = data[mark:p]
-				}
-				goto st1
-			st1:
-				p++
-				if p == pe {
-					goto _test_eof1
-				}
-				fallthrough
-			case 1:
-				// line 626 "zparse.go"
-				switch data[p] {
-				case 9:
-					goto st1
-				case 32:
-					goto st1
-				case 65:
-					goto tr3
-				case 67:
-					goto tr4
-				case 68:
-					goto tr5
-				case 72:
-					goto tr6
-				case 73:
-					goto tr7
-				case 77:
-					goto tr8
-				case 78:
-					goto tr9
-				case 80:
-					goto tr10
-				case 82:
-					goto tr11
-				case 83:
-					goto tr12
-				case 84:
-					goto tr13
-				case 97:
-					goto tr3
-				case 99:
-					goto tr4
-				case 100:
-					goto tr5
-				case 104:
-					goto tr6
-				case 105:
-					goto tr7
-				case 109:
-					goto tr8
-				case 110:
-					goto tr9
-				case 112:
-					goto tr10
-				case 114:
-					goto tr11
-				case 115:
-					goto tr12
-				case 116:
-					goto tr13
-				}
-				if 48 <= data[p] && data[p] <= 57 {
-					goto tr2
-				}
-				goto st0
-			tr2:
-				// line 120 "zparse.rl"
-				{ // ... 
-				}
-				// line 111 "zparse.rl"
-				{
-					mark = p
-				}
-				goto st2
-			st2:
-				p++
-				if p == pe {
-					goto _test_eof2
-				}
-				fallthrough
-			case 2:
-				// line 666 "zparse.go"
-				switch data[p] {
-				case 9:
-					goto tr14
-				case 32:
-					goto tr14
-				}
-				if 48 <= data[p] && data[p] <= 57 {
-					goto st2
-				}
-				goto st0
-			tr14:
-				// line 122 "zparse.rl"
-				{
-					i, _ := strconv.Atoui(data[mark:p])
-					hdr.Ttl = uint32(i)
-				}
-				goto st3
-			st3:
-				p++
-				if p == pe {
-					goto _test_eof3
-				}
-				fallthrough
-			case 3:
-				// line 682 "zparse.go"
-				switch data[p] {
-				case 9:
-					goto st3
-				case 32:
-					goto st3
-				case 65:
-					goto st4
-				case 67:
-					goto tr18
-				case 68:
-					goto st31
-				case 72:
-					goto tr20
-				case 73:
-					goto tr21
-				case 77:
-					goto st55
-				case 78:
-					goto st60
-				case 80:
-					goto st89
-				case 82:
-					goto st95
-				case 83:
-					goto st103
-				case 84:
-					goto st121
-				case 97:
-					goto st4
-				case 99:
-					goto tr18
-				case 100:
-					goto st31
-				case 104:
-					goto tr20
-				case 105:
-					goto tr21
-				case 109:
-					goto st55
-				case 110:
-					goto st60
-				case 112:
-					goto st89
-				case 114:
-					goto st95
-				case 115:
-					goto st103
-				case 116:
-					goto st121
-				}
-				goto st0
-			tr3:
-				// line 120 "zparse.rl"
-				{ // ... 
-				}
-				goto st4
-			st4:
-				p++
-				if p == pe {
-					goto _test_eof4
-				}
-				fallthrough
-			case 4:
-				// line 719 "zparse.go"
-				switch data[p] {
-				case 9:
-					goto st5
-				case 32:
-					goto st5
-				case 65:
-					goto st8
-				case 97:
-					goto st8
-				}
-				goto st0
-			st5:
-				p++
-				if p == pe {
-					goto _test_eof5
-				}
-				fallthrough
-			case 5:
-				switch data[p] {
-				case 9:
-					goto tr31
-				case 10:
-					goto st0
-				case 32:
-					goto tr31
-				}
-				goto tr30
-			tr30:
-				// line 111 "zparse.rl"
-				{
-					mark = p
-				}
-				goto st6
-			st6:
-				p++
-				if p == pe {
-					goto _test_eof6
-				}
-				fallthrough
-			case 6:
-				// line 747 "zparse.go"
-				if data[p] == 10 {
-					goto tr33
-				}
-				goto st6
-			tr31:
-				// line 111 "zparse.rl"
-				{
-					mark = p
-				}
-				goto st7
-			st7:
-				p++
-				if p == pe {
-					goto _test_eof7
-				}
-				fallthrough
-			case 7:
-				// line 759 "zparse.go"
-				switch data[p] {
-				case 9:
-					goto tr31
-				case 10:
-					goto tr33
-				case 32:
-					goto tr31
-				}
-				goto tr30
-			st8:
-				p++
-				if p == pe {
-					goto _test_eof8
-				}
-				fallthrough
-			case 8:
-				switch data[p] {
-				case 65:
-					goto st9
-				case 97:
-					goto st9
-				}
-				goto st0
-			st9:
-				p++
-				if p == pe {
-					goto _test_eof9
-				}
-				fallthrough
-			case 9:
-				switch data[p] {
-				case 65:
-					goto st10
-				case 97:
-					goto st10
-				}
-				goto st0
-			st10:
-				p++
-				if p == pe {
-					goto _test_eof10
-				}
-				fallthrough
-			case 10:
-				switch data[p] {
-				case 9:
-					goto st11
-				case 32:
-					goto st11
-				}
-				goto st0
-			st11:
-				p++
-				if p == pe {
-					goto _test_eof11
-				}
-				fallthrough
-			case 11:
-				switch data[p] {
-				case 9:
-					goto tr38
-				case 10:
-					goto st0
-				case 32:
-					goto tr38
-				}
-				goto tr37
-			tr37:
-				// line 111 "zparse.rl"
-				{
-					mark = p
-				}
-				goto st12
-			st12:
-				p++
-				if p == pe {
-					goto _test_eof12
-				}
-				fallthrough
-			case 12:
-				// line 816 "zparse.go"
-				if data[p] == 10 {
-					goto tr40
-				}
-				goto st12
-			tr38:
-				// line 111 "zparse.rl"
-				{
-					mark = p
-				}
-				goto st13
-			st13:
-				p++
-				if p == pe {
-					goto _test_eof13
-				}
-				fallthrough
-			case 13:
-				// line 828 "zparse.go"
-				switch data[p] {
-				case 9:
-					goto tr38
-				case 10:
-					goto tr40
-				case 32:
-					goto tr38
-				}
-				goto tr37
-			tr18:
-				// line 111 "zparse.rl"
-				{
-					mark = p
-				}
-				goto st14
-			st14:
-				p++
-				if p == pe {
-					goto _test_eof14
-				}
-				fallthrough
-			case 14:
-				// line 844 "zparse.go"
-				switch data[p] {
-				case 69:
-					goto st15
-				case 72:
-					goto st21
-				case 78:
-					goto st24
-				case 101:
-					goto st15
-				case 104:
-					goto st21
-				case 110:
-					goto st24
-				}
-				goto st0
-			st15:
-				p++
-				if p == pe {
-					goto _test_eof15
-				}
-				fallthrough
-			case 15:
-				switch data[p] {
-				case 82:
-					goto st16
-				case 114:
-					goto st16
-				}
-				goto st0
-			st16:
-				p++
-				if p == pe {
-					goto _test_eof16
-				}
-				fallthrough
-			case 16:
-				switch data[p] {
-				case 84:
-					goto st17
-				case 116:
-					goto st17
-				}
-				goto st0
-			st17:
-				p++
-				if p == pe {
-					goto _test_eof17
-				}
-				fallthrough
-			case 17:
-				switch data[p] {
-				case 9:
-					goto st18
-				case 32:
-					goto st18
-				}
-				goto st0
-			st18:
-				p++
-				if p == pe {
-					goto _test_eof18
-				}
-				fallthrough
-			case 18:
-				switch data[p] {
-				case 9:
-					goto tr48
-				case 10:
-					goto st0
-				case 32:
-					goto tr48
-				}
-				goto tr47
-			tr47:
-				// line 111 "zparse.rl"
-				{
-					mark = p
-				}
-				goto st19
-			st19:
-				p++
-				if p == pe {
-					goto _test_eof19
-				}
-				fallthrough
-			case 19:
-				// line 904 "zparse.go"
-				if data[p] == 10 {
-					goto tr50
-				}
-				goto st19
-			tr48:
-				// line 111 "zparse.rl"
-				{
-					mark = p
-				}
-				goto st20
-			st20:
-				p++
-				if p == pe {
-					goto _test_eof20
-				}
-				fallthrough
-			case 20:
-				// line 916 "zparse.go"
-				switch data[p] {
-				case 9:
-					goto tr48
-				case 10:
-					goto tr50
-				case 32:
-					goto tr48
-				}
-				goto tr47
-			st21:
-				p++
-				if p == pe {
-					goto _test_eof21
-				}
-				fallthrough
-			case 21:
-				switch data[p] {
-				case 9:
-					goto tr51
-				case 32:
-					goto tr51
-				}
-				goto st0
-			tr193:
-				// line 122 "zparse.rl"
-				{
-					i, _ := strconv.Atoui(data[mark:p])
-					hdr.Ttl = uint32(i)
-				}
-				goto st22
-			tr51:
-				// line 119 "zparse.rl"
-				{
-					hdr.Class = str_class[data[mark:p]]
-				}
-				goto st22
-			st22:
-				p++
-				if p == pe {
-					goto _test_eof22
-				}
-				fallthrough
-			case 22:
-				// line 946 "zparse.go"
-				switch data[p] {
-				case 9:
-					goto st22
-				case 32:
-					goto st22
-				case 65:
-					goto st4
-				case 67:
-					goto st23
-				case 68:
-					goto st31
-				case 77:
-					goto st55
-				case 78:
-					goto st60
-				case 80:
-					goto st89
-				case 82:
-					goto st95
-				case 83:
-					goto st103
-				case 84:
-					goto st121
-				case 97:
-					goto st4
-				case 99:
-					goto st23
-				case 100:
-					goto st31
-				case 109:
-					goto st55
-				case 110:
-					goto st60
-				case 112:
-					goto st89
-				case 114:
-					goto st95
-				case 115:
-					goto st103
-				case 116:
-					goto st121
-				}
-				goto st0
-			st23:
-				p++
-				if p == pe {
-					goto _test_eof23
-				}
-				fallthrough
-			case 23:
-				switch data[p] {
-				case 69:
-					goto st15
-				case 78:
-					goto st24
-				case 101:
-					goto st15
-				case 110:
-					goto st24
-				}
-				goto st0
-			st24:
-				p++
-				if p == pe {
-					goto _test_eof24
-				}
-				fallthrough
-			case 24:
-				switch data[p] {
-				case 65:
-					goto st25
-				case 97:
-					goto st25
-				}
-				goto st0
-			st25:
-				p++
-				if p == pe {
-					goto _test_eof25
-				}
-				fallthrough
-			case 25:
-				switch data[p] {
-				case 77:
-					goto st26
-				case 109:
-					goto st26
-				}
-				goto st0
-			st26:
-				p++
-				if p == pe {
-					goto _test_eof26
-				}
-				fallthrough
-			case 26:
-				switch data[p] {
-				case 69:
-					goto st27
-				case 101:
-					goto st27
-				}
-				goto st0
-			st27:
-				p++
-				if p == pe {
-					goto _test_eof27
-				}
-				fallthrough
-			case 27:
-				switch data[p] {
-				case 9:
-					goto st28
-				case 32:
-					goto st28
-				}
-				goto st0
-			st28:
-				p++
-				if p == pe {
-					goto _test_eof28
-				}
-				fallthrough
-			case 28:
-				switch data[p] {
-				case 9:
-					goto tr59
-				case 10:
-					goto st0
-				case 32:
-					goto tr59
-				}
-				goto tr58
-			tr58:
-				// line 111 "zparse.rl"
-				{
-					mark = p
-				}
-				goto st29
-			st29:
-				p++
-				if p == pe {
-					goto _test_eof29
-				}
-				fallthrough
-			case 29:
-				// line 1042 "zparse.go"
-				if data[p] == 10 {
-					goto tr61
-				}
-				goto st29
-			tr59:
-				// line 111 "zparse.rl"
-				{
-					mark = p
-				}
-				goto st30
-			st30:
-				p++
-				if p == pe {
-					goto _test_eof30
-				}
-				fallthrough
-			case 30:
-				// line 1054 "zparse.go"
-				switch data[p] {
-				case 9:
-					goto tr59
-				case 10:
-					goto tr61
-				case 32:
-					goto tr59
-				}
-				goto tr58
-			tr5:
-				// line 120 "zparse.rl"
-				{ // ...
-				}
-				goto st31
-			st31:
-				p++
-				if p == pe {
-					goto _test_eof31
-				}
-				fallthrough
-			case 31:
-				// line 1070 "zparse.go"
-				switch data[p] {
-				case 76:
-					goto st32
-				case 78:
-					goto st37
-				case 83:
-					goto st51
-				case 108:
-					goto st32
-				case 110:
-					goto st37
-				case 115:
-					goto st51
-				}
-				goto st0
-			st32:
-				p++
-				if p == pe {
-					goto _test_eof32
-				}
-				fallthrough
-			case 32:
-				switch data[p] {
-				case 86:
-					goto st33
-				case 118:
-					goto st33
-				}
-				goto st0
-			st33:
-				p++
-				if p == pe {
-					goto _test_eof33
-				}
-				fallthrough
-			case 33:
-				switch data[p] {
-				case 9:
-					goto st34
-				case 32:
-					goto st34
-				}
-				goto st0
-			st34:
-				p++
-				if p == pe {
-					goto _test_eof34
-				}
-				fallthrough
-			case 34:
-				switch data[p] {
-				case 9:
-					goto tr68
-				case 10:
-					goto st0
-				case 32:
-					goto tr68
-				}
-				goto tr67
-			tr67:
-				// line 111 "zparse.rl"
-				{
-					mark = p
-				}
-				goto st35
-			st35:
-				p++
-				if p == pe {
-					goto _test_eof35
-				}
-				fallthrough
-			case 35:
-				// line 1120 "zparse.go"
-				if data[p] == 10 {
-					goto tr70
-				}
-				goto st35
-			tr68:
-				// line 111 "zparse.rl"
-				{
-					mark = p
-				}
-				goto st36
-			st36:
-				p++
-				if p == pe {
-					goto _test_eof36
-				}
-				fallthrough
-			case 36:
-				// line 1132 "zparse.go"
-				switch data[p] {
-				case 9:
-					goto tr68
-				case 10:
-					goto tr70
-				case 32:
-					goto tr68
-				}
-				goto tr67
-			st37:
-				p++
-				if p == pe {
-					goto _test_eof37
-				}
-				fallthrough
-			case 37:
-				switch data[p] {
-				case 65:
-					goto st38
-				case 83:
-					goto st44
-				case 97:
-					goto st38
-				case 115:
-					goto st44
-				}
-				goto st0
-			st38:
-				p++
-				if p == pe {
-					goto _test_eof38
-				}
-				fallthrough
-			case 38:
-				switch data[p] {
-				case 77:
-					goto st39
-				case 109:
-					goto st39
-				}
-				goto st0
-			st39:
-				p++
-				if p == pe {
-					goto _test_eof39
-				}
-				fallthrough
-			case 39:
-				switch data[p] {
-				case 69:
-					goto st40
-				case 101:
-					goto st40
-				}
-				goto st0
-			st40:
-				p++
-				if p == pe {
-					goto _test_eof40
-				}
-				fallthrough
-			case 40:
-				switch data[p] {
-				case 9:
-					goto st41
-				case 32:
-					goto st41
-				}
-				goto st0
-			st41:
-				p++
-				if p == pe {
-					goto _test_eof41
-				}
-				fallthrough
-			case 41:
-				switch data[p] {
-				case 9:
-					goto tr77
-				case 10:
-					goto st0
-				case 32:
-					goto tr77
-				}
-				goto tr76
-			tr76:
-				// line 111 "zparse.rl"
-				{
-					mark = p
-				}
-				goto st42
-			st42:
-				p++
-				if p == pe {
-					goto _test_eof42
-				}
-				fallthrough
-			case 42:
-				// line 1201 "zparse.go"
-				if data[p] == 10 {
-					goto tr79
-				}
-				goto st42
-			tr77:
-				// line 111 "zparse.rl"
-				{
-					mark = p
-				}
-				goto st43
-			st43:
-				p++
-				if p == pe {
-					goto _test_eof43
-				}
-				fallthrough
-			case 43:
-				// line 1213 "zparse.go"
-				switch data[p] {
-				case 9:
-					goto tr77
-				case 10:
-					goto tr79
-				case 32:
-					goto tr77
-				}
-				goto tr76
-			st44:
-				p++
-				if p == pe {
-					goto _test_eof44
-				}
-				fallthrough
-			case 44:
-				switch data[p] {
-				case 75:
-					goto st45
-				case 107:
-					goto st45
-				}
-				goto st0
-			st45:
-				p++
-				if p == pe {
-					goto _test_eof45
-				}
-				fallthrough
-			case 45:
-				switch data[p] {
-				case 69:
-					goto st46
-				case 101:
-					goto st46
-				}
-				goto st0
-			st46:
-				p++
-				if p == pe {
-					goto _test_eof46
-				}
-				fallthrough
-			case 46:
-				switch data[p] {
-				case 89:
-					goto st47
-				case 121:
-					goto st47
-				}
-				goto st0
-			st47:
-				p++
-				if p == pe {
-					goto _test_eof47
-				}
-				fallthrough
-			case 47:
-				switch data[p] {
-				case 9:
-					goto st48
-				case 32:
-					goto st48
-				}
-				goto st0
-			st48:
-				p++
-				if p == pe {
-					goto _test_eof48
-				}
-				fallthrough
-			case 48:
-				switch data[p] {
-				case 9:
-					goto tr85
-				case 10:
-					goto st0
-				case 32:
-					goto tr85
-				}
-				goto tr84
-			tr84:
-				// line 111 "zparse.rl"
-				{
-					mark = p
-				}
-				goto st49
-			st49:
-				p++
-				if p == pe {
-					goto _test_eof49
-				}
-				fallthrough
-			case 49:
-				// line 1280 "zparse.go"
-				if data[p] == 10 {
-					goto tr87
-				}
-				goto st49
-			tr85:
-				// line 111 "zparse.rl"
-				{
-					mark = p
-				}
-				goto st50
-			st50:
-				p++
-				if p == pe {
-					goto _test_eof50
-				}
-				fallthrough
-			case 50:
-				// line 1292 "zparse.go"
-				switch data[p] {
-				case 9:
-					goto tr85
-				case 10:
-					goto tr87
-				case 32:
-					goto tr85
-				}
-				goto tr84
-			st51:
-				p++
-				if p == pe {
-					goto _test_eof51
-				}
-				fallthrough
-			case 51:
-				switch data[p] {
-				case 9:
-					goto st52
-				case 32:
-					goto st52
-				}
-				goto st0
-			st52:
-				p++
-				if p == pe {
-					goto _test_eof52
-				}
-				fallthrough
-			case 52:
-				switch data[p] {
-				case 9:
-					goto tr90
-				case 10:
-					goto st0
-				case 32:
-					goto tr90
-				}
-				goto tr89
-			tr89:
-				// line 111 "zparse.rl"
-				{
-					mark = p
-				}
-				goto st53
-			st53:
-				p++
-				if p == pe {
-					goto _test_eof53
-				}
-				fallthrough
-			case 53:
-				// line 1329 "zparse.go"
-				if data[p] == 10 {
-					goto tr92
-				}
-				goto st53
-			tr90:
-				// line 111 "zparse.rl"
-				{
-					mark = p
-				}
-				goto st54
-			st54:
-				p++
-				if p == pe {
-					goto _test_eof54
-				}
-				fallthrough
-			case 54:
-				// line 1341 "zparse.go"
-				switch data[p] {
-				case 9:
-					goto tr90
-				case 10:
-					goto tr92
-				case 32:
-					goto tr90
-				}
-				goto tr89
-			tr8:
-				// line 120 "zparse.rl"
-				{ // ...
-				}
-				goto st55
-			st55:
-				p++
-				if p == pe {
-					goto _test_eof55
-				}
-				fallthrough
-			case 55:
-				// line 1357 "zparse.go"
-				switch data[p] {
-				case 88:
-					goto st56
-				case 120:
-					goto st56
-				}
-				goto st0
-			st56:
-				p++
-				if p == pe {
-					goto _test_eof56
-				}
-				fallthrough
-			case 56:
-				switch data[p] {
-				case 9:
-					goto st57
-				case 32:
-					goto st57
-				}
-				goto st0
-			st57:
-				p++
-				if p == pe {
-					goto _test_eof57
-				}
-				fallthrough
-			case 57:
-				switch data[p] {
-				case 9:
-					goto tr96
-				case 10:
-					goto st0
-				case 32:
-					goto tr96
-				}
-				goto tr95
-			tr95:
-				// line 111 "zparse.rl"
-				{
-					mark = p
-				}
-				goto st58
-			st58:
-				p++
-				if p == pe {
-					goto _test_eof58
-				}
-				fallthrough
-			case 58:
-				// line 1393 "zparse.go"
-				if data[p] == 10 {
-					goto tr98
-				}
-				goto st58
-			tr96:
-				// line 111 "zparse.rl"
-				{
-					mark = p
-				}
-				goto st59
-			st59:
-				p++
-				if p == pe {
-					goto _test_eof59
-				}
-				fallthrough
-			case 59:
-				// line 1405 "zparse.go"
-				switch data[p] {
-				case 9:
-					goto tr96
-				case 10:
-					goto tr98
-				case 32:
-					goto tr96
-				}
-				goto tr95
-			tr9:
-				// line 120 "zparse.rl"
-				{ // ... 
-				}
-				goto st60
-			st60:
-				p++
-				if p == pe {
-					goto _test_eof60
-				}
-				fallthrough
-			case 60:
-				// line 1421 "zparse.go"
-				switch data[p] {
-				case 65:
-					goto st61
-				case 83:
-					goto st68
-				case 97:
-					goto st61
-				case 115:
-					goto st68
-				}
-				goto st0
-			st61:
-				p++
-				if p == pe {
-					goto _test_eof61
-				}
-				fallthrough
-			case 61:
-				switch data[p] {
-				case 80:
-					goto st62
-				case 112:
-					goto st62
-				}
-				goto st0
-			st62:
-				p++
-				if p == pe {
-					goto _test_eof62
-				}
-				fallthrough
-			case 62:
-				switch data[p] {
-				case 84:
-					goto st63
-				case 116:
-					goto st63
-				}
-				goto st0
-			st63:
-				p++
-				if p == pe {
-					goto _test_eof63
-				}
-				fallthrough
-			case 63:
-				switch data[p] {
-				case 82:
-					goto st64
-				case 114:
-					goto st64
-				}
-				goto st0
-			st64:
-				p++
-				if p == pe {
-					goto _test_eof64
-				}
-				fallthrough
-			case 64:
-				switch data[p] {
-				case 9:
-					goto st65
-				case 32:
-					goto st65
-				}
-				goto st0
-			st65:
-				p++
-				if p == pe {
-					goto _test_eof65
-				}
-				fallthrough
-			case 65:
-				switch data[p] {
-				case 9:
-					goto tr106
-				case 10:
-					goto st0
-				case 32:
-					goto tr106
-				}
-				goto tr105
-			tr105:
-				// line 111 "zparse.rl"
-				{
-					mark = p
-				}
-				goto st66
-			st66:
-				p++
-				if p == pe {
-					goto _test_eof66
-				}
-				fallthrough
-			case 66:
-				// line 1489 "zparse.go"
-				if data[p] == 10 {
-					goto tr108
-				}
-				goto st66
-			tr106:
-				// line 111 "zparse.rl"
-				{
-					mark = p
-				}
-				goto st67
-			st67:
-				p++
-				if p == pe {
-					goto _test_eof67
-				}
-				fallthrough
-			case 67:
-				// line 1501 "zparse.go"
-				switch data[p] {
-				case 9:
-					goto tr106
-				case 10:
-					goto tr108
-				case 32:
-					goto tr106
-				}
-				goto tr105
-			st68:
-				p++
-				if p == pe {
-					goto _test_eof68
-				}
-				fallthrough
-			case 68:
-				switch data[p] {
-				case 9:
-					goto st69
-				case 32:
-					goto st69
-				case 69:
-					goto st72
-				case 101:
-					goto st72
-				}
-				goto st0
-			st69:
-				p++
-				if p == pe {
-					goto _test_eof69
-				}
-				fallthrough
-			case 69:
-				switch data[p] {
-				case 9:
-					goto tr112
-				case 10:
-					goto st0
-				case 32:
-					goto tr112
-				}
-				goto tr111
-			tr111:
-				// line 111 "zparse.rl"
-				{
-					mark = p
-				}
-				goto st70
-			st70:
-				p++
-				if p == pe {
-					goto _test_eof70
-				}
-				fallthrough
-			case 70:
-				// line 1540 "zparse.go"
-				if data[p] == 10 {
-					goto tr114
-				}
-				goto st70
-			tr112:
-				// line 111 "zparse.rl"
-				{
-					mark = p
-				}
-				goto st71
-			st71:
-				p++
-				if p == pe {
-					goto _test_eof71
-				}
-				fallthrough
-			case 71:
-				// line 1552 "zparse.go"
-				switch data[p] {
-				case 9:
-					goto tr112
-				case 10:
-					goto tr114
-				case 32:
-					goto tr112
-				}
-				goto tr111
-			st72:
-				p++
-				if p == pe {
-					goto _test_eof72
-				}
-				fallthrough
-			case 72:
-				switch data[p] {
-				case 67:
-					goto st73
-				case 99:
-					goto st73
-				}
-				goto st0
-			st73:
-				p++
-				if p == pe {
-					goto _test_eof73
-				}
-				fallthrough
-			case 73:
-				switch data[p] {
-				case 9:
-					goto st74
-				case 32:
-					goto st74
-				case 51:
-					goto st77
-				}
-				goto st0
-			st74:
-				p++
-				if p == pe {
-					goto _test_eof74
-				}
-				fallthrough
-			case 74:
-				switch data[p] {
-				case 9:
-					goto tr119
-				case 10:
-					goto st0
-				case 32:
-					goto tr119
-				}
-				goto tr118
-			tr118:
-				// line 111 "zparse.rl"
-				{
-					mark = p
-				}
-				goto st75
-			st75:
-				p++
-				if p == pe {
-					goto _test_eof75
-				}
-				fallthrough
-			case 75:
-				// line 1600 "zparse.go"
-				if data[p] == 10 {
-					goto tr121
-				}
-				goto st75
-			tr119:
-				// line 111 "zparse.rl"
-				{
-					mark = p
-				}
-				goto st76
-			st76:
-				p++
-				if p == pe {
-					goto _test_eof76
-				}
-				fallthrough
-			case 76:
-				// line 1612 "zparse.go"
-				switch data[p] {
-				case 9:
-					goto tr119
-				case 10:
-					goto tr121
-				case 32:
-					goto tr119
-				}
-				goto tr118
-			st77:
-				p++
-				if p == pe {
-					goto _test_eof77
-				}
-				fallthrough
-			case 77:
-				switch data[p] {
-				case 9:
-					goto st78
-				case 32:
-					goto st78
-				case 80:
-					goto st81
-				case 112:
-					goto st81
-				}
-				goto st0
-			st78:
-				p++
-				if p == pe {
-					goto _test_eof78
-				}
-				fallthrough
-			case 78:
-				switch data[p] {
-				case 9:
-					goto tr125
-				case 10:
-					goto st0
-				case 32:
-					goto tr125
-				}
-				goto tr124
-			tr124:
-				// line 111 "zparse.rl"
-				{
-					mark = p
-				}
-				goto st79
-			st79:
-				p++
-				if p == pe {
-					goto _test_eof79
-				}
-				fallthrough
-			case 79:
-				// line 1651 "zparse.go"
-				if data[p] == 10 {
-					goto tr127
-				}
-				goto st79
-			tr125:
-				// line 111 "zparse.rl"
-				{
-					mark = p
-				}
-				goto st80
-			st80:
-				p++
-				if p == pe {
-					goto _test_eof80
-				}
-				fallthrough
-			case 80:
-				// line 1663 "zparse.go"
-				switch data[p] {
-				case 9:
-					goto tr125
-				case 10:
-					goto tr127
-				case 32:
-					goto tr125
-				}
-				goto tr124
-			st81:
-				p++
-				if p == pe {
-					goto _test_eof81
-				}
-				fallthrough
-			case 81:
-				switch data[p] {
-				case 65:
-					goto st82
-				case 97:
-					goto st82
-				}
-				goto st0
-			st82:
-				p++
-				if p == pe {
-					goto _test_eof82
-				}
-				fallthrough
-			case 82:
-				switch data[p] {
-				case 82:
-					goto st83
-				case 114:
-					goto st83
-				}
-				goto st0
-			st83:
-				p++
-				if p == pe {
-					goto _test_eof83
-				}
-				fallthrough
-			case 83:
-				switch data[p] {
-				case 65:
-					goto st84
-				case 97:
-					goto st84
-				}
-				goto st0
-			st84:
-				p++
-				if p == pe {
-					goto _test_eof84
-				}
-				fallthrough
-			case 84:
-				switch data[p] {
-				case 77:
-					goto st85
-				case 109:
-					goto st85
-				}
-				goto st0
-			st85:
-				p++
-				if p == pe {
-					goto _test_eof85
-				}
-				fallthrough
-			case 85:
-				switch data[p] {
-				case 9:
-					goto st86
-				case 32:
-					goto st86
-				}
-				goto st0
-			st86:
-				p++
-				if p == pe {
-					goto _test_eof86
-				}
-				fallthrough
-			case 86:
-				switch data[p] {
-				case 9:
-					goto tr134
-				case 10:
-					goto st0
-				case 32:
-					goto tr134
-				}
-				goto tr133
-			tr133:
-				// line 111 "zparse.rl"
-				{
-					mark = p
-				}
-				goto st87
-			st87:
-				p++
-				if p == pe {
-					goto _test_eof87
-				}
-				fallthrough
-			case 87:
-				// line 1740 "zparse.go"
-				if data[p] == 10 {
-					goto tr136
-				}
-				goto st87
-			tr134:
-				// line 111 "zparse.rl"
-				{
-					mark = p
-				}
-				goto st88
-			st88:
-				p++
-				if p == pe {
-					goto _test_eof88
-				}
-				fallthrough
-			case 88:
-				// line 1752 "zparse.go"
-				switch data[p] {
-				case 9:
-					goto tr134
-				case 10:
-					goto tr136
-				case 32:
-					goto tr134
-				}
-				goto tr133
-			tr10:
-				// line 120 "zparse.rl"
-				{ // ... 
-				}
-				goto st89
-			st89:
-				p++
-				if p == pe {
-					goto _test_eof89
-				}
-				fallthrough
-			case 89:
-				// line 1768 "zparse.go"
-				switch data[p] {
-				case 84:
-					goto st90
-				case 116:
-					goto st90
-				}
-				goto st0
-			st90:
-				p++
-				if p == pe {
-					goto _test_eof90
-				}
-				fallthrough
-			case 90:
-				switch data[p] {
-				case 82:
-					goto st91
-				case 114:
-					goto st91
-				}
-				goto st0
-			st91:
-				p++
-				if p == pe {
-					goto _test_eof91
-				}
-				fallthrough
-			case 91:
-				switch data[p] {
-				case 9:
-					goto st92
-				case 32:
-					goto st92
-				}
-				goto st0
-			st92:
-				p++
-				if p == pe {
-					goto _test_eof92
-				}
-				fallthrough
-			case 92:
-				switch data[p] {
-				case 9:
-					goto tr141
-				case 10:
-					goto st0
-				case 32:
-					goto tr141
-				}
-				goto tr140
-			tr140:
-				// line 111 "zparse.rl"
-				{
-					mark = p
-				}
-				goto st93
-			st93:
-				p++
-				if p == pe {
-					goto _test_eof93
-				}
-				fallthrough
-			case 93:
-				// line 1814 "zparse.go"
-				if data[p] == 10 {
-					goto tr143
-				}
-				goto st93
-			tr141:
-				// line 111 "zparse.rl"
-				{
-					mark = p
-				}
-				goto st94
-			st94:
-				p++
-				if p == pe {
-					goto _test_eof94
-				}
-				fallthrough
-			case 94:
-				// line 1826 "zparse.go"
-				switch data[p] {
-				case 9:
-					goto tr141
-				case 10:
-					goto tr143
-				case 32:
-					goto tr141
-				}
-				goto tr140
-			tr11:
-				// line 120 "zparse.rl"
-				{ // ... 
-				}
-				goto st95
-			st95:
-				p++
-				if p == pe {
-					goto _test_eof95
-				}
-				fallthrough
-			case 95:
-				// line 1842 "zparse.go"
-				switch data[p] {
-				case 82:
-					goto st96
-				case 114:
-					goto st96
-				}
-				goto st0
-			st96:
-				p++
-				if p == pe {
-					goto _test_eof96
-				}
-				fallthrough
-			case 96:
-				switch data[p] {
-				case 83:
-					goto st97
-				case 115:
-					goto st97
-				}
-				goto st0
-			st97:
-				p++
-				if p == pe {
-					goto _test_eof97
-				}
-				fallthrough
-			case 97:
-				switch data[p] {
-				case 73:
-					goto st98
-				case 105:
-					goto st98
-				}
-				goto st0
-			st98:
-				p++
-				if p == pe {
-					goto _test_eof98
-				}
-				fallthrough
-			case 98:
-				switch data[p] {
-				case 71:
-					goto st99
-				case 103:
-					goto st99
-				}
-				goto st0
-			st99:
-				p++
-				if p == pe {
-					goto _test_eof99
-				}
-				fallthrough
-			case 99:
-				switch data[p] {
-				case 9:
-					goto st100
-				case 32:
-					goto st100
-				}
-				goto st0
-			st100:
-				p++
-				if p == pe {
-					goto _test_eof100
-				}
-				fallthrough
-			case 100:
-				switch data[p] {
-				case 9:
-					goto tr150
-				case 10:
-					goto st0
-				case 32:
-					goto tr150
-				}
-				goto tr149
-			tr149:
-				// line 111 "zparse.rl"
-				{
-					mark = p
-				}
-				goto st101
-			st101:
-				p++
-				if p == pe {
-					goto _test_eof101
-				}
-				fallthrough
-			case 101:
-				// line 1908 "zparse.go"
-				if data[p] == 10 {
-					goto tr152
-				}
-				goto st101
-			tr150:
-				// line 111 "zparse.rl"
-				{
-					mark = p
-				}
-				goto st102
-			st102:
-				p++
-				if p == pe {
-					goto _test_eof102
-				}
-				fallthrough
-			case 102:
-				// line 1920 "zparse.go"
-				switch data[p] {
-				case 9:
-					goto tr150
-				case 10:
-					goto tr152
-				case 32:
-					goto tr150
-				}
-				goto tr149
-			tr12:
-				// line 120 "zparse.rl"
-				{ // ... 
-				}
-				goto st103
-			st103:
-				p++
-				if p == pe {
-					goto _test_eof103
-				}
-				fallthrough
-			case 103:
-				// line 1936 "zparse.go"
-				switch data[p] {
-				case 79:
-					goto st104
-				case 82:
-					goto st109
-				case 83:
-					goto st114
-				case 111:
-					goto st104
-				case 114:
-					goto st109
-				case 115:
-					goto st114
-				}
-				goto st0
-			st104:
-				p++
-				if p == pe {
-					goto _test_eof104
-				}
-				fallthrough
-			case 104:
-				switch data[p] {
-				case 65:
-					goto st105
-				case 97:
-					goto st105
-				}
-				goto st0
-			st105:
-				p++
-				if p == pe {
-					goto _test_eof105
-				}
-				fallthrough
-			case 105:
-				switch data[p] {
-				case 9:
-					goto st106
-				case 32:
-					goto st106
-				}
-				goto st0
-			st106:
-				p++
-				if p == pe {
-					goto _test_eof106
-				}
-				fallthrough
-			case 106:
-				switch data[p] {
-				case 9:
-					goto tr159
-				case 10:
-					goto st0
-				case 32:
-					goto tr159
-				}
-				goto tr158
-			tr158:
-				// line 111 "zparse.rl"
-				{
-					mark = p
-				}
-				goto st107
-			st107:
-				p++
-				if p == pe {
-					goto _test_eof107
-				}
-				fallthrough
-			case 107:
-				// line 1986 "zparse.go"
-				if data[p] == 10 {
-					goto tr161
-				}
-				goto st107
-			tr159:
-				// line 111 "zparse.rl"
-				{
-					mark = p
-				}
-				goto st108
-			st108:
-				p++
-				if p == pe {
-					goto _test_eof108
-				}
-				fallthrough
-			case 108:
-				// line 1998 "zparse.go"
-				switch data[p] {
-				case 9:
-					goto tr159
-				case 10:
-					goto tr161
-				case 32:
-					goto tr159
-				}
-				goto tr158
-			st109:
-				p++
-				if p == pe {
-					goto _test_eof109
-				}
-				fallthrough
-			case 109:
-				switch data[p] {
-				case 86:
-					goto st110
-				case 118:
-					goto st110
-				}
-				goto st0
-			st110:
-				p++
-				if p == pe {
-					goto _test_eof110
-				}
-				fallthrough
-			case 110:
-				switch data[p] {
-				case 9:
-					goto st111
-				case 32:
-					goto st111
-				}
-				goto st0
-			st111:
-				p++
-				if p == pe {
-					goto _test_eof111
-				}
-				fallthrough
-			case 111:
-				switch data[p] {
-				case 9:
-					goto tr165
-				case 10:
-					goto st0
-				case 32:
-					goto tr165
-				}
-				goto tr164
-			tr164:
-				// line 111 "zparse.rl"
-				{
-					mark = p
-				}
-				goto st112
-			st112:
-				p++
-				if p == pe {
-					goto _test_eof112
-				}
-				fallthrough
-			case 112:
-				// line 2045 "zparse.go"
-				if data[p] == 10 {
-					goto tr167
-				}
-				goto st112
-			tr165:
-				// line 111 "zparse.rl"
-				{
-					mark = p
-				}
-				goto st113
-			st113:
-				p++
-				if p == pe {
-					goto _test_eof113
-				}
-				fallthrough
-			case 113:
-				// line 2057 "zparse.go"
-				switch data[p] {
-				case 9:
-					goto tr165
-				case 10:
-					goto tr167
-				case 32:
-					goto tr165
-				}
-				goto tr164
-			st114:
-				p++
-				if p == pe {
-					goto _test_eof114
-				}
-				fallthrough
-			case 114:
-				switch data[p] {
-				case 72:
-					goto st115
-				case 104:
-					goto st115
-				}
-				goto st0
-			st115:
-				p++
-				if p == pe {
-					goto _test_eof115
-				}
-				fallthrough
-			case 115:
-				switch data[p] {
-				case 70:
-					goto st116
-				case 102:
-					goto st116
-				}
-				goto st0
-			st116:
-				p++
-				if p == pe {
-					goto _test_eof116
-				}
-				fallthrough
-			case 116:
-				switch data[p] {
-				case 80:
-					goto st117
-				case 112:
-					goto st117
-				}
-				goto st0
-			st117:
-				p++
-				if p == pe {
-					goto _test_eof117
-				}
-				fallthrough
-			case 117:
-				switch data[p] {
-				case 9:
-					goto st118
-				case 32:
-					goto st118
-				}
-				goto st0
-			st118:
-				p++
-				if p == pe {
-					goto _test_eof118
-				}
-				fallthrough
-			case 118:
-				switch data[p] {
-				case 9:
-					goto tr173
-				case 10:
-					goto st0
-				case 32:
-					goto tr173
-				}
-				goto tr172
-			tr172:
-				// line 111 "zparse.rl"
-				{
-					mark = p
-				}
-				goto st119
-			st119:
-				p++
-				if p == pe {
-					goto _test_eof119
-				}
-				fallthrough
-			case 119:
-				// line 2124 "zparse.go"
-				if data[p] == 10 {
-					goto tr175
-				}
-				goto st119
-			tr173:
-				// line 111 "zparse.rl"
-				{
-					mark = p
-				}
-				goto st120
-			st120:
-				p++
-				if p == pe {
-					goto _test_eof120
-				}
-				fallthrough
-			case 120:
-				// line 2136 "zparse.go"
-				switch data[p] {
-				case 9:
-					goto tr173
-				case 10:
-					goto tr175
-				case 32:
-					goto tr173
-				}
-				goto tr172
-			tr13:
-				// line 120 "zparse.rl"
-				{ // ... 
-				}
-				goto st121
-			st121:
-				p++
-				if p == pe {
-					goto _test_eof121
-				}
-				fallthrough
-			case 121:
-				// line 2152 "zparse.go"
-				switch data[p] {
-				case 65:
-					goto st122
-				case 88:
-					goto st126
-				case 97:
-					goto st122
-				case 120:
-					goto st126
-				}
-				goto st0
-			st122:
-				p++
-				if p == pe {
-					goto _test_eof122
-				}
-				fallthrough
-			case 122:
-				switch data[p] {
-				case 9:
-					goto st123
-				case 32:
-					goto st123
-				}
-				goto st0
-			st123:
-				p++
-				if p == pe {
-					goto _test_eof123
-				}
-				fallthrough
-			case 123:
-				switch data[p] {
-				case 9:
-					goto tr180
-				case 10:
-					goto st0
-				case 32:
-					goto tr180
-				}
-				goto tr179
-			tr179:
-				// line 111 "zparse.rl"
-				{
-					mark = p
-				}
-				goto st124
-			st124:
-				p++
-				if p == pe {
-					goto _test_eof124
-				}
-				fallthrough
-			case 124:
-				// line 2190 "zparse.go"
-				if data[p] == 10 {
-					goto tr182
-				}
-				goto st124
-			tr180:
-				// line 111 "zparse.rl"
-				{
-					mark = p
-				}
-				goto st125
-			st125:
-				p++
-				if p == pe {
-					goto _test_eof125
-				}
-				fallthrough
-			case 125:
-				// line 2202 "zparse.go"
-				switch data[p] {
-				case 9:
-					goto tr180
-				case 10:
-					goto tr182
-				case 32:
-					goto tr180
-				}
-				goto tr179
-			st126:
-				p++
-				if p == pe {
-					goto _test_eof126
-				}
-				fallthrough
-			case 126:
-				switch data[p] {
-				case 84:
-					goto st127
-				case 116:
-					goto st127
-				}
-				goto st0
-			st127:
-				p++
-				if p == pe {
-					goto _test_eof127
-				}
-				fallthrough
-			case 127:
-				switch data[p] {
-				case 9:
-					goto st128
-				case 32:
-					goto st128
-				}
-				goto st0
-			st128:
-				p++
-				if p == pe {
-					goto _test_eof128
-				}
-				fallthrough
-			case 128:
-				switch data[p] {
-				case 9:
-					goto tr186
-				case 10:
-					goto st0
-				case 32:
-					goto tr186
-				}
-				goto tr185
-			tr185:
-				// line 111 "zparse.rl"
-				{
-					mark = p
-				}
-				goto st129
-			st129:
-				p++
-				if p == pe {
-					goto _test_eof129
-				}
-				fallthrough
-			case 129:
-				// line 2249 "zparse.go"
-				if data[p] == 10 {
-					goto tr188
-				}
-				goto st129
-			tr186:
-				// line 111 "zparse.rl"
-				{
-					mark = p
-				}
-				goto st130
-			st130:
-				p++
-				if p == pe {
-					goto _test_eof130
-				}
-				fallthrough
-			case 130:
-				// line 2261 "zparse.go"
-				switch data[p] {
-				case 9:
-					goto tr186
-				case 10:
-					goto tr188
-				case 32:
-					goto tr186
-				}
-				goto tr185
-			tr20:
-				// line 111 "zparse.rl"
-				{
-					mark = p
-				}
-				goto st131
-			st131:
-				p++
-				if p == pe {
-					goto _test_eof131
-				}
-				fallthrough
-			case 131:
-				// line 2277 "zparse.go"
-				switch data[p] {
-				case 83:
-					goto st21
-				case 115:
-					goto st21
-				}
-				goto st0
-			tr21:
-				// line 111 "zparse.rl"
-				{
-					mark = p
-				}
-				goto st132
-			st132:
-				p++
-				if p == pe {
-					goto _test_eof132
-				}
-				fallthrough
-			case 132:
-				// line 2292 "zparse.go"
-				switch data[p] {
-				case 78:
-					goto st21
-				case 110:
-					goto st21
-				}
-				goto st0
-			tr4:
-				// line 120 "zparse.rl"
-				{ // ...
-				}
-				// line 111 "zparse.rl"
-				{
-					mark = p
-				}
-				goto st133
-			st133:
-				p++
-				if p == pe {
-					goto _test_eof133
-				}
-				fallthrough
-			case 133:
-				// line 2309 "zparse.go"
-				switch data[p] {
-				case 69:
-					goto st15
-				case 72:
-					goto st134
-				case 78:
-					goto st24
-				case 101:
-					goto st15
-				case 104:
-					goto st134
-				case 110:
-					goto st24
-				}
-				goto st0
-			st134:
-				p++
-				if p == pe {
-					goto _test_eof134
-				}
-				fallthrough
-			case 134:
-				switch data[p] {
-				case 9:
-					goto tr190
-				case 32:
-					goto tr190
-				}
-				goto st0
-			tr190:
-				// line 119 "zparse.rl"
-				{
-					hdr.Class = str_class[data[mark:p]]
-				}
-				goto st135
-			st135:
-				p++
-				if p == pe {
-					goto _test_eof135
-				}
-				fallthrough
-			case 135:
-				// line 2338 "zparse.go"
-				switch data[p] {
-				case 9:
-					goto st135
-				case 32:
-					goto st135
-				case 65:
-					goto st4
-				case 67:
-					goto st23
-				case 68:
-					goto st31
-				case 77:
-					goto st55
-				case 78:
-					goto st60
-				case 80:
-					goto st89
-				case 82:
-					goto st95
-				case 83:
-					goto st103
-				case 84:
-					goto st121
-				case 97:
-					goto st4
-				case 99:
-					goto st23
-				case 100:
-					goto st31
-				case 109:
-					goto st55
-				case 110:
-					goto st60
-				case 112:
-					goto st89
-				case 114:
-					goto st95
-				case 115:
-					goto st103
-				case 116:
-					goto st121
-				}
-				if 48 <= data[p] && data[p] <= 57 {
-					goto tr192
-				}
-				goto st0
-			tr192:
-				// line 111 "zparse.rl"
-				{
-					mark = p
-				}
-				goto st136
-			st136:
-				p++
-				if p == pe {
-					goto _test_eof136
-				}
-				fallthrough
-			case 136:
-				// line 2372 "zparse.go"
-				switch data[p] {
-				case 9:
-					goto tr193
-				case 32:
-					goto tr193
-				}
-				if 48 <= data[p] && data[p] <= 57 {
-					goto st136
-				}
-				goto st0
-			tr6:
-				// line 120 "zparse.rl"
-				{ // ... 
-				}
-				// line 111 "zparse.rl"
-				{
-					mark = p
-				}
-				goto st137
-			st137:
-				p++
-				if p == pe {
-					goto _test_eof137
-				}
-				fallthrough
-			case 137:
-				// line 2390 "zparse.go"
-				switch data[p] {
-				case 83:
-					goto st134
-				case 115:
-					goto st134
-				}
-				goto st0
-			tr7:
-				// line 120 "zparse.rl"
-				{ // ...
-				}
-				// line 111 "zparse.rl"
-				{
-					mark = p
-				}
-				goto st138
-			st138:
-				p++
-				if p == pe {
-					goto _test_eof138
-				}
-				fallthrough
-			case 138:
-				// line 2407 "zparse.go"
-				switch data[p] {
-				case 78:
-					goto st134
-				case 110:
-					goto st134
-				}
-				goto st0
-			tr199:
-				// line 111 "zparse.rl"
-				{
-					mark = p
-				}
-				goto st139
-			st139:
-				p++
-				if p == pe {
-					goto _test_eof139
-				}
-				fallthrough
-			case 139:
-				// line 2422 "zparse.go"
-				switch data[p] {
-				case 9:
-					goto tr195
-				case 32:
-					goto tr195
-				case 42:
-					goto st139
-				case 95:
-					goto st139
-				}
-				if data[p] < 48 {
-					if 45 <= data[p] && data[p] <= 46 {
-						goto st139
-					}
-				} else if data[p] > 57 {
-					if data[p] > 90 {
-						if 97 <= data[p] && data[p] <= 122 {
-							goto st139
-						}
-					} else if data[p] >= 65 {
-						goto st139
-					}
-				} else {
-					goto st139
-				}
-				goto st0
-			st140:
-				p++
-				if p == pe {
-					goto _test_eof140
-				}
-				fallthrough
-			case 140:
-				if data[p] == 10 {
-					goto tr198
-				}
-				goto st140
-			}
-		_test_eof141:
-			cs = 141
-			goto _test_eof
-		_test_eof1:
-			cs = 1
-			goto _test_eof
-		_test_eof2:
-			cs = 2
-			goto _test_eof
-		_test_eof3:
-			cs = 3
-			goto _test_eof
-		_test_eof4:
-			cs = 4
-			goto _test_eof
-		_test_eof5:
-			cs = 5
-			goto _test_eof
-		_test_eof6:
-			cs = 6
-			goto _test_eof
-		_test_eof7:
-			cs = 7
-			goto _test_eof
-		_test_eof8:
-			cs = 8
-			goto _test_eof
-		_test_eof9:
-			cs = 9
-			goto _test_eof
-		_test_eof10:
-			cs = 10
-			goto _test_eof
-		_test_eof11:
-			cs = 11
-			goto _test_eof
-		_test_eof12:
-			cs = 12
-			goto _test_eof
-		_test_eof13:
-			cs = 13
-			goto _test_eof
-		_test_eof14:
-			cs = 14
-			goto _test_eof
-		_test_eof15:
-			cs = 15
-			goto _test_eof
-		_test_eof16:
-			cs = 16
-			goto _test_eof
-		_test_eof17:
-			cs = 17
-			goto _test_eof
-		_test_eof18:
-			cs = 18
-			goto _test_eof
-		_test_eof19:
-			cs = 19
-			goto _test_eof
-		_test_eof20:
-			cs = 20
-			goto _test_eof
-		_test_eof21:
-			cs = 21
-			goto _test_eof
-		_test_eof22:
-			cs = 22
-			goto _test_eof
-		_test_eof23:
-			cs = 23
-			goto _test_eof
-		_test_eof24:
-			cs = 24
-			goto _test_eof
-		_test_eof25:
-			cs = 25
-			goto _test_eof
-		_test_eof26:
-			cs = 26
-			goto _test_eof
-		_test_eof27:
-			cs = 27
-			goto _test_eof
-		_test_eof28:
-			cs = 28
-			goto _test_eof
-		_test_eof29:
-			cs = 29
-			goto _test_eof
-		_test_eof30:
-			cs = 30
-			goto _test_eof
-		_test_eof31:
-			cs = 31
-			goto _test_eof
-		_test_eof32:
-			cs = 32
-			goto _test_eof
-		_test_eof33:
-			cs = 33
-			goto _test_eof
-		_test_eof34:
-			cs = 34
-			goto _test_eof
-		_test_eof35:
-			cs = 35
-			goto _test_eof
-		_test_eof36:
-			cs = 36
-			goto _test_eof
-		_test_eof37:
-			cs = 37
-			goto _test_eof
-		_test_eof38:
-			cs = 38
-			goto _test_eof
-		_test_eof39:
-			cs = 39
-			goto _test_eof
-		_test_eof40:
-			cs = 40
-			goto _test_eof
-		_test_eof41:
-			cs = 41
-			goto _test_eof
-		_test_eof42:
-			cs = 42
-			goto _test_eof
-		_test_eof43:
-			cs = 43
-			goto _test_eof
-		_test_eof44:
-			cs = 44
-			goto _test_eof
-		_test_eof45:
-			cs = 45
-			goto _test_eof
-		_test_eof46:
-			cs = 46
-			goto _test_eof
-		_test_eof47:
-			cs = 47
-			goto _test_eof
-		_test_eof48:
-			cs = 48
-			goto _test_eof
-		_test_eof49:
-			cs = 49
-			goto _test_eof
-		_test_eof50:
-			cs = 50
-			goto _test_eof
-		_test_eof51:
-			cs = 51
-			goto _test_eof
-		_test_eof52:
-			cs = 52
-			goto _test_eof
-		_test_eof53:
-			cs = 53
-			goto _test_eof
-		_test_eof54:
-			cs = 54
-			goto _test_eof
-		_test_eof55:
-			cs = 55
-			goto _test_eof
-		_test_eof56:
-			cs = 56
-			goto _test_eof
-		_test_eof57:
-			cs = 57
-			goto _test_eof
-		_test_eof58:
-			cs = 58
-			goto _test_eof
-		_test_eof59:
-			cs = 59
-			goto _test_eof
-		_test_eof60:
-			cs = 60
-			goto _test_eof
-		_test_eof61:
-			cs = 61
-			goto _test_eof
-		_test_eof62:
-			cs = 62
-			goto _test_eof
-		_test_eof63:
-			cs = 63
-			goto _test_eof
-		_test_eof64:
-			cs = 64
-			goto _test_eof
-		_test_eof65:
-			cs = 65
-			goto _test_eof
-		_test_eof66:
-			cs = 66
-			goto _test_eof
-		_test_eof67:
-			cs = 67
-			goto _test_eof
-		_test_eof68:
-			cs = 68
-			goto _test_eof
-		_test_eof69:
-			cs = 69
-			goto _test_eof
-		_test_eof70:
-			cs = 70
-			goto _test_eof
-		_test_eof71:
-			cs = 71
-			goto _test_eof
-		_test_eof72:
-			cs = 72
-			goto _test_eof
-		_test_eof73:
-			cs = 73
-			goto _test_eof
-		_test_eof74:
-			cs = 74
-			goto _test_eof
-		_test_eof75:
-			cs = 75
-			goto _test_eof
-		_test_eof76:
-			cs = 76
-			goto _test_eof
-		_test_eof77:
-			cs = 77
-			goto _test_eof
-		_test_eof78:
-			cs = 78
-			goto _test_eof
-		_test_eof79:
-			cs = 79
-			goto _test_eof
-		_test_eof80:
-			cs = 80
-			goto _test_eof
-		_test_eof81:
-			cs = 81
-			goto _test_eof
-		_test_eof82:
-			cs = 82
-			goto _test_eof
-		_test_eof83:
-			cs = 83
-			goto _test_eof
-		_test_eof84:
-			cs = 84
-			goto _test_eof
-		_test_eof85:
-			cs = 85
-			goto _test_eof
-		_test_eof86:
-			cs = 86
-			goto _test_eof
-		_test_eof87:
-			cs = 87
-			goto _test_eof
-		_test_eof88:
-			cs = 88
-			goto _test_eof
-		_test_eof89:
-			cs = 89
-			goto _test_eof
-		_test_eof90:
-			cs = 90
-			goto _test_eof
-		_test_eof91:
-			cs = 91
-			goto _test_eof
-		_test_eof92:
-			cs = 92
-			goto _test_eof
-		_test_eof93:
-			cs = 93
-			goto _test_eof
-		_test_eof94:
-			cs = 94
-			goto _test_eof
-		_test_eof95:
-			cs = 95
-			goto _test_eof
-		_test_eof96:
-			cs = 96
-			goto _test_eof
-		_test_eof97:
-			cs = 97
-			goto _test_eof
-		_test_eof98:
-			cs = 98
-			goto _test_eof
-		_test_eof99:
-			cs = 99
-			goto _test_eof
-		_test_eof100:
-			cs = 100
-			goto _test_eof
-		_test_eof101:
-			cs = 101
-			goto _test_eof
-		_test_eof102:
-			cs = 102
-			goto _test_eof
-		_test_eof103:
-			cs = 103
-			goto _test_eof
-		_test_eof104:
-			cs = 104
-			goto _test_eof
-		_test_eof105:
-			cs = 105
-			goto _test_eof
-		_test_eof106:
-			cs = 106
-			goto _test_eof
-		_test_eof107:
-			cs = 107
-			goto _test_eof
-		_test_eof108:
-			cs = 108
-			goto _test_eof
-		_test_eof109:
-			cs = 109
-			goto _test_eof
-		_test_eof110:
-			cs = 110
-			goto _test_eof
-		_test_eof111:
-			cs = 111
-			goto _test_eof
-		_test_eof112:
-			cs = 112
-			goto _test_eof
-		_test_eof113:
-			cs = 113
-			goto _test_eof
-		_test_eof114:
-			cs = 114
-			goto _test_eof
-		_test_eof115:
-			cs = 115
-			goto _test_eof
-		_test_eof116:
-			cs = 116
-			goto _test_eof
-		_test_eof117:
-			cs = 117
-			goto _test_eof
-		_test_eof118:
-			cs = 118
-			goto _test_eof
-		_test_eof119:
-			cs = 119
-			goto _test_eof
-		_test_eof120:
-			cs = 120
-			goto _test_eof
-		_test_eof121:
-			cs = 121
-			goto _test_eof
-		_test_eof122:
-			cs = 122
-			goto _test_eof
-		_test_eof123:
-			cs = 123
-			goto _test_eof
-		_test_eof124:
-			cs = 124
-			goto _test_eof
-		_test_eof125:
-			cs = 125
-			goto _test_eof
-		_test_eof126:
-			cs = 126
-			goto _test_eof
-		_test_eof127:
-			cs = 127
-			goto _test_eof
-		_test_eof128:
-			cs = 128
-			goto _test_eof
-		_test_eof129:
-			cs = 129
-			goto _test_eof
-		_test_eof130:
-			cs = 130
-			goto _test_eof
-		_test_eof131:
-			cs = 131
-			goto _test_eof
-		_test_eof132:
-			cs = 132
-			goto _test_eof
-		_test_eof133:
-			cs = 133
-			goto _test_eof
-		_test_eof134:
-			cs = 134
-			goto _test_eof
-		_test_eof135:
-			cs = 135
-			goto _test_eof
-		_test_eof136:
-			cs = 136
-			goto _test_eof
-		_test_eof137:
-			cs = 137
-			goto _test_eof
-		_test_eof138:
-			cs = 138
-			goto _test_eof
-		_test_eof139:
-			cs = 139
-			goto _test_eof
-		_test_eof140:
-			cs = 140
-			goto _test_eof
-
-		_test_eof:
-			{
-			}
-		_out:
-			{
-			}
-		}
-
-		// line 178 "zparse.rl"
-
-
-		if eof > -1 {
-			if cs < z_first_final {
-				// No clue what I'm doing what so ever
-				if p == pe {
-					println("p", p, "pe", pe)
-					println("cs", cs, "z_first_final", z_first_final)
-					println("unexpected eof at line ", l)
-					return nil
-				} else {
-					println("error at position ", p, "\"", data[mark:p], "\" at line ", l)
-					return nil
-				}
-			}
-		}
-	*/
-	return nil
-}