diff --git a/keygen.go b/keygen.go
index 37fa1bed..ed3a418a 100644
--- a/keygen.go
+++ b/keygen.go
@@ -112,6 +112,7 @@ func (r *RR_DNSKEY) PrivateKeyString(p PrivateKey) (s string) {
 	return
 }
 
+// Do I want Read/SetString or both???
 func (k *RR_DNSKEY) Read(q io.Reader) os.Error {
         r, e := Zparse(q)
         if e != nil || r == nil {
diff --git a/parse_test.go b/parse_test.go
index 5b661897..c8d13e7d 100644
--- a/parse_test.go
+++ b/parse_test.go
@@ -131,7 +131,11 @@ func TestParse(t *testing.T) {
                         "nlnetlabs.nl.\t3175\tIN\tDNSKEY\t256 3 8 AwEAAdR7XR95OaAN9Rz7TbtPalQ9guQk7zfxTHYNKhsiwTZA9z+F16nD0VeBlk7dNik3ETpT2GLAwr9sntG898JwurCDe353wHPvjZtMCdiTVp3cRCrjuCEvoFpmZNN82H0gaH/4v8mkv/QBDAkDSncYjz/FqHKAeYy3cMcjY6RyVweh",
                 }
         for test, result := range tests {
-                r, _ := Zparse(strings.NewReader(test))
+                r, err := Zparse(strings.NewReader(test))
+                if err != nil || r == nil{
+                        t.Logf("Error of nil r %v %s\n", err, test)
+                        t.Fail()
+                }
                 if r.String() != result {
                         t.Logf("\"%s\" should be equal to\n\"%s\"\n", r, result)
                         t.Fail()
@@ -139,9 +143,18 @@ func TestParse(t *testing.T) {
         }
 }
 
-// 
 func TestSetString(t *testing.T) {
         a := new(RR_A)
         a.SetString("miek.nl. IN A 127.0.0.1")
-        println(a.String())
+        t.Log(a.String())
+        b := new(RR_AAAA)
+        b.SetString("miek.nl. IN AAAA ::1")
+        t.Log(b.String())
+        c := new(RR_MX)
+        c.SetString("miek.nl. IN MX 10 miek.nl.")
+        t.Log(c.String())
+        d := new(RR_NS)
+        d.SetString("miek.nl. IN NS ns1.miek.nl")
+        t.Log(d.String())
+        t.Fail()
 }
diff --git a/types.go b/types.go
index 61ed1aa0..fcb93f7f 100644
--- a/types.go
+++ b/types.go
@@ -582,6 +582,27 @@ func (rr *RR_RRSIG) String() string {
 		" " + rr.Signature
 }
 
+func (rr *RR_RRSIG) SetString(s string) (*RR_RRSIG, bool) {
+        p := parse(s)
+        if p == nil {
+                return nil, false
+        }
+        if _, ok := p.(*RR_RRSIG); !ok {
+                return nil, false
+        }
+        rr.Hdr = p.(*RR_RRSIG).Hdr
+        rr.TypeCovered   = p.(*RR_RRSIG).TypeCovered
+        rr.Algorithm   = p.(*RR_RRSIG).Algorithm
+        rr.Labels   = p.(*RR_RRSIG).Labels
+        rr.OrigTtl   = p.(*RR_RRSIG).OrigTtl
+        rr.Expiration   = p.(*RR_RRSIG).Expiration
+        rr.Inception   = p.(*RR_RRSIG).Inception
+        rr.KeyTag   = p.(*RR_RRSIG).KeyTag
+        rr.SignerName   = p.(*RR_RRSIG).SignerName
+        rr.Signature   = p.(*RR_RRSIG).Signature
+        return rr, true
+}
+
 type RR_NSEC struct {
 	Hdr        RR_Header
 	NextDomain string   "domain-name"
@@ -727,6 +748,22 @@ func (rr *RR_DNSKEY) String() string {
 		" " + rr.PublicKey
 }
 
+func (rr *RR_DNSKEY) SetString(s string) (*RR_DNSKEY, bool) {
+        p := parse(s)
+        if p == nil {
+                return nil, false
+        }
+        if _, ok := p.(*RR_DNSKEY); !ok {
+                return nil, false
+        }
+        rr.Hdr = p.(*RR_DNSKEY).Hdr
+        rr.Flags   = p.(*RR_DNSKEY).Flags
+        rr.Protocol   = p.(*RR_DNSKEY).Protocol
+        rr.Algorithm   = p.(*RR_DNSKEY).Algorithm
+        rr.PublicKey   = p.(*RR_DNSKEY).PublicKey
+        return rr, true
+}
+
 type RR_NSEC3 struct {
 	Hdr        RR_Header
 	Hash       uint8
diff --git a/types.rl b/types.rl
index cbafddab..b19cc708 100644
--- a/types.rl
+++ b/types.rl
@@ -5,6 +5,10 @@
             rr.(*RR_A).Hdr = *hdr
             rr.(*RR_A).A = net.ParseIP(data[mark:p])
         }
+        action rdata_aaaa {
+            rr.(*RR_AAAA).Hdr = *hdr
+            rr.(*RR_AAAA).AAAA = net.ParseIP(data[mark:p])
+        }
         action rdata_ns {
             rr.(*RR_NS).Hdr = *hdr
             rr.(*RR_NS).Ns = tok.T[0]
diff --git a/zparse.go b/zparse.go
index 9558bfb5..0dabba63 100644
--- a/zparse.go
+++ b/zparse.go
@@ -61,7 +61,7 @@ func (to *token) reset() {
 
 // line 63 "zparse.go"
 var z_start int = 1
-var z_first_final int = 102
+var z_first_final int = 106
 var z_error int = 0
 
 var z_en_main int = 1
@@ -102,25 +102,25 @@ case 1:
 	switch data[p] {
 		case 9: goto st2
 		case 32: goto st2
-		case 46: goto st84
-		case 92: goto st84
+		case 46: goto st88
+		case 92: goto st88
 	}
 	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st84 }
+		if 48 <= data[p] && data[p] <= 57 { goto st88 }
 	} else if data[p] > 90 {
-		if 97 <= data[p] && data[p] <= 122 { goto st84 }
+		if 97 <= data[p] && data[p] <= 122 { goto st88 }
 	} else {
-		goto st84
+		goto st88
 	}
 	goto st0
 st0:
 cs = 0;
 	goto _out;
-tr158:
+tr164:
 // line 85 "zparse.rl"
 	{ hdr.Name = data[mark:p] }
 	goto st2
-tr170:
+tr176:
 // line 90 "zparse.rl"
 	{ tok.pushString(data[mark:p]) }
 // line 4 "types.rl"
@@ -129,19 +129,28 @@ tr170:
             rr.(*RR_A).A = net.ParseIP(data[mark:p])
         }
 	goto st2
-tr172:
+tr178:
 // line 90 "zparse.rl"
 	{ tok.pushString(data[mark:p]) }
-// line 12 "types.rl"
+// line 8 "types.rl"
+	{
+            rr.(*RR_AAAA).Hdr = *hdr
+            rr.(*RR_AAAA).AAAA = net.ParseIP(data[mark:p])
+        }
+	goto st2
+tr180:
+// line 90 "zparse.rl"
+	{ tok.pushString(data[mark:p]) }
+// line 16 "types.rl"
 	{
             rr.(*RR_CNAME).Hdr = *hdr
             rr.(*RR_CNAME).Cname = tok.T[0]
         }
 	goto st2
-tr174:
+tr182:
 // line 90 "zparse.rl"
 	{ tok.pushString(data[mark:p]) }
-// line 38 "types.rl"
+// line 42 "types.rl"
 	{
             rr.(*RR_DNSKEY).Hdr = *hdr;
             rr.(*RR_DNSKEY).Flags = uint16(tok.N[0])
@@ -150,10 +159,10 @@ tr174:
             rr.(*RR_DNSKEY).PublicKey = tok.T[0]
         }
 	goto st2
-tr176:
+tr184:
 // line 90 "zparse.rl"
 	{ tok.pushString(data[mark:p]) }
-// line 31 "types.rl"
+// line 35 "types.rl"
 	{
             rr.(*RR_DS).Hdr = *hdr;
             rr.(*RR_DS).KeyTag = uint16(tok.N[0])
@@ -162,29 +171,29 @@ tr176:
             rr.(*RR_DS).Digest = tok.T[0]
         }
 	goto st2
-tr178:
+tr186:
 // line 90 "zparse.rl"
 	{ tok.pushString(data[mark:p]) }
-// line 26 "types.rl"
+// line 30 "types.rl"
 	{
             rr.(*RR_MX).Hdr = *hdr;
             rr.(*RR_MX).Pref = uint16(tok.N[0])
             rr.(*RR_MX).Mx = tok.T[0]
         }
 	goto st2
-tr180:
+tr188:
 // line 90 "zparse.rl"
 	{ tok.pushString(data[mark:p]) }
-// line 8 "types.rl"
+// line 12 "types.rl"
 	{
             rr.(*RR_NS).Hdr = *hdr
             rr.(*RR_NS).Ns = tok.T[0]
         }
 	goto st2
-tr182:
+tr190:
 // line 90 "zparse.rl"
 	{ tok.pushString(data[mark:p]) }
-// line 45 "types.rl"
+// line 49 "types.rl"
 	{
             rr.(*RR_RRSIG).Hdr = *hdr;
             rr.(*RR_RRSIG).TypeCovered = uint16(tok.N[0])
@@ -198,10 +207,10 @@ tr182:
             rr.(*RR_RRSIG).Signature = tok.T[1]
         }
 	goto st2
-tr184:
+tr192:
 // line 89 "zparse.rl"
 	{ tok.pushInt(data[mark:p]) }
-// line 16 "types.rl"
+// line 20 "types.rl"
 	{
             rr.(*RR_SOA).Hdr = *hdr
             rr.(*RR_SOA).Ns = tok.T[0]
@@ -218,7 +227,7 @@ st2:
 	if p == pe { goto _test_eof2 }
 	fallthrough
 case 2:
-// line 222 "zparse.go"
+// line 231 "zparse.go"
 	switch data[p] {
 		case 9: goto st2
 		case 32: goto st2
@@ -254,7 +263,7 @@ st3:
 	if p == pe { goto _test_eof3 }
 	fallthrough
 case 3:
-// line 258 "zparse.go"
+// line 267 "zparse.go"
 	switch data[p] {
 		case 9: goto tr13
 		case 32: goto tr13
@@ -270,7 +279,7 @@ st4:
 	if p == pe { goto _test_eof4 }
 	fallthrough
 case 4:
-// line 274 "zparse.go"
+// line 283 "zparse.go"
 	switch data[p] {
 		case 9: goto st4
 		case 32: goto st4
@@ -303,12 +312,14 @@ st5:
 	if p == pe { goto _test_eof5 }
 	fallthrough
 case 5:
-// line 307 "zparse.go"
+// line 316 "zparse.go"
 	switch data[p] {
 		case 9: goto tr25
 		case 32: goto tr25
-		case 78: goto st7
-		case 110: goto st7
+		case 65: goto st7
+		case 78: goto st11
+		case 97: goto st7
+		case 110: goto st11
 	}
 	goto st0
 tr25:
@@ -328,716 +339,23 @@ st6:
 	if p == pe { goto _test_eof6 }
 	fallthrough
 case 6:
-// line 332 "zparse.go"
+// line 343 "zparse.go"
 	switch data[p] {
 		case 9: goto st6
 		case 32: goto st6
-		case 43: goto tr28
-		case 61: goto tr28
-		case 92: goto tr28
+		case 43: goto tr29
+		case 61: goto tr29
+		case 92: goto tr29
 	}
 	if data[p] < 65 {
-		if 46 <= data[p] && data[p] <= 57 { goto tr28 }
+		if 46 <= data[p] && data[p] <= 57 { goto tr29 }
 	} else if data[p] > 90 {
-		if 97 <= data[p] && data[p] <= 122 { goto tr28 }
+		if 97 <= data[p] && data[p] <= 122 { goto tr29 }
 	} else {
-		goto tr28
+		goto tr29
 	}
 	goto st0
-tr28:
-// line 84 "zparse.rl"
-	{ mark = p }
-	goto st102
-st102:
-	p++
-	if p == pe { goto _test_eof102 }
-	fallthrough
-case 102:
-// line 357 "zparse.go"
-	switch data[p] {
-		case 9: goto tr170
-		case 32: goto tr170
-		case 43: goto st102
-		case 61: goto st102
-		case 92: goto st102
-	}
-	if data[p] < 65 {
-		if 46 <= data[p] && data[p] <= 57 { goto st102 }
-	} else if data[p] > 90 {
-		if 97 <= data[p] && data[p] <= 122 { goto st102 }
-	} else {
-		goto st102
-	}
-	goto st0
-st7:
-	p++
-	if p == pe { goto _test_eof7 }
-	fallthrough
-case 7:
-	switch data[p] {
-		case 89: goto st8
-		case 121: goto st8
-	}
-	goto st0
-st8:
-	p++
-	if p == pe { goto _test_eof8 }
-	fallthrough
-case 8:
-	switch data[p] {
-		case 9: goto tr30
-		case 32: goto tr30
-	}
-	goto st0
-tr166:
-// line 88 "zparse.rl"
-	{ ttl, _ :=  strconv.Atoi(data[mark:p]); hdr.Ttl = uint32(ttl) }
-	goto st9
-tr30:
-// line 86 "zparse.rl"
-	{ hdr.Class = Str_class[data[mark:p]] }
-	goto st9
-st9:
-	p++
-	if p == pe { goto _test_eof9 }
-	fallthrough
-case 9:
-// line 406 "zparse.go"
-	switch data[p] {
-		case 9: goto st9
-		case 32: goto st9
-		case 65: goto tr32
-		case 67: goto tr33
-		case 68: goto tr18
-		case 77: goto tr21
-		case 78: goto tr34
-		case 82: goto tr23
-		case 83: goto tr24
-		case 97: goto tr32
-		case 99: goto tr33
-		case 100: goto tr18
-		case 109: goto tr21
-		case 110: goto tr34
-		case 114: goto tr23
-		case 115: goto tr24
-	}
-	goto st0
-tr32:
-// line 84 "zparse.rl"
-	{ mark = p }
-	goto st10
-st10:
-	p++
-	if p == pe { goto _test_eof10 }
-	fallthrough
-case 10:
-// line 435 "zparse.go"
-	switch data[p] {
-		case 9: goto tr25
-		case 32: goto tr25
-	}
-	goto st0
-tr33:
-// line 84 "zparse.rl"
-	{ mark = p }
-	goto st11
-st11:
-	p++
-	if p == pe { goto _test_eof11 }
-	fallthrough
-case 11:
-// line 450 "zparse.go"
-	switch data[p] {
-		case 78: goto st12
-		case 110: goto st12
-	}
-	goto st0
-st12:
-	p++
-	if p == pe { goto _test_eof12 }
-	fallthrough
-case 12:
-	switch data[p] {
-		case 65: goto st13
-		case 97: goto st13
-	}
-	goto st0
-st13:
-	p++
-	if p == pe { goto _test_eof13 }
-	fallthrough
-case 13:
-	switch data[p] {
-		case 77: goto st14
-		case 109: goto st14
-	}
-	goto st0
-st14:
-	p++
-	if p == pe { goto _test_eof14 }
-	fallthrough
-case 14:
-	switch data[p] {
-		case 69: goto st15
-		case 101: goto st15
-	}
-	goto st0
-st15:
-	p++
-	if p == pe { goto _test_eof15 }
-	fallthrough
-case 15:
-	switch data[p] {
-		case 9: goto tr39
-		case 32: goto tr39
-	}
-	goto st0
-tr39:
-// line 93 "zparse.rl"
-	{ 
-                    i := Str_rr[data[mark:p]]
-                    mk, known := rr_mk[int(i)]
-                    if ! known {
-                        // ...
-                    }
-                    rr = mk()
-                    hdr.Rrtype = i
-                }
-	goto st16
-st16:
-	p++
-	if p == pe { goto _test_eof16 }
-	fallthrough
-case 16:
-// line 513 "zparse.go"
-	switch data[p] {
-		case 9: goto st16
-		case 32: goto st16
-		case 43: goto tr41
-		case 61: goto tr41
-		case 92: goto tr41
-	}
-	if data[p] < 65 {
-		if 46 <= data[p] && data[p] <= 57 { goto tr41 }
-	} else if data[p] > 90 {
-		if 97 <= data[p] && data[p] <= 122 { goto tr41 }
-	} else {
-		goto tr41
-	}
-	goto st0
-tr41:
-// line 84 "zparse.rl"
-	{ mark = p }
-	goto st103
-st103:
-	p++
-	if p == pe { goto _test_eof103 }
-	fallthrough
-case 103:
-// line 538 "zparse.go"
-	switch data[p] {
-		case 9: goto tr172
-		case 32: goto tr172
-		case 43: goto st103
-		case 61: goto st103
-		case 92: goto st103
-	}
-	if data[p] < 65 {
-		if 46 <= data[p] && data[p] <= 57 { goto st103 }
-	} else if data[p] > 90 {
-		if 97 <= data[p] && data[p] <= 122 { goto st103 }
-	} else {
-		goto st103
-	}
-	goto st0
-tr6:
-// line 84 "zparse.rl"
-	{ mark = p }
-// line 87 "zparse.rl"
-	{ /* ... */ }
-	goto st17
-tr18:
-// line 84 "zparse.rl"
-	{ mark = p }
-	goto st17
-st17:
-	p++
-	if p == pe { goto _test_eof17 }
-	fallthrough
-case 17:
-// line 569 "zparse.go"
-	switch data[p] {
-		case 78: goto st18
-		case 83: goto st30
-		case 110: goto st18
-		case 115: goto st30
-	}
-	goto st0
-st18:
-	p++
-	if p == pe { goto _test_eof18 }
-	fallthrough
-case 18:
-	switch data[p] {
-		case 83: goto st19
-		case 115: goto st19
-	}
-	goto st0
-st19:
-	p++
-	if p == pe { goto _test_eof19 }
-	fallthrough
-case 19:
-	switch data[p] {
-		case 75: goto st20
-		case 107: goto st20
-	}
-	goto st0
-st20:
-	p++
-	if p == pe { goto _test_eof20 }
-	fallthrough
-case 20:
-	switch data[p] {
-		case 69: goto st21
-		case 101: goto st21
-	}
-	goto st0
-st21:
-	p++
-	if p == pe { goto _test_eof21 }
-	fallthrough
-case 21:
-	switch data[p] {
-		case 89: goto st22
-		case 121: goto st22
-	}
-	goto st0
-st22:
-	p++
-	if p == pe { goto _test_eof22 }
-	fallthrough
-case 22:
-	switch data[p] {
-		case 9: goto tr48
-		case 32: goto tr48
-	}
-	goto st0
-tr48:
-// line 93 "zparse.rl"
-	{ 
-                    i := Str_rr[data[mark:p]]
-                    mk, known := rr_mk[int(i)]
-                    if ! known {
-                        // ...
-                    }
-                    rr = mk()
-                    hdr.Rrtype = i
-                }
-	goto st23
-st23:
-	p++
-	if p == pe { goto _test_eof23 }
-	fallthrough
-case 23:
-// line 644 "zparse.go"
-	switch data[p] {
-		case 9: goto st23
-		case 32: goto st23
-	}
-	if 48 <= data[p] && data[p] <= 57 { goto tr50 }
-	goto st0
-tr50:
-// line 84 "zparse.rl"
-	{ mark = p }
-	goto st24
-st24:
-	p++
-	if p == pe { goto _test_eof24 }
-	fallthrough
-case 24:
-// line 660 "zparse.go"
-	switch data[p] {
-		case 9: goto tr51
-		case 32: goto tr51
-	}
-	if 48 <= data[p] && data[p] <= 57 { goto st24 }
-	goto st0
-tr51:
-// line 89 "zparse.rl"
-	{ tok.pushInt(data[mark:p]) }
-	goto st25
-st25:
-	p++
-	if p == pe { goto _test_eof25 }
-	fallthrough
-case 25:
-// line 676 "zparse.go"
-	switch data[p] {
-		case 9: goto st25
-		case 32: goto st25
-	}
-	if 48 <= data[p] && data[p] <= 57 { goto tr54 }
-	goto st0
-tr54:
-// line 84 "zparse.rl"
-	{ mark = p }
-	goto st26
-st26:
-	p++
-	if p == pe { goto _test_eof26 }
-	fallthrough
-case 26:
-// line 692 "zparse.go"
-	switch data[p] {
-		case 9: goto tr55
-		case 32: goto tr55
-	}
-	if 48 <= data[p] && data[p] <= 57 { goto st26 }
-	goto st0
-tr55:
-// line 89 "zparse.rl"
-	{ tok.pushInt(data[mark:p]) }
-	goto st27
-st27:
-	p++
-	if p == pe { goto _test_eof27 }
-	fallthrough
-case 27:
-// line 708 "zparse.go"
-	switch data[p] {
-		case 9: goto st27
-		case 32: goto st27
-	}
-	if 48 <= data[p] && data[p] <= 57 { goto tr58 }
-	goto st0
-tr58:
-// line 84 "zparse.rl"
-	{ mark = p }
-	goto st28
-st28:
-	p++
-	if p == pe { goto _test_eof28 }
-	fallthrough
-case 28:
-// line 724 "zparse.go"
-	switch data[p] {
-		case 9: goto tr59
-		case 32: goto tr59
-	}
-	if 48 <= data[p] && data[p] <= 57 { goto st28 }
-	goto st0
-tr59:
-// line 89 "zparse.rl"
-	{ tok.pushInt(data[mark:p]) }
-	goto st29
-st29:
-	p++
-	if p == pe { goto _test_eof29 }
-	fallthrough
-case 29:
-// line 740 "zparse.go"
-	switch data[p] {
-		case 9: goto st29
-		case 32: goto st29
-		case 43: goto tr62
-		case 61: goto tr62
-		case 92: goto tr62
-	}
-	if data[p] < 65 {
-		if 46 <= data[p] && data[p] <= 57 { goto tr62 }
-	} else if data[p] > 90 {
-		if 97 <= data[p] && data[p] <= 122 { goto tr62 }
-	} else {
-		goto tr62
-	}
-	goto st0
-tr62:
-// line 84 "zparse.rl"
-	{ mark = p }
-	goto st104
-st104:
-	p++
-	if p == pe { goto _test_eof104 }
-	fallthrough
-case 104:
-// line 765 "zparse.go"
-	switch data[p] {
-		case 9: goto tr174
-		case 32: goto tr174
-		case 43: goto st104
-		case 61: goto st104
-		case 92: goto st104
-	}
-	if data[p] < 65 {
-		if 46 <= data[p] && data[p] <= 57 { goto st104 }
-	} else if data[p] > 90 {
-		if 97 <= data[p] && data[p] <= 122 { goto st104 }
-	} else {
-		goto st104
-	}
-	goto st0
-st30:
-	p++
-	if p == pe { goto _test_eof30 }
-	fallthrough
-case 30:
-	switch data[p] {
-		case 9: goto tr63
-		case 32: goto tr63
-	}
-	goto st0
-tr63:
-// line 93 "zparse.rl"
-	{ 
-                    i := Str_rr[data[mark:p]]
-                    mk, known := rr_mk[int(i)]
-                    if ! known {
-                        // ...
-                    }
-                    rr = mk()
-                    hdr.Rrtype = i
-                }
-	goto st31
-st31:
-	p++
-	if p == pe { goto _test_eof31 }
-	fallthrough
-case 31:
-// line 808 "zparse.go"
-	switch data[p] {
-		case 9: goto st31
-		case 32: goto st31
-	}
-	if 48 <= data[p] && data[p] <= 57 { goto tr65 }
-	goto st0
-tr65:
-// line 84 "zparse.rl"
-	{ mark = p }
-	goto st32
-st32:
-	p++
-	if p == pe { goto _test_eof32 }
-	fallthrough
-case 32:
-// line 824 "zparse.go"
-	switch data[p] {
-		case 9: goto tr66
-		case 32: goto tr66
-	}
-	if 48 <= data[p] && data[p] <= 57 { goto st32 }
-	goto st0
-tr66:
-// line 89 "zparse.rl"
-	{ tok.pushInt(data[mark:p]) }
-	goto st33
-st33:
-	p++
-	if p == pe { goto _test_eof33 }
-	fallthrough
-case 33:
-// line 840 "zparse.go"
-	switch data[p] {
-		case 9: goto st33
-		case 32: goto st33
-	}
-	if 48 <= data[p] && data[p] <= 57 { goto tr69 }
-	goto st0
-tr69:
-// line 84 "zparse.rl"
-	{ mark = p }
-	goto st34
-st34:
-	p++
-	if p == pe { goto _test_eof34 }
-	fallthrough
-case 34:
-// line 856 "zparse.go"
-	switch data[p] {
-		case 9: goto tr70
-		case 32: goto tr70
-	}
-	if 48 <= data[p] && data[p] <= 57 { goto st34 }
-	goto st0
-tr70:
-// line 89 "zparse.rl"
-	{ tok.pushInt(data[mark:p]) }
-	goto st35
-st35:
-	p++
-	if p == pe { goto _test_eof35 }
-	fallthrough
-case 35:
-// line 872 "zparse.go"
-	switch data[p] {
-		case 9: goto st35
-		case 32: goto st35
-	}
-	if 48 <= data[p] && data[p] <= 57 { goto tr73 }
-	goto st0
-tr73:
-// line 84 "zparse.rl"
-	{ mark = p }
-	goto st36
-st36:
-	p++
-	if p == pe { goto _test_eof36 }
-	fallthrough
-case 36:
-// line 888 "zparse.go"
-	switch data[p] {
-		case 9: goto tr74
-		case 32: goto tr74
-	}
-	if 48 <= data[p] && data[p] <= 57 { goto st36 }
-	goto st0
-tr74:
-// line 89 "zparse.rl"
-	{ tok.pushInt(data[mark:p]) }
-	goto st37
-st37:
-	p++
-	if p == pe { goto _test_eof37 }
-	fallthrough
-case 37:
-// line 904 "zparse.go"
-	switch data[p] {
-		case 9: goto st37
-		case 32: goto st37
-		case 43: goto tr77
-		case 61: goto tr77
-		case 92: goto tr77
-	}
-	if data[p] < 65 {
-		if 46 <= data[p] && data[p] <= 57 { goto tr77 }
-	} else if data[p] > 90 {
-		if 97 <= data[p] && data[p] <= 122 { goto tr77 }
-	} else {
-		goto tr77
-	}
-	goto st0
-tr77:
-// line 84 "zparse.rl"
-	{ mark = p }
-	goto st105
-st105:
-	p++
-	if p == pe { goto _test_eof105 }
-	fallthrough
-case 105:
-// line 929 "zparse.go"
-	switch data[p] {
-		case 9: goto tr176
-		case 32: goto tr176
-		case 43: goto st105
-		case 61: goto st105
-		case 92: goto st105
-	}
-	if data[p] < 65 {
-		if 46 <= data[p] && data[p] <= 57 { goto st105 }
-	} else if data[p] > 90 {
-		if 97 <= data[p] && data[p] <= 122 { goto st105 }
-	} else {
-		goto st105
-	}
-	goto st0
-tr9:
-// line 84 "zparse.rl"
-	{ mark = p }
-// line 87 "zparse.rl"
-	{ /* ... */ }
-	goto st38
-tr21:
-// line 84 "zparse.rl"
-	{ mark = p }
-	goto st38
-st38:
-	p++
-	if p == pe { goto _test_eof38 }
-	fallthrough
-case 38:
-// line 960 "zparse.go"
-	switch data[p] {
-		case 88: goto st39
-		case 120: goto st39
-	}
-	goto st0
-st39:
-	p++
-	if p == pe { goto _test_eof39 }
-	fallthrough
-case 39:
-	switch data[p] {
-		case 9: goto tr79
-		case 32: goto tr79
-	}
-	goto st0
-tr79:
-// line 93 "zparse.rl"
-	{ 
-                    i := Str_rr[data[mark:p]]
-                    mk, known := rr_mk[int(i)]
-                    if ! known {
-                        // ...
-                    }
-                    rr = mk()
-                    hdr.Rrtype = i
-                }
-	goto st40
-st40:
-	p++
-	if p == pe { goto _test_eof40 }
-	fallthrough
-case 40:
-// line 993 "zparse.go"
-	switch data[p] {
-		case 9: goto st40
-		case 32: goto st40
-	}
-	if 48 <= data[p] && data[p] <= 57 { goto tr81 }
-	goto st0
-tr81:
-// line 84 "zparse.rl"
-	{ mark = p }
-	goto st41
-st41:
-	p++
-	if p == pe { goto _test_eof41 }
-	fallthrough
-case 41:
-// line 1009 "zparse.go"
-	switch data[p] {
-		case 9: goto tr82
-		case 32: goto tr82
-	}
-	if 48 <= data[p] && data[p] <= 57 { goto st41 }
-	goto st0
-tr82:
-// line 89 "zparse.rl"
-	{ tok.pushInt(data[mark:p]) }
-	goto st42
-st42:
-	p++
-	if p == pe { goto _test_eof42 }
-	fallthrough
-case 42:
-// line 1025 "zparse.go"
-	switch data[p] {
-		case 9: goto st42
-		case 32: goto st42
-		case 43: goto tr85
-		case 61: goto tr85
-		case 92: goto tr85
-	}
-	if data[p] < 65 {
-		if 46 <= data[p] && data[p] <= 57 { goto tr85 }
-	} else if data[p] > 90 {
-		if 97 <= data[p] && data[p] <= 122 { goto tr85 }
-	} else {
-		goto tr85
-	}
-	goto st0
-tr85:
+tr29:
 // line 84 "zparse.rl"
 	{ mark = p }
 	goto st106
@@ -1046,10 +364,10 @@ st106:
 	if p == pe { goto _test_eof106 }
 	fallthrough
 case 106:
-// line 1050 "zparse.go"
+// line 368 "zparse.go"
 	switch data[p] {
-		case 9: goto tr178
-		case 32: goto tr178
+		case 9: goto tr176
+		case 32: goto tr176
 		case 43: goto st106
 		case 61: goto st106
 		case 92: goto st106
@@ -1062,32 +380,37 @@ case 106:
 		goto st106
 	}
 	goto st0
-tr34:
-// line 84 "zparse.rl"
-	{ mark = p }
-	goto st43
-st43:
+st7:
 	p++
-	if p == pe { goto _test_eof43 }
+	if p == pe { goto _test_eof7 }
 	fallthrough
-case 43:
-// line 1075 "zparse.go"
+case 7:
 	switch data[p] {
-		case 83: goto st44
-		case 115: goto st44
+		case 65: goto st8
+		case 97: goto st8
 	}
 	goto st0
-st44:
+st8:
 	p++
-	if p == pe { goto _test_eof44 }
+	if p == pe { goto _test_eof8 }
 	fallthrough
-case 44:
+case 8:
 	switch data[p] {
-		case 9: goto tr87
-		case 32: goto tr87
+		case 65: goto st9
+		case 97: goto st9
 	}
 	goto st0
-tr87:
+st9:
+	p++
+	if p == pe { goto _test_eof9 }
+	fallthrough
+case 9:
+	switch data[p] {
+		case 9: goto tr32
+		case 32: goto tr32
+	}
+	goto st0
+tr32:
 // line 93 "zparse.rl"
 	{ 
                     i := Str_rr[data[mark:p]]
@@ -1098,29 +421,29 @@ tr87:
                     rr = mk()
                     hdr.Rrtype = i
                 }
-	goto st45
-st45:
+	goto st10
+st10:
 	p++
-	if p == pe { goto _test_eof45 }
+	if p == pe { goto _test_eof10 }
 	fallthrough
-case 45:
-// line 1108 "zparse.go"
+case 10:
+// line 431 "zparse.go"
 	switch data[p] {
-		case 9: goto st45
-		case 32: goto st45
-		case 43: goto tr89
-		case 61: goto tr89
-		case 92: goto tr89
+		case 9: goto st10
+		case 32: goto st10
+		case 43: goto tr34
+		case 61: goto tr34
+		case 92: goto tr34
 	}
 	if data[p] < 65 {
-		if 46 <= data[p] && data[p] <= 57 { goto tr89 }
+		if 46 <= data[p] && data[p] <= 57 { goto tr34 }
 	} else if data[p] > 90 {
-		if 97 <= data[p] && data[p] <= 122 { goto tr89 }
+		if 97 <= data[p] && data[p] <= 122 { goto tr34 }
 	} else {
-		goto tr89
+		goto tr34
 	}
 	goto st0
-tr89:
+tr34:
 // line 84 "zparse.rl"
 	{ mark = p }
 	goto st107
@@ -1129,10 +452,10 @@ st107:
 	if p == pe { goto _test_eof107 }
 	fallthrough
 case 107:
-// line 1133 "zparse.go"
+// line 456 "zparse.go"
 	switch data[p] {
-		case 9: goto tr180
-		case 32: goto tr180
+		case 9: goto tr178
+		case 32: goto tr178
 		case 43: goto st107
 		case 61: goto st107
 		case 92: goto st107
@@ -1145,68 +468,132 @@ case 107:
 		goto st107
 	}
 	goto st0
-tr11:
+st11:
+	p++
+	if p == pe { goto _test_eof11 }
+	fallthrough
+case 11:
+	switch data[p] {
+		case 89: goto st12
+		case 121: goto st12
+	}
+	goto st0
+st12:
+	p++
+	if p == pe { goto _test_eof12 }
+	fallthrough
+case 12:
+	switch data[p] {
+		case 9: goto tr36
+		case 32: goto tr36
+	}
+	goto st0
+tr172:
+// line 88 "zparse.rl"
+	{ ttl, _ :=  strconv.Atoi(data[mark:p]); hdr.Ttl = uint32(ttl) }
+	goto st13
+tr36:
+// line 86 "zparse.rl"
+	{ hdr.Class = Str_class[data[mark:p]] }
+	goto st13
+st13:
+	p++
+	if p == pe { goto _test_eof13 }
+	fallthrough
+case 13:
+// line 505 "zparse.go"
+	switch data[p] {
+		case 9: goto st13
+		case 32: goto st13
+		case 65: goto tr38
+		case 67: goto tr39
+		case 68: goto tr18
+		case 77: goto tr21
+		case 78: goto tr40
+		case 82: goto tr23
+		case 83: goto tr24
+		case 97: goto tr38
+		case 99: goto tr39
+		case 100: goto tr18
+		case 109: goto tr21
+		case 110: goto tr40
+		case 114: goto tr23
+		case 115: goto tr24
+	}
+	goto st0
+tr38:
 // line 84 "zparse.rl"
 	{ mark = p }
-// line 87 "zparse.rl"
-	{ /* ... */ }
-	goto st46
-tr23:
+	goto st14
+st14:
+	p++
+	if p == pe { goto _test_eof14 }
+	fallthrough
+case 14:
+// line 534 "zparse.go"
+	switch data[p] {
+		case 9: goto tr25
+		case 32: goto tr25
+		case 65: goto st7
+		case 97: goto st7
+	}
+	goto st0
+tr39:
 // line 84 "zparse.rl"
 	{ mark = p }
-	goto st46
-st46:
+	goto st15
+st15:
 	p++
-	if p == pe { goto _test_eof46 }
+	if p == pe { goto _test_eof15 }
 	fallthrough
-case 46:
-// line 1164 "zparse.go"
+case 15:
+// line 551 "zparse.go"
 	switch data[p] {
-		case 82: goto st47
-		case 114: goto st47
+		case 78: goto st16
+		case 110: goto st16
 	}
 	goto st0
-st47:
+st16:
 	p++
-	if p == pe { goto _test_eof47 }
+	if p == pe { goto _test_eof16 }
 	fallthrough
-case 47:
+case 16:
 	switch data[p] {
-		case 83: goto st48
-		case 115: goto st48
+		case 65: goto st17
+		case 97: goto st17
 	}
 	goto st0
-st48:
+st17:
 	p++
-	if p == pe { goto _test_eof48 }
+	if p == pe { goto _test_eof17 }
 	fallthrough
-case 48:
+case 17:
 	switch data[p] {
-		case 73: goto st49
-		case 105: goto st49
+		case 77: goto st18
+		case 109: goto st18
 	}
 	goto st0
-st49:
+st18:
 	p++
-	if p == pe { goto _test_eof49 }
+	if p == pe { goto _test_eof18 }
 	fallthrough
-case 49:
+case 18:
 	switch data[p] {
-		case 71: goto st50
-		case 103: goto st50
+		case 69: goto st19
+		case 101: goto st19
 	}
 	goto st0
-st50:
+st19:
 	p++
-	if p == pe { goto _test_eof50 }
+	if p == pe { goto _test_eof19 }
 	fallthrough
-case 50:
+case 19:
 	switch data[p] {
-		case 9: goto tr94
-		case 32: goto tr94
+		case 9: goto tr45
+		case 32: goto tr45
 	}
 	goto st0
-tr94:
+tr45:
 // line 93 "zparse.rl"
 	{ 
                     i := Str_rr[data[mark:p]]
@@ -1217,303 +604,29 @@ tr94:
                     rr = mk()
                     hdr.Rrtype = i
                 }
-	goto st51
-st51:
+	goto st20
+st20:
 	p++
-	if p == pe { goto _test_eof51 }
+	if p == pe { goto _test_eof20 }
 	fallthrough
-case 51:
-// line 1227 "zparse.go"
+case 20:
+// line 614 "zparse.go"
 	switch data[p] {
-		case 9: goto st51
-		case 32: goto st51
-	}
-	if 48 <= data[p] && data[p] <= 57 { goto tr96 }
-	goto st0
-tr96:
-// line 84 "zparse.rl"
-	{ mark = p }
-	goto st52
-st52:
-	p++
-	if p == pe { goto _test_eof52 }
-	fallthrough
-case 52:
-// line 1243 "zparse.go"
-	switch data[p] {
-		case 9: goto tr97
-		case 32: goto tr97
-	}
-	if 48 <= data[p] && data[p] <= 57 { goto st52 }
-	goto st0
-tr97:
-// line 89 "zparse.rl"
-	{ tok.pushInt(data[mark:p]) }
-	goto st53
-st53:
-	p++
-	if p == pe { goto _test_eof53 }
-	fallthrough
-case 53:
-// line 1259 "zparse.go"
-	switch data[p] {
-		case 9: goto st53
-		case 32: goto st53
-	}
-	if 48 <= data[p] && data[p] <= 57 { goto tr100 }
-	goto st0
-tr100:
-// line 84 "zparse.rl"
-	{ mark = p }
-	goto st54
-st54:
-	p++
-	if p == pe { goto _test_eof54 }
-	fallthrough
-case 54:
-// line 1275 "zparse.go"
-	switch data[p] {
-		case 9: goto tr101
-		case 32: goto tr101
-	}
-	if 48 <= data[p] && data[p] <= 57 { goto st54 }
-	goto st0
-tr101:
-// line 89 "zparse.rl"
-	{ tok.pushInt(data[mark:p]) }
-	goto st55
-st55:
-	p++
-	if p == pe { goto _test_eof55 }
-	fallthrough
-case 55:
-// line 1291 "zparse.go"
-	switch data[p] {
-		case 9: goto st55
-		case 32: goto st55
-	}
-	if 48 <= data[p] && data[p] <= 57 { goto tr104 }
-	goto st0
-tr104:
-// line 84 "zparse.rl"
-	{ mark = p }
-	goto st56
-st56:
-	p++
-	if p == pe { goto _test_eof56 }
-	fallthrough
-case 56:
-// line 1307 "zparse.go"
-	switch data[p] {
-		case 9: goto tr105
-		case 32: goto tr105
-	}
-	if 48 <= data[p] && data[p] <= 57 { goto st56 }
-	goto st0
-tr105:
-// line 89 "zparse.rl"
-	{ tok.pushInt(data[mark:p]) }
-	goto st57
-st57:
-	p++
-	if p == pe { goto _test_eof57 }
-	fallthrough
-case 57:
-// line 1323 "zparse.go"
-	switch data[p] {
-		case 9: goto st57
-		case 32: goto st57
-	}
-	if 48 <= data[p] && data[p] <= 57 { goto tr108 }
-	goto st0
-tr108:
-// line 84 "zparse.rl"
-	{ mark = p }
-	goto st58
-st58:
-	p++
-	if p == pe { goto _test_eof58 }
-	fallthrough
-case 58:
-// line 1339 "zparse.go"
-	switch data[p] {
-		case 9: goto tr109
-		case 32: goto tr109
-	}
-	if 48 <= data[p] && data[p] <= 57 { goto st58 }
-	goto st0
-tr109:
-// line 89 "zparse.rl"
-	{ tok.pushInt(data[mark:p]) }
-	goto st59
-st59:
-	p++
-	if p == pe { goto _test_eof59 }
-	fallthrough
-case 59:
-// line 1355 "zparse.go"
-	switch data[p] {
-		case 9: goto st59
-		case 32: goto st59
-	}
-	if 48 <= data[p] && data[p] <= 57 { goto tr112 }
-	goto st0
-tr112:
-// line 84 "zparse.rl"
-	{ mark = p }
-	goto st60
-st60:
-	p++
-	if p == pe { goto _test_eof60 }
-	fallthrough
-case 60:
-// line 1371 "zparse.go"
-	switch data[p] {
-		case 9: goto tr113
-		case 32: goto tr113
-	}
-	if 48 <= data[p] && data[p] <= 57 { goto st60 }
-	goto st0
-tr113:
-// line 89 "zparse.rl"
-	{ tok.pushInt(data[mark:p]) }
-	goto st61
-st61:
-	p++
-	if p == pe { goto _test_eof61 }
-	fallthrough
-case 61:
-// line 1387 "zparse.go"
-	switch data[p] {
-		case 9: goto st61
-		case 32: goto st61
-	}
-	if 48 <= data[p] && data[p] <= 57 { goto tr116 }
-	goto st0
-tr116:
-// line 84 "zparse.rl"
-	{ mark = p }
-	goto st62
-st62:
-	p++
-	if p == pe { goto _test_eof62 }
-	fallthrough
-case 62:
-// line 1403 "zparse.go"
-	switch data[p] {
-		case 9: goto tr117
-		case 32: goto tr117
-	}
-	if 48 <= data[p] && data[p] <= 57 { goto st62 }
-	goto st0
-tr117:
-// line 89 "zparse.rl"
-	{ tok.pushInt(data[mark:p]) }
-	goto st63
-st63:
-	p++
-	if p == pe { goto _test_eof63 }
-	fallthrough
-case 63:
-// line 1419 "zparse.go"
-	switch data[p] {
-		case 9: goto st63
-		case 32: goto st63
-	}
-	if 48 <= data[p] && data[p] <= 57 { goto tr120 }
-	goto st0
-tr120:
-// line 84 "zparse.rl"
-	{ mark = p }
-	goto st64
-st64:
-	p++
-	if p == pe { goto _test_eof64 }
-	fallthrough
-case 64:
-// line 1435 "zparse.go"
-	switch data[p] {
-		case 9: goto tr121
-		case 32: goto tr121
-	}
-	if 48 <= data[p] && data[p] <= 57 { goto st64 }
-	goto st0
-tr121:
-// line 89 "zparse.rl"
-	{ tok.pushInt(data[mark:p]) }
-	goto st65
-st65:
-	p++
-	if p == pe { goto _test_eof65 }
-	fallthrough
-case 65:
-// line 1451 "zparse.go"
-	switch data[p] {
-		case 9: goto st65
-		case 32: goto st65
-		case 43: goto tr124
-		case 61: goto tr124
-		case 92: goto tr124
+		case 9: goto st20
+		case 32: goto st20
+		case 43: goto tr47
+		case 61: goto tr47
+		case 92: goto tr47
 	}
 	if data[p] < 65 {
-		if 46 <= data[p] && data[p] <= 57 { goto tr124 }
+		if 46 <= data[p] && data[p] <= 57 { goto tr47 }
 	} else if data[p] > 90 {
-		if 97 <= data[p] && data[p] <= 122 { goto tr124 }
+		if 97 <= data[p] && data[p] <= 122 { goto tr47 }
 	} else {
-		goto tr124
+		goto tr47
 	}
 	goto st0
-tr124:
-// line 84 "zparse.rl"
-	{ mark = p }
-	goto st66
-st66:
-	p++
-	if p == pe { goto _test_eof66 }
-	fallthrough
-case 66:
-// line 1476 "zparse.go"
-	switch data[p] {
-		case 9: goto tr125
-		case 32: goto tr125
-		case 43: goto st66
-		case 61: goto st66
-		case 92: goto st66
-	}
-	if data[p] < 65 {
-		if 46 <= data[p] && data[p] <= 57 { goto st66 }
-	} else if data[p] > 90 {
-		if 97 <= data[p] && data[p] <= 122 { goto st66 }
-	} else {
-		goto st66
-	}
-	goto st0
-tr125:
-// line 90 "zparse.rl"
-	{ tok.pushString(data[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 st67
-		case 32: goto st67
-		case 43: goto tr128
-		case 61: goto tr128
-		case 92: goto tr128
-	}
-	if data[p] < 65 {
-		if 46 <= data[p] && data[p] <= 57 { goto tr128 }
-	} else if data[p] > 90 {
-		if 97 <= data[p] && data[p] <= 122 { goto tr128 }
-	} else {
-		goto tr128
-	}
-	goto st0
-tr128:
+tr47:
 // line 84 "zparse.rl"
 	{ mark = p }
 	goto st108
@@ -1522,10 +635,10 @@ st108:
 	if p == pe { goto _test_eof108 }
 	fallthrough
 case 108:
-// line 1526 "zparse.go"
+// line 639 "zparse.go"
 	switch data[p] {
-		case 9: goto tr182
-		case 32: goto tr182
+		case 9: goto tr180
+		case 32: goto tr180
 		case 43: goto st108
 		case 61: goto st108
 		case 92: goto st108
@@ -1538,48 +651,80 @@ case 108:
 		goto st108
 	}
 	goto st0
-tr12:
+tr6:
 // line 84 "zparse.rl"
 	{ mark = p }
 // line 87 "zparse.rl"
 	{ /* ... */ }
-	goto st68
-tr24:
+	goto st21
+tr18:
 // line 84 "zparse.rl"
 	{ mark = p }
-	goto st68
-st68:
+	goto st21
+st21:
 	p++
-	if p == pe { goto _test_eof68 }
+	if p == pe { goto _test_eof21 }
 	fallthrough
-case 68:
-// line 1557 "zparse.go"
+case 21:
+// line 670 "zparse.go"
 	switch data[p] {
-		case 79: goto st69
-		case 111: goto st69
+		case 78: goto st22
+		case 83: goto st34
+		case 110: goto st22
+		case 115: goto st34
 	}
 	goto st0
-st69:
+st22:
 	p++
-	if p == pe { goto _test_eof69 }
+	if p == pe { goto _test_eof22 }
 	fallthrough
-case 69:
+case 22:
 	switch data[p] {
-		case 65: goto st70
-		case 97: goto st70
+		case 83: goto st23
+		case 115: goto st23
 	}
 	goto st0
-st70:
+st23:
 	p++
-	if p == pe { goto _test_eof70 }
+	if p == pe { goto _test_eof23 }
 	fallthrough
-case 70:
+case 23:
 	switch data[p] {
-		case 9: goto tr131
-		case 32: goto tr131
+		case 75: goto st24
+		case 107: goto st24
 	}
 	goto st0
-tr131:
+st24:
+	p++
+	if p == pe { goto _test_eof24 }
+	fallthrough
+case 24:
+	switch data[p] {
+		case 69: goto st25
+		case 101: goto st25
+	}
+	goto st0
+st25:
+	p++
+	if p == pe { goto _test_eof25 }
+	fallthrough
+case 25:
+	switch data[p] {
+		case 89: goto st26
+		case 121: goto st26
+	}
+	goto st0
+st26:
+	p++
+	if p == pe { goto _test_eof26 }
+	fallthrough
+case 26:
+	switch data[p] {
+		case 9: goto tr54
+		case 32: goto tr54
+	}
+	goto st0
+tr54:
 // line 93 "zparse.rl"
 	{ 
                     i := Str_rr[data[mark:p]]
@@ -1590,248 +735,125 @@ tr131:
                     rr = mk()
                     hdr.Rrtype = i
                 }
-	goto st71
-st71:
+	goto st27
+st27:
 	p++
-	if p == pe { goto _test_eof71 }
+	if p == pe { goto _test_eof27 }
 	fallthrough
-case 71:
-// line 1600 "zparse.go"
+case 27:
+// line 745 "zparse.go"
 	switch data[p] {
-		case 9: goto st71
-		case 32: goto st71
-		case 43: goto tr133
-		case 61: goto tr133
-		case 92: goto tr133
-	}
-	if data[p] < 65 {
-		if 46 <= data[p] && data[p] <= 57 { goto tr133 }
-	} else if data[p] > 90 {
-		if 97 <= data[p] && data[p] <= 122 { goto tr133 }
-	} else {
-		goto tr133
+		case 9: goto st27
+		case 32: goto st27
 	}
+	if 48 <= data[p] && data[p] <= 57 { goto tr56 }
 	goto st0
-tr133:
+tr56:
 // line 84 "zparse.rl"
 	{ mark = p }
-	goto st72
-st72:
+	goto st28
+st28:
 	p++
-	if p == pe { goto _test_eof72 }
+	if p == pe { goto _test_eof28 }
 	fallthrough
-case 72:
-// line 1625 "zparse.go"
+case 28:
+// line 761 "zparse.go"
 	switch data[p] {
-		case 9: goto tr134
-		case 32: goto tr134
-		case 43: goto st72
-		case 61: goto st72
-		case 92: goto st72
-	}
-	if data[p] < 65 {
-		if 46 <= data[p] && data[p] <= 57 { goto st72 }
-	} else if data[p] > 90 {
-		if 97 <= data[p] && data[p] <= 122 { goto st72 }
-	} else {
-		goto st72
+		case 9: goto tr57
+		case 32: goto tr57
 	}
+	if 48 <= data[p] && data[p] <= 57 { goto st28 }
 	goto st0
-tr134:
-// line 90 "zparse.rl"
-	{ tok.pushString(data[mark:p]) }
-	goto st73
-st73:
-	p++
-	if p == pe { goto _test_eof73 }
-	fallthrough
-case 73:
-// line 1650 "zparse.go"
-	switch data[p] {
-		case 9: goto st73
-		case 32: goto st73
-		case 43: goto tr137
-		case 61: goto tr137
-		case 92: goto tr137
-	}
-	if data[p] < 65 {
-		if 46 <= data[p] && data[p] <= 57 { goto tr137 }
-	} else if data[p] > 90 {
-		if 97 <= data[p] && data[p] <= 122 { goto tr137 }
-	} else {
-		goto tr137
-	}
-	goto st0
-tr137:
-// line 84 "zparse.rl"
-	{ mark = p }
-	goto st74
-st74:
-	p++
-	if p == pe { goto _test_eof74 }
-	fallthrough
-case 74:
-// line 1675 "zparse.go"
-	switch data[p] {
-		case 9: goto tr138
-		case 32: goto tr138
-		case 43: goto st74
-		case 61: goto st74
-		case 92: goto st74
-	}
-	if data[p] < 65 {
-		if 46 <= data[p] && data[p] <= 57 { goto st74 }
-	} else if data[p] > 90 {
-		if 97 <= data[p] && data[p] <= 122 { goto st74 }
-	} else {
-		goto st74
-	}
-	goto st0
-tr138:
-// line 90 "zparse.rl"
-	{ tok.pushString(data[mark:p]) }
-	goto st75
-st75:
-	p++
-	if p == pe { goto _test_eof75 }
-	fallthrough
-case 75:
-// line 1700 "zparse.go"
-	switch data[p] {
-		case 9: goto st75
-		case 32: goto st75
-	}
-	if 48 <= data[p] && data[p] <= 57 { goto tr141 }
-	goto st0
-tr141:
-// line 84 "zparse.rl"
-	{ mark = p }
-	goto st76
-st76:
-	p++
-	if p == pe { goto _test_eof76 }
-	fallthrough
-case 76:
-// line 1716 "zparse.go"
-	switch data[p] {
-		case 9: goto tr142
-		case 32: goto tr142
-	}
-	if 48 <= data[p] && data[p] <= 57 { goto st76 }
-	goto st0
-tr142:
+tr57:
 // line 89 "zparse.rl"
 	{ tok.pushInt(data[mark:p]) }
-	goto st77
-st77:
+	goto st29
+st29:
 	p++
-	if p == pe { goto _test_eof77 }
+	if p == pe { goto _test_eof29 }
 	fallthrough
-case 77:
-// line 1732 "zparse.go"
+case 29:
+// line 777 "zparse.go"
 	switch data[p] {
-		case 9: goto st77
-		case 32: goto st77
+		case 9: goto st29
+		case 32: goto st29
 	}
-	if 48 <= data[p] && data[p] <= 57 { goto tr145 }
+	if 48 <= data[p] && data[p] <= 57 { goto tr60 }
 	goto st0
-tr145:
+tr60:
 // line 84 "zparse.rl"
 	{ mark = p }
-	goto st78
-st78:
+	goto st30
+st30:
 	p++
-	if p == pe { goto _test_eof78 }
+	if p == pe { goto _test_eof30 }
 	fallthrough
-case 78:
-// line 1748 "zparse.go"
+case 30:
+// line 793 "zparse.go"
 	switch data[p] {
-		case 9: goto tr146
-		case 32: goto tr146
+		case 9: goto tr61
+		case 32: goto tr61
 	}
-	if 48 <= data[p] && data[p] <= 57 { goto st78 }
+	if 48 <= data[p] && data[p] <= 57 { goto st30 }
 	goto st0
-tr146:
+tr61:
 // line 89 "zparse.rl"
 	{ tok.pushInt(data[mark:p]) }
-	goto st79
-st79:
+	goto st31
+st31:
 	p++
-	if p == pe { goto _test_eof79 }
+	if p == pe { goto _test_eof31 }
 	fallthrough
-case 79:
-// line 1764 "zparse.go"
+case 31:
+// line 809 "zparse.go"
 	switch data[p] {
-		case 9: goto st79
-		case 32: goto st79
+		case 9: goto st31
+		case 32: goto st31
 	}
-	if 48 <= data[p] && data[p] <= 57 { goto tr149 }
+	if 48 <= data[p] && data[p] <= 57 { goto tr64 }
 	goto st0
-tr149:
+tr64:
 // line 84 "zparse.rl"
 	{ mark = p }
-	goto st80
-st80:
+	goto st32
+st32:
 	p++
-	if p == pe { goto _test_eof80 }
+	if p == pe { goto _test_eof32 }
 	fallthrough
-case 80:
-// line 1780 "zparse.go"
+case 32:
+// line 825 "zparse.go"
 	switch data[p] {
-		case 9: goto tr150
-		case 32: goto tr150
+		case 9: goto tr65
+		case 32: goto tr65
 	}
-	if 48 <= data[p] && data[p] <= 57 { goto st80 }
+	if 48 <= data[p] && data[p] <= 57 { goto st32 }
 	goto st0
-tr150:
+tr65:
 // line 89 "zparse.rl"
 	{ tok.pushInt(data[mark:p]) }
-	goto st81
-st81:
+	goto st33
+st33:
 	p++
-	if p == pe { goto _test_eof81 }
+	if p == pe { goto _test_eof33 }
 	fallthrough
-case 81:
-// line 1796 "zparse.go"
+case 33:
+// line 841 "zparse.go"
 	switch data[p] {
-		case 9: goto st81
-		case 32: goto st81
+		case 9: goto st33
+		case 32: goto st33
+		case 43: goto tr68
+		case 61: goto tr68
+		case 92: goto tr68
 	}
-	if 48 <= data[p] && data[p] <= 57 { goto tr153 }
-	goto st0
-tr153:
-// line 84 "zparse.rl"
-	{ mark = p }
-	goto st82
-st82:
-	p++
-	if p == pe { goto _test_eof82 }
-	fallthrough
-case 82:
-// line 1812 "zparse.go"
-	switch data[p] {
-		case 9: goto tr154
-		case 32: goto tr154
+	if data[p] < 65 {
+		if 46 <= data[p] && data[p] <= 57 { goto tr68 }
+	} else if data[p] > 90 {
+		if 97 <= data[p] && data[p] <= 122 { goto tr68 }
+	} else {
+		goto tr68
 	}
-	if 48 <= data[p] && data[p] <= 57 { goto st82 }
 	goto st0
-tr154:
-// line 89 "zparse.rl"
-	{ tok.pushInt(data[mark:p]) }
-	goto st83
-st83:
-	p++
-	if p == pe { goto _test_eof83 }
-	fallthrough
-case 83:
-// line 1828 "zparse.go"
-	switch data[p] {
-		case 9: goto st83
-		case 32: goto st83
-	}
-	if 48 <= data[p] && data[p] <= 57 { goto tr157 }
-	goto st0
-tr157:
+tr68:
 // line 84 "zparse.rl"
 	{ mark = p }
 	goto st109
@@ -1840,25 +862,1104 @@ st109:
 	if p == pe { goto _test_eof109 }
 	fallthrough
 case 109:
-// line 1844 "zparse.go"
+// line 866 "zparse.go"
+	switch data[p] {
+		case 9: goto tr182
+		case 32: goto tr182
+		case 43: goto st109
+		case 61: goto st109
+		case 92: goto st109
+	}
+	if data[p] < 65 {
+		if 46 <= data[p] && data[p] <= 57 { goto st109 }
+	} else if data[p] > 90 {
+		if 97 <= data[p] && data[p] <= 122 { goto st109 }
+	} else {
+		goto st109
+	}
+	goto st0
+st34:
+	p++
+	if p == pe { goto _test_eof34 }
+	fallthrough
+case 34:
+	switch data[p] {
+		case 9: goto tr69
+		case 32: goto tr69
+	}
+	goto st0
+tr69:
+// line 93 "zparse.rl"
+	{ 
+                    i := Str_rr[data[mark:p]]
+                    mk, known := rr_mk[int(i)]
+                    if ! known {
+                        // ...
+                    }
+                    rr = mk()
+                    hdr.Rrtype = i
+                }
+	goto st35
+st35:
+	p++
+	if p == pe { goto _test_eof35 }
+	fallthrough
+case 35:
+// line 909 "zparse.go"
+	switch data[p] {
+		case 9: goto st35
+		case 32: goto st35
+	}
+	if 48 <= data[p] && data[p] <= 57 { goto tr71 }
+	goto st0
+tr71:
+// line 84 "zparse.rl"
+	{ mark = p }
+	goto st36
+st36:
+	p++
+	if p == pe { goto _test_eof36 }
+	fallthrough
+case 36:
+// line 925 "zparse.go"
+	switch data[p] {
+		case 9: goto tr72
+		case 32: goto tr72
+	}
+	if 48 <= data[p] && data[p] <= 57 { goto st36 }
+	goto st0
+tr72:
+// line 89 "zparse.rl"
+	{ tok.pushInt(data[mark:p]) }
+	goto st37
+st37:
+	p++
+	if p == pe { goto _test_eof37 }
+	fallthrough
+case 37:
+// line 941 "zparse.go"
+	switch data[p] {
+		case 9: goto st37
+		case 32: goto st37
+	}
+	if 48 <= data[p] && data[p] <= 57 { goto tr75 }
+	goto st0
+tr75:
+// line 84 "zparse.rl"
+	{ mark = p }
+	goto st38
+st38:
+	p++
+	if p == pe { goto _test_eof38 }
+	fallthrough
+case 38:
+// line 957 "zparse.go"
+	switch data[p] {
+		case 9: goto tr76
+		case 32: goto tr76
+	}
+	if 48 <= data[p] && data[p] <= 57 { goto st38 }
+	goto st0
+tr76:
+// line 89 "zparse.rl"
+	{ tok.pushInt(data[mark:p]) }
+	goto st39
+st39:
+	p++
+	if p == pe { goto _test_eof39 }
+	fallthrough
+case 39:
+// line 973 "zparse.go"
+	switch data[p] {
+		case 9: goto st39
+		case 32: goto st39
+	}
+	if 48 <= data[p] && data[p] <= 57 { goto tr79 }
+	goto st0
+tr79:
+// line 84 "zparse.rl"
+	{ mark = p }
+	goto st40
+st40:
+	p++
+	if p == pe { goto _test_eof40 }
+	fallthrough
+case 40:
+// line 989 "zparse.go"
+	switch data[p] {
+		case 9: goto tr80
+		case 32: goto tr80
+	}
+	if 48 <= data[p] && data[p] <= 57 { goto st40 }
+	goto st0
+tr80:
+// line 89 "zparse.rl"
+	{ tok.pushInt(data[mark:p]) }
+	goto st41
+st41:
+	p++
+	if p == pe { goto _test_eof41 }
+	fallthrough
+case 41:
+// line 1005 "zparse.go"
+	switch data[p] {
+		case 9: goto st41
+		case 32: goto st41
+		case 43: goto tr83
+		case 61: goto tr83
+		case 92: goto tr83
+	}
+	if data[p] < 65 {
+		if 46 <= data[p] && data[p] <= 57 { goto tr83 }
+	} else if data[p] > 90 {
+		if 97 <= data[p] && data[p] <= 122 { goto tr83 }
+	} else {
+		goto tr83
+	}
+	goto st0
+tr83:
+// line 84 "zparse.rl"
+	{ mark = p }
+	goto st110
+st110:
+	p++
+	if p == pe { goto _test_eof110 }
+	fallthrough
+case 110:
+// line 1030 "zparse.go"
 	switch data[p] {
 		case 9: goto tr184
 		case 32: goto tr184
-		case 46: goto tr185
-		case 92: goto tr185
+		case 43: goto st110
+		case 61: goto st110
+		case 92: goto st110
 	}
 	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st109 }
+		if 46 <= data[p] && data[p] <= 57 { goto st110 }
 	} else if data[p] > 90 {
-		if 97 <= data[p] && data[p] <= 122 { goto tr185 }
+		if 97 <= data[p] && data[p] <= 122 { goto st110 }
 	} else {
-		goto tr185
+		goto st110
 	}
 	goto st0
-tr185:
+tr9:
+// line 84 "zparse.rl"
+	{ mark = p }
+// line 87 "zparse.rl"
+	{ /* ... */ }
+	goto st42
+tr21:
+// line 84 "zparse.rl"
+	{ mark = p }
+	goto st42
+st42:
+	p++
+	if p == pe { goto _test_eof42 }
+	fallthrough
+case 42:
+// line 1061 "zparse.go"
+	switch data[p] {
+		case 88: goto st43
+		case 120: goto st43
+	}
+	goto st0
+st43:
+	p++
+	if p == pe { goto _test_eof43 }
+	fallthrough
+case 43:
+	switch data[p] {
+		case 9: goto tr85
+		case 32: goto tr85
+	}
+	goto st0
+tr85:
+// line 93 "zparse.rl"
+	{ 
+                    i := Str_rr[data[mark:p]]
+                    mk, known := rr_mk[int(i)]
+                    if ! known {
+                        // ...
+                    }
+                    rr = mk()
+                    hdr.Rrtype = i
+                }
+	goto st44
+st44:
+	p++
+	if p == pe { goto _test_eof44 }
+	fallthrough
+case 44:
+// line 1094 "zparse.go"
+	switch data[p] {
+		case 9: goto st44
+		case 32: goto st44
+	}
+	if 48 <= data[p] && data[p] <= 57 { goto tr87 }
+	goto st0
+tr87:
+// line 84 "zparse.rl"
+	{ mark = p }
+	goto st45
+st45:
+	p++
+	if p == pe { goto _test_eof45 }
+	fallthrough
+case 45:
+// line 1110 "zparse.go"
+	switch data[p] {
+		case 9: goto tr88
+		case 32: goto tr88
+	}
+	if 48 <= data[p] && data[p] <= 57 { goto st45 }
+	goto st0
+tr88:
 // line 89 "zparse.rl"
 	{ tok.pushInt(data[mark:p]) }
-// line 16 "types.rl"
+	goto st46
+st46:
+	p++
+	if p == pe { goto _test_eof46 }
+	fallthrough
+case 46:
+// line 1126 "zparse.go"
+	switch data[p] {
+		case 9: goto st46
+		case 32: goto st46
+		case 43: goto tr91
+		case 61: goto tr91
+		case 92: goto tr91
+	}
+	if data[p] < 65 {
+		if 46 <= data[p] && data[p] <= 57 { goto tr91 }
+	} else if data[p] > 90 {
+		if 97 <= data[p] && data[p] <= 122 { goto tr91 }
+	} else {
+		goto tr91
+	}
+	goto st0
+tr91:
+// line 84 "zparse.rl"
+	{ mark = p }
+	goto st111
+st111:
+	p++
+	if p == pe { goto _test_eof111 }
+	fallthrough
+case 111:
+// line 1151 "zparse.go"
+	switch data[p] {
+		case 9: goto tr186
+		case 32: goto tr186
+		case 43: goto st111
+		case 61: goto st111
+		case 92: goto st111
+	}
+	if data[p] < 65 {
+		if 46 <= data[p] && data[p] <= 57 { goto st111 }
+	} else if data[p] > 90 {
+		if 97 <= data[p] && data[p] <= 122 { goto st111 }
+	} else {
+		goto st111
+	}
+	goto st0
+tr40:
+// line 84 "zparse.rl"
+	{ mark = p }
+	goto st47
+st47:
+	p++
+	if p == pe { goto _test_eof47 }
+	fallthrough
+case 47:
+// line 1176 "zparse.go"
+	switch data[p] {
+		case 83: goto st48
+		case 115: goto st48
+	}
+	goto st0
+st48:
+	p++
+	if p == pe { goto _test_eof48 }
+	fallthrough
+case 48:
+	switch data[p] {
+		case 9: goto tr93
+		case 32: goto tr93
+	}
+	goto st0
+tr93:
+// line 93 "zparse.rl"
+	{ 
+                    i := Str_rr[data[mark:p]]
+                    mk, known := rr_mk[int(i)]
+                    if ! known {
+                        // ...
+                    }
+                    rr = mk()
+                    hdr.Rrtype = i
+                }
+	goto st49
+st49:
+	p++
+	if p == pe { goto _test_eof49 }
+	fallthrough
+case 49:
+// line 1209 "zparse.go"
+	switch data[p] {
+		case 9: goto st49
+		case 32: goto st49
+		case 43: goto tr95
+		case 61: goto tr95
+		case 92: goto tr95
+	}
+	if data[p] < 65 {
+		if 46 <= data[p] && data[p] <= 57 { goto tr95 }
+	} else if data[p] > 90 {
+		if 97 <= data[p] && data[p] <= 122 { goto tr95 }
+	} else {
+		goto tr95
+	}
+	goto st0
+tr95:
+// line 84 "zparse.rl"
+	{ mark = p }
+	goto st112
+st112:
+	p++
+	if p == pe { goto _test_eof112 }
+	fallthrough
+case 112:
+// line 1234 "zparse.go"
+	switch data[p] {
+		case 9: goto tr188
+		case 32: goto tr188
+		case 43: goto st112
+		case 61: goto st112
+		case 92: goto st112
+	}
+	if data[p] < 65 {
+		if 46 <= data[p] && data[p] <= 57 { goto st112 }
+	} else if data[p] > 90 {
+		if 97 <= data[p] && data[p] <= 122 { goto st112 }
+	} else {
+		goto st112
+	}
+	goto st0
+tr11:
+// line 84 "zparse.rl"
+	{ mark = p }
+// line 87 "zparse.rl"
+	{ /* ... */ }
+	goto st50
+tr23:
+// line 84 "zparse.rl"
+	{ mark = p }
+	goto st50
+st50:
+	p++
+	if p == pe { goto _test_eof50 }
+	fallthrough
+case 50:
+// line 1265 "zparse.go"
+	switch data[p] {
+		case 82: goto st51
+		case 114: goto st51
+	}
+	goto st0
+st51:
+	p++
+	if p == pe { goto _test_eof51 }
+	fallthrough
+case 51:
+	switch data[p] {
+		case 83: goto st52
+		case 115: goto st52
+	}
+	goto st0
+st52:
+	p++
+	if p == pe { goto _test_eof52 }
+	fallthrough
+case 52:
+	switch data[p] {
+		case 73: goto st53
+		case 105: goto st53
+	}
+	goto st0
+st53:
+	p++
+	if p == pe { goto _test_eof53 }
+	fallthrough
+case 53:
+	switch data[p] {
+		case 71: goto st54
+		case 103: goto st54
+	}
+	goto st0
+st54:
+	p++
+	if p == pe { goto _test_eof54 }
+	fallthrough
+case 54:
+	switch data[p] {
+		case 9: goto tr100
+		case 32: goto tr100
+	}
+	goto st0
+tr100:
+// line 93 "zparse.rl"
+	{ 
+                    i := Str_rr[data[mark:p]]
+                    mk, known := rr_mk[int(i)]
+                    if ! known {
+                        // ...
+                    }
+                    rr = mk()
+                    hdr.Rrtype = i
+                }
+	goto st55
+st55:
+	p++
+	if p == pe { goto _test_eof55 }
+	fallthrough
+case 55:
+// line 1328 "zparse.go"
+	switch data[p] {
+		case 9: goto st55
+		case 32: goto st55
+	}
+	if 48 <= data[p] && data[p] <= 57 { goto tr102 }
+	goto st0
+tr102:
+// line 84 "zparse.rl"
+	{ mark = p }
+	goto st56
+st56:
+	p++
+	if p == pe { goto _test_eof56 }
+	fallthrough
+case 56:
+// line 1344 "zparse.go"
+	switch data[p] {
+		case 9: goto tr103
+		case 32: goto tr103
+	}
+	if 48 <= data[p] && data[p] <= 57 { goto st56 }
+	goto st0
+tr103:
+// line 89 "zparse.rl"
+	{ tok.pushInt(data[mark:p]) }
+	goto st57
+st57:
+	p++
+	if p == pe { goto _test_eof57 }
+	fallthrough
+case 57:
+// line 1360 "zparse.go"
+	switch data[p] {
+		case 9: goto st57
+		case 32: goto st57
+	}
+	if 48 <= data[p] && data[p] <= 57 { goto tr106 }
+	goto st0
+tr106:
+// line 84 "zparse.rl"
+	{ mark = p }
+	goto st58
+st58:
+	p++
+	if p == pe { goto _test_eof58 }
+	fallthrough
+case 58:
+// line 1376 "zparse.go"
+	switch data[p] {
+		case 9: goto tr107
+		case 32: goto tr107
+	}
+	if 48 <= data[p] && data[p] <= 57 { goto st58 }
+	goto st0
+tr107:
+// line 89 "zparse.rl"
+	{ tok.pushInt(data[mark:p]) }
+	goto st59
+st59:
+	p++
+	if p == pe { goto _test_eof59 }
+	fallthrough
+case 59:
+// line 1392 "zparse.go"
+	switch data[p] {
+		case 9: goto st59
+		case 32: goto st59
+	}
+	if 48 <= data[p] && data[p] <= 57 { goto tr110 }
+	goto st0
+tr110:
+// line 84 "zparse.rl"
+	{ mark = p }
+	goto st60
+st60:
+	p++
+	if p == pe { goto _test_eof60 }
+	fallthrough
+case 60:
+// line 1408 "zparse.go"
+	switch data[p] {
+		case 9: goto tr111
+		case 32: goto tr111
+	}
+	if 48 <= data[p] && data[p] <= 57 { goto st60 }
+	goto st0
+tr111:
+// line 89 "zparse.rl"
+	{ tok.pushInt(data[mark:p]) }
+	goto st61
+st61:
+	p++
+	if p == pe { goto _test_eof61 }
+	fallthrough
+case 61:
+// line 1424 "zparse.go"
+	switch data[p] {
+		case 9: goto st61
+		case 32: goto st61
+	}
+	if 48 <= data[p] && data[p] <= 57 { goto tr114 }
+	goto st0
+tr114:
+// line 84 "zparse.rl"
+	{ mark = p }
+	goto st62
+st62:
+	p++
+	if p == pe { goto _test_eof62 }
+	fallthrough
+case 62:
+// line 1440 "zparse.go"
+	switch data[p] {
+		case 9: goto tr115
+		case 32: goto tr115
+	}
+	if 48 <= data[p] && data[p] <= 57 { goto st62 }
+	goto st0
+tr115:
+// line 89 "zparse.rl"
+	{ tok.pushInt(data[mark:p]) }
+	goto st63
+st63:
+	p++
+	if p == pe { goto _test_eof63 }
+	fallthrough
+case 63:
+// line 1456 "zparse.go"
+	switch data[p] {
+		case 9: goto st63
+		case 32: goto st63
+	}
+	if 48 <= data[p] && data[p] <= 57 { goto tr118 }
+	goto st0
+tr118:
+// line 84 "zparse.rl"
+	{ mark = p }
+	goto st64
+st64:
+	p++
+	if p == pe { goto _test_eof64 }
+	fallthrough
+case 64:
+// line 1472 "zparse.go"
+	switch data[p] {
+		case 9: goto tr119
+		case 32: goto tr119
+	}
+	if 48 <= data[p] && data[p] <= 57 { goto st64 }
+	goto st0
+tr119:
+// line 89 "zparse.rl"
+	{ tok.pushInt(data[mark:p]) }
+	goto st65
+st65:
+	p++
+	if p == pe { goto _test_eof65 }
+	fallthrough
+case 65:
+// line 1488 "zparse.go"
+	switch data[p] {
+		case 9: goto st65
+		case 32: goto st65
+	}
+	if 48 <= data[p] && data[p] <= 57 { goto tr122 }
+	goto st0
+tr122:
+// line 84 "zparse.rl"
+	{ mark = p }
+	goto st66
+st66:
+	p++
+	if p == pe { goto _test_eof66 }
+	fallthrough
+case 66:
+// line 1504 "zparse.go"
+	switch data[p] {
+		case 9: goto tr123
+		case 32: goto tr123
+	}
+	if 48 <= data[p] && data[p] <= 57 { goto st66 }
+	goto st0
+tr123:
+// line 89 "zparse.rl"
+	{ tok.pushInt(data[mark:p]) }
+	goto st67
+st67:
+	p++
+	if p == pe { goto _test_eof67 }
+	fallthrough
+case 67:
+// line 1520 "zparse.go"
+	switch data[p] {
+		case 9: goto st67
+		case 32: goto st67
+	}
+	if 48 <= data[p] && data[p] <= 57 { goto tr126 }
+	goto st0
+tr126:
+// line 84 "zparse.rl"
+	{ mark = p }
+	goto st68
+st68:
+	p++
+	if p == pe { goto _test_eof68 }
+	fallthrough
+case 68:
+// line 1536 "zparse.go"
+	switch data[p] {
+		case 9: goto tr127
+		case 32: goto tr127
+	}
+	if 48 <= data[p] && data[p] <= 57 { goto st68 }
+	goto st0
+tr127:
+// line 89 "zparse.rl"
+	{ tok.pushInt(data[mark:p]) }
+	goto st69
+st69:
+	p++
+	if p == pe { goto _test_eof69 }
+	fallthrough
+case 69:
+// line 1552 "zparse.go"
+	switch data[p] {
+		case 9: goto st69
+		case 32: goto st69
+		case 43: goto tr130
+		case 61: goto tr130
+		case 92: goto tr130
+	}
+	if data[p] < 65 {
+		if 46 <= data[p] && data[p] <= 57 { goto tr130 }
+	} else if data[p] > 90 {
+		if 97 <= data[p] && data[p] <= 122 { goto tr130 }
+	} else {
+		goto tr130
+	}
+	goto st0
+tr130:
+// line 84 "zparse.rl"
+	{ mark = p }
+	goto st70
+st70:
+	p++
+	if p == pe { goto _test_eof70 }
+	fallthrough
+case 70:
+// line 1577 "zparse.go"
+	switch data[p] {
+		case 9: goto tr131
+		case 32: goto tr131
+		case 43: goto st70
+		case 61: goto st70
+		case 92: goto st70
+	}
+	if data[p] < 65 {
+		if 46 <= data[p] && data[p] <= 57 { goto st70 }
+	} else if data[p] > 90 {
+		if 97 <= data[p] && data[p] <= 122 { goto st70 }
+	} else {
+		goto st70
+	}
+	goto st0
+tr131:
+// line 90 "zparse.rl"
+	{ tok.pushString(data[mark:p]) }
+	goto st71
+st71:
+	p++
+	if p == pe { goto _test_eof71 }
+	fallthrough
+case 71:
+// line 1602 "zparse.go"
+	switch data[p] {
+		case 9: goto st71
+		case 32: goto st71
+		case 43: goto tr134
+		case 61: goto tr134
+		case 92: goto tr134
+	}
+	if data[p] < 65 {
+		if 46 <= data[p] && data[p] <= 57 { goto tr134 }
+	} else if data[p] > 90 {
+		if 97 <= data[p] && data[p] <= 122 { goto tr134 }
+	} else {
+		goto tr134
+	}
+	goto st0
+tr134:
+// line 84 "zparse.rl"
+	{ mark = p }
+	goto st113
+st113:
+	p++
+	if p == pe { goto _test_eof113 }
+	fallthrough
+case 113:
+// line 1627 "zparse.go"
+	switch data[p] {
+		case 9: goto tr190
+		case 32: goto tr190
+		case 43: goto st113
+		case 61: goto st113
+		case 92: goto st113
+	}
+	if data[p] < 65 {
+		if 46 <= data[p] && data[p] <= 57 { goto st113 }
+	} else if data[p] > 90 {
+		if 97 <= data[p] && data[p] <= 122 { goto st113 }
+	} else {
+		goto st113
+	}
+	goto st0
+tr12:
+// line 84 "zparse.rl"
+	{ mark = p }
+// line 87 "zparse.rl"
+	{ /* ... */ }
+	goto st72
+tr24:
+// line 84 "zparse.rl"
+	{ mark = p }
+	goto st72
+st72:
+	p++
+	if p == pe { goto _test_eof72 }
+	fallthrough
+case 72:
+// line 1658 "zparse.go"
+	switch data[p] {
+		case 79: goto st73
+		case 111: goto st73
+	}
+	goto st0
+st73:
+	p++
+	if p == pe { goto _test_eof73 }
+	fallthrough
+case 73:
+	switch data[p] {
+		case 65: goto st74
+		case 97: goto st74
+	}
+	goto st0
+st74:
+	p++
+	if p == pe { goto _test_eof74 }
+	fallthrough
+case 74:
+	switch data[p] {
+		case 9: goto tr137
+		case 32: goto tr137
+	}
+	goto st0
+tr137:
+// line 93 "zparse.rl"
+	{ 
+                    i := Str_rr[data[mark:p]]
+                    mk, known := rr_mk[int(i)]
+                    if ! known {
+                        // ...
+                    }
+                    rr = mk()
+                    hdr.Rrtype = i
+                }
+	goto st75
+st75:
+	p++
+	if p == pe { goto _test_eof75 }
+	fallthrough
+case 75:
+// line 1701 "zparse.go"
+	switch data[p] {
+		case 9: goto st75
+		case 32: goto st75
+		case 43: goto tr139
+		case 61: goto tr139
+		case 92: goto tr139
+	}
+	if data[p] < 65 {
+		if 46 <= data[p] && data[p] <= 57 { goto tr139 }
+	} else if data[p] > 90 {
+		if 97 <= data[p] && data[p] <= 122 { goto tr139 }
+	} else {
+		goto tr139
+	}
+	goto st0
+tr139:
+// line 84 "zparse.rl"
+	{ mark = p }
+	goto st76
+st76:
+	p++
+	if p == pe { goto _test_eof76 }
+	fallthrough
+case 76:
+// line 1726 "zparse.go"
+	switch data[p] {
+		case 9: goto tr140
+		case 32: goto tr140
+		case 43: goto st76
+		case 61: goto st76
+		case 92: goto st76
+	}
+	if data[p] < 65 {
+		if 46 <= data[p] && data[p] <= 57 { goto st76 }
+	} else if data[p] > 90 {
+		if 97 <= data[p] && data[p] <= 122 { goto st76 }
+	} else {
+		goto st76
+	}
+	goto st0
+tr140:
+// line 90 "zparse.rl"
+	{ tok.pushString(data[mark:p]) }
+	goto st77
+st77:
+	p++
+	if p == pe { goto _test_eof77 }
+	fallthrough
+case 77:
+// line 1751 "zparse.go"
+	switch data[p] {
+		case 9: goto st77
+		case 32: goto st77
+		case 43: goto tr143
+		case 61: goto tr143
+		case 92: goto tr143
+	}
+	if data[p] < 65 {
+		if 46 <= data[p] && data[p] <= 57 { goto tr143 }
+	} else if data[p] > 90 {
+		if 97 <= data[p] && data[p] <= 122 { goto tr143 }
+	} else {
+		goto tr143
+	}
+	goto st0
+tr143:
+// line 84 "zparse.rl"
+	{ mark = p }
+	goto st78
+st78:
+	p++
+	if p == pe { goto _test_eof78 }
+	fallthrough
+case 78:
+// line 1776 "zparse.go"
+	switch data[p] {
+		case 9: goto tr144
+		case 32: goto tr144
+		case 43: goto st78
+		case 61: goto st78
+		case 92: goto st78
+	}
+	if data[p] < 65 {
+		if 46 <= data[p] && data[p] <= 57 { goto st78 }
+	} else if data[p] > 90 {
+		if 97 <= data[p] && data[p] <= 122 { goto st78 }
+	} else {
+		goto st78
+	}
+	goto st0
+tr144:
+// line 90 "zparse.rl"
+	{ tok.pushString(data[mark:p]) }
+	goto st79
+st79:
+	p++
+	if p == pe { goto _test_eof79 }
+	fallthrough
+case 79:
+// line 1801 "zparse.go"
+	switch data[p] {
+		case 9: goto st79
+		case 32: goto st79
+	}
+	if 48 <= data[p] && data[p] <= 57 { goto tr147 }
+	goto st0
+tr147:
+// line 84 "zparse.rl"
+	{ mark = p }
+	goto st80
+st80:
+	p++
+	if p == pe { goto _test_eof80 }
+	fallthrough
+case 80:
+// line 1817 "zparse.go"
+	switch data[p] {
+		case 9: goto tr148
+		case 32: goto tr148
+	}
+	if 48 <= data[p] && data[p] <= 57 { goto st80 }
+	goto st0
+tr148:
+// line 89 "zparse.rl"
+	{ tok.pushInt(data[mark:p]) }
+	goto st81
+st81:
+	p++
+	if p == pe { goto _test_eof81 }
+	fallthrough
+case 81:
+// line 1833 "zparse.go"
+	switch data[p] {
+		case 9: goto st81
+		case 32: goto st81
+	}
+	if 48 <= data[p] && data[p] <= 57 { goto tr151 }
+	goto st0
+tr151:
+// line 84 "zparse.rl"
+	{ mark = p }
+	goto st82
+st82:
+	p++
+	if p == pe { goto _test_eof82 }
+	fallthrough
+case 82:
+// line 1849 "zparse.go"
+	switch data[p] {
+		case 9: goto tr152
+		case 32: goto tr152
+	}
+	if 48 <= data[p] && data[p] <= 57 { goto st82 }
+	goto st0
+tr152:
+// line 89 "zparse.rl"
+	{ tok.pushInt(data[mark:p]) }
+	goto st83
+st83:
+	p++
+	if p == pe { goto _test_eof83 }
+	fallthrough
+case 83:
+// line 1865 "zparse.go"
+	switch data[p] {
+		case 9: goto st83
+		case 32: goto st83
+	}
+	if 48 <= data[p] && data[p] <= 57 { goto tr155 }
+	goto st0
+tr155:
+// line 84 "zparse.rl"
+	{ mark = p }
+	goto st84
+st84:
+	p++
+	if p == pe { goto _test_eof84 }
+	fallthrough
+case 84:
+// line 1881 "zparse.go"
+	switch data[p] {
+		case 9: goto tr156
+		case 32: goto tr156
+	}
+	if 48 <= data[p] && data[p] <= 57 { goto st84 }
+	goto st0
+tr156:
+// line 89 "zparse.rl"
+	{ tok.pushInt(data[mark:p]) }
+	goto st85
+st85:
+	p++
+	if p == pe { goto _test_eof85 }
+	fallthrough
+case 85:
+// line 1897 "zparse.go"
+	switch data[p] {
+		case 9: goto st85
+		case 32: goto st85
+	}
+	if 48 <= data[p] && data[p] <= 57 { goto tr159 }
+	goto st0
+tr159:
+// line 84 "zparse.rl"
+	{ mark = p }
+	goto st86
+st86:
+	p++
+	if p == pe { goto _test_eof86 }
+	fallthrough
+case 86:
+// line 1913 "zparse.go"
+	switch data[p] {
+		case 9: goto tr160
+		case 32: goto tr160
+	}
+	if 48 <= data[p] && data[p] <= 57 { goto st86 }
+	goto st0
+tr160:
+// line 89 "zparse.rl"
+	{ tok.pushInt(data[mark:p]) }
+	goto st87
+st87:
+	p++
+	if p == pe { goto _test_eof87 }
+	fallthrough
+case 87:
+// line 1929 "zparse.go"
+	switch data[p] {
+		case 9: goto st87
+		case 32: goto st87
+	}
+	if 48 <= data[p] && data[p] <= 57 { goto tr163 }
+	goto st0
+tr163:
+// line 84 "zparse.rl"
+	{ mark = p }
+	goto st114
+st114:
+	p++
+	if p == pe { goto _test_eof114 }
+	fallthrough
+case 114:
+// line 1945 "zparse.go"
+	switch data[p] {
+		case 9: goto tr192
+		case 32: goto tr192
+		case 46: goto tr193
+		case 92: goto tr193
+	}
+	if data[p] < 65 {
+		if 48 <= data[p] && data[p] <= 57 { goto st114 }
+	} else if data[p] > 90 {
+		if 97 <= data[p] && data[p] <= 122 { goto tr193 }
+	} else {
+		goto tr193
+	}
+	goto st0
+tr193:
+// line 89 "zparse.rl"
+	{ tok.pushInt(data[mark:p]) }
+// line 20 "types.rl"
 	{
             rr.(*RR_SOA).Hdr = *hdr
             rr.(*RR_SOA).Ns = tok.T[0]
@@ -1869,140 +1970,91 @@ tr185:
             rr.(*RR_SOA).Expire = uint32(tok.N[3])
             rr.(*RR_SOA).Minttl = uint32(tok.N[4])
         }
-	goto st84
-st84:
-	p++
-	if p == pe { goto _test_eof84 }
-	fallthrough
-case 84:
-// line 1879 "zparse.go"
-	switch data[p] {
-		case 9: goto tr158
-		case 32: goto tr158
-		case 46: goto st84
-		case 92: goto st84
-	}
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st84 }
-	} else if data[p] > 90 {
-		if 97 <= data[p] && data[p] <= 122 { goto st84 }
-	} else {
-		goto st84
-	}
-	goto st0
-tr17:
-// line 84 "zparse.rl"
-	{ mark = p }
-	goto st85
-st85:
-	p++
-	if p == pe { goto _test_eof85 }
-	fallthrough
-case 85:
-// line 1903 "zparse.go"
-	switch data[p] {
-		case 72: goto st8
-		case 78: goto st12
-		case 83: goto st8
-		case 104: goto st8
-		case 110: goto st12
-		case 115: goto st8
-	}
-	goto st0
-tr19:
-// line 84 "zparse.rl"
-	{ mark = p }
-	goto st86
-st86:
-	p++
-	if p == pe { goto _test_eof86 }
-	fallthrough
-case 86:
-// line 1922 "zparse.go"
-	switch data[p] {
-		case 83: goto st8
-		case 115: goto st8
-	}
-	goto st0
-tr20:
-// line 84 "zparse.rl"
-	{ mark = p }
-	goto st87
-st87:
-	p++
-	if p == pe { goto _test_eof87 }
-	fallthrough
-case 87:
-// line 1937 "zparse.go"
-	switch data[p] {
-		case 78: goto st8
-		case 110: goto st8
-	}
-	goto st0
-tr22:
-// line 84 "zparse.rl"
-	{ mark = p }
 	goto st88
 st88:
 	p++
 	if p == pe { goto _test_eof88 }
 	fallthrough
 case 88:
-// line 1952 "zparse.go"
+// line 1980 "zparse.go"
 	switch data[p] {
-		case 79: goto st89
-		case 83: goto st44
-		case 111: goto st89
-		case 115: goto st44
+		case 9: goto tr164
+		case 32: goto tr164
+		case 46: goto st88
+		case 92: goto st88
+	}
+	if data[p] < 65 {
+		if 48 <= data[p] && data[p] <= 57 { goto st88 }
+	} else if data[p] > 90 {
+		if 97 <= data[p] && data[p] <= 122 { goto st88 }
+	} else {
+		goto st88
 	}
 	goto st0
+tr17:
+// line 84 "zparse.rl"
+	{ mark = p }
+	goto st89
 st89:
 	p++
 	if p == pe { goto _test_eof89 }
 	fallthrough
 case 89:
+// line 2004 "zparse.go"
 	switch data[p] {
-		case 78: goto st90
-		case 110: goto st90
+		case 72: goto st12
+		case 78: goto st16
+		case 83: goto st12
+		case 104: goto st12
+		case 110: goto st16
+		case 115: goto st12
 	}
 	goto st0
+tr19:
+// line 84 "zparse.rl"
+	{ mark = p }
+	goto st90
 st90:
 	p++
 	if p == pe { goto _test_eof90 }
 	fallthrough
 case 90:
+// line 2023 "zparse.go"
 	switch data[p] {
-		case 69: goto st8
-		case 101: goto st8
+		case 83: goto st12
+		case 115: goto st12
 	}
 	goto st0
-tr4:
+tr20:
 // line 84 "zparse.rl"
 	{ mark = p }
-// line 87 "zparse.rl"
-	{ /* ... */ }
 	goto st91
 st91:
 	p++
 	if p == pe { goto _test_eof91 }
 	fallthrough
 case 91:
-// line 1991 "zparse.go"
+// line 2038 "zparse.go"
 	switch data[p] {
-		case 9: goto tr25
-		case 32: goto tr25
-		case 78: goto st92
-		case 110: goto st92
+		case 78: goto st12
+		case 110: goto st12
 	}
 	goto st0
+tr22:
+// line 84 "zparse.rl"
+	{ mark = p }
+	goto st92
 st92:
 	p++
 	if p == pe { goto _test_eof92 }
 	fallthrough
 case 92:
+// line 2053 "zparse.go"
 	switch data[p] {
-		case 89: goto st93
-		case 121: goto st93
+		case 79: goto st93
+		case 83: goto st48
+		case 111: goto st93
+		case 115: goto st48
 	}
 	goto st0
 st93:
@@ -2011,75 +2063,126 @@ st93:
 	fallthrough
 case 93:
 	switch data[p] {
-		case 9: goto tr163
-		case 32: goto tr163
+		case 78: goto st94
+		case 110: goto st94
 	}
 	goto st0
-tr163:
-// line 86 "zparse.rl"
-	{ hdr.Class = Str_class[data[mark:p]] }
-	goto st94
 st94:
 	p++
 	if p == pe { goto _test_eof94 }
 	fallthrough
 case 94:
-// line 2028 "zparse.go"
 	switch data[p] {
-		case 9: goto st94
-		case 32: goto st94
-		case 65: goto tr32
-		case 67: goto tr33
-		case 68: goto tr18
-		case 77: goto tr21
-		case 78: goto tr34
-		case 82: goto tr23
-		case 83: goto tr24
-		case 97: goto tr32
-		case 99: goto tr33
-		case 100: goto tr18
-		case 109: goto tr21
-		case 110: goto tr34
-		case 114: goto tr23
-		case 115: goto tr24
+		case 69: goto st12
+		case 101: goto st12
 	}
-	if 48 <= data[p] && data[p] <= 57 { goto tr165 }
 	goto st0
-tr165:
+tr4:
 // line 84 "zparse.rl"
 	{ mark = p }
+// line 87 "zparse.rl"
+	{ /* ... */ }
 	goto st95
 st95:
 	p++
 	if p == pe { goto _test_eof95 }
 	fallthrough
 case 95:
-// line 2058 "zparse.go"
+// line 2092 "zparse.go"
 	switch data[p] {
-		case 9: goto tr166
-		case 32: goto tr166
+		case 9: goto tr25
+		case 32: goto tr25
+		case 65: goto st7
+		case 78: goto st96
+		case 97: goto st7
+		case 110: goto st96
 	}
-	if 48 <= data[p] && data[p] <= 57 { goto st95 }
+	goto st0
+st96:
+	p++
+	if p == pe { goto _test_eof96 }
+	fallthrough
+case 96:
+	switch data[p] {
+		case 89: goto st97
+		case 121: goto st97
+	}
+	goto st0
+st97:
+	p++
+	if p == pe { goto _test_eof97 }
+	fallthrough
+case 97:
+	switch data[p] {
+		case 9: goto tr169
+		case 32: goto tr169
+	}
+	goto st0
+tr169:
+// line 86 "zparse.rl"
+	{ hdr.Class = Str_class[data[mark:p]] }
+	goto st98
+st98:
+	p++
+	if p == pe { goto _test_eof98 }
+	fallthrough
+case 98:
+// line 2131 "zparse.go"
+	switch data[p] {
+		case 9: goto st98
+		case 32: goto st98
+		case 65: goto tr38
+		case 67: goto tr39
+		case 68: goto tr18
+		case 77: goto tr21
+		case 78: goto tr40
+		case 82: goto tr23
+		case 83: goto tr24
+		case 97: goto tr38
+		case 99: goto tr39
+		case 100: goto tr18
+		case 109: goto tr21
+		case 110: goto tr40
+		case 114: goto tr23
+		case 115: goto tr24
+	}
+	if 48 <= data[p] && data[p] <= 57 { goto tr171 }
+	goto st0
+tr171:
+// line 84 "zparse.rl"
+	{ mark = p }
+	goto st99
+st99:
+	p++
+	if p == pe { goto _test_eof99 }
+	fallthrough
+case 99:
+// line 2161 "zparse.go"
+	switch data[p] {
+		case 9: goto tr172
+		case 32: goto tr172
+	}
+	if 48 <= data[p] && data[p] <= 57 { goto st99 }
 	goto st0
 tr5:
 // line 84 "zparse.rl"
 	{ mark = p }
 // line 87 "zparse.rl"
 	{ /* ... */ }
-	goto st96
-st96:
+	goto st100
+st100:
 	p++
-	if p == pe { goto _test_eof96 }
+	if p == pe { goto _test_eof100 }
 	fallthrough
-case 96:
-// line 2076 "zparse.go"
+case 100:
+// line 2179 "zparse.go"
 	switch data[p] {
-		case 72: goto st93
-		case 78: goto st12
-		case 83: goto st93
-		case 104: goto st93
-		case 110: goto st12
-		case 115: goto st93
+		case 72: goto st97
+		case 78: goto st16
+		case 83: goto st97
+		case 104: goto st97
+		case 110: goto st16
+		case 115: goto st97
 	}
 	goto st0
 tr7:
@@ -2087,16 +2190,16 @@ tr7:
 	{ mark = p }
 // line 87 "zparse.rl"
 	{ /* ... */ }
-	goto st97
-st97:
+	goto st101
+st101:
 	p++
-	if p == pe { goto _test_eof97 }
+	if p == pe { goto _test_eof101 }
 	fallthrough
-case 97:
-// line 2097 "zparse.go"
+case 101:
+// line 2200 "zparse.go"
 	switch data[p] {
-		case 83: goto st93
-		case 115: goto st93
+		case 83: goto st97
+		case 115: goto st97
 	}
 	goto st0
 tr8:
@@ -2104,16 +2207,16 @@ tr8:
 	{ mark = p }
 // line 87 "zparse.rl"
 	{ /* ... */ }
-	goto st98
-st98:
+	goto st102
+st102:
 	p++
-	if p == pe { goto _test_eof98 }
+	if p == pe { goto _test_eof102 }
 	fallthrough
-case 98:
-// line 2114 "zparse.go"
+case 102:
+// line 2217 "zparse.go"
 	switch data[p] {
-		case 78: goto st93
-		case 110: goto st93
+		case 78: goto st97
+		case 110: goto st97
 	}
 	goto st0
 tr10:
@@ -2121,38 +2224,38 @@ tr10:
 	{ mark = p }
 // line 87 "zparse.rl"
 	{ /* ... */ }
-	goto st99
-st99:
+	goto st103
+st103:
 	p++
-	if p == pe { goto _test_eof99 }
+	if p == pe { goto _test_eof103 }
 	fallthrough
-case 99:
-// line 2131 "zparse.go"
+case 103:
+// line 2234 "zparse.go"
 	switch data[p] {
-		case 79: goto st100
-		case 83: goto st44
-		case 111: goto st100
-		case 115: goto st44
+		case 79: goto st104
+		case 83: goto st48
+		case 111: goto st104
+		case 115: goto st48
 	}
 	goto st0
-st100:
+st104:
 	p++
-	if p == pe { goto _test_eof100 }
+	if p == pe { goto _test_eof104 }
 	fallthrough
-case 100:
+case 104:
 	switch data[p] {
-		case 78: goto st101
-		case 110: goto st101
+		case 78: goto st105
+		case 110: goto st105
 	}
 	goto st0
-st101:
+st105:
 	p++
-	if p == pe { goto _test_eof101 }
+	if p == pe { goto _test_eof105 }
 	fallthrough
-case 101:
+case 105:
 	switch data[p] {
-		case 69: goto st93
-		case 101: goto st93
+		case 69: goto st97
+		case 101: goto st97
 	}
 	goto st0
 	}
@@ -2161,22 +2264,23 @@ case 101:
 	_test_eof4: cs = 4; goto _test_eof; 
 	_test_eof5: cs = 5; goto _test_eof; 
 	_test_eof6: cs = 6; goto _test_eof; 
-	_test_eof102: cs = 102; goto _test_eof; 
+	_test_eof106: cs = 106; 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_eof107: cs = 107; 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_eof103: cs = 103; 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_eof108: cs = 108; goto _test_eof; 
 	_test_eof21: cs = 21; goto _test_eof; 
 	_test_eof22: cs = 22; goto _test_eof; 
 	_test_eof23: cs = 23; goto _test_eof; 
@@ -2186,30 +2290,30 @@ case 101:
 	_test_eof27: cs = 27; goto _test_eof; 
 	_test_eof28: cs = 28; goto _test_eof; 
 	_test_eof29: cs = 29; goto _test_eof; 
-	_test_eof104: cs = 104; 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_eof109: cs = 109; 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_eof105: cs = 105; 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_eof110: cs = 110; goto _test_eof; 
 	_test_eof42: cs = 42; goto _test_eof; 
-	_test_eof106: cs = 106; 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_eof107: cs = 107; goto _test_eof; 
 	_test_eof46: cs = 46; goto _test_eof; 
+	_test_eof111: cs = 111; 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_eof112: cs = 112; goto _test_eof; 
 	_test_eof50: cs = 50; goto _test_eof; 
 	_test_eof51: cs = 51; goto _test_eof; 
 	_test_eof52: cs = 52; goto _test_eof; 
@@ -2228,11 +2332,11 @@ case 101:
 	_test_eof65: cs = 65; goto _test_eof; 
 	_test_eof66: cs = 66; goto _test_eof; 
 	_test_eof67: cs = 67; goto _test_eof; 
-	_test_eof108: cs = 108; 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_eof113: cs = 113; goto _test_eof; 
 	_test_eof72: cs = 72; goto _test_eof; 
 	_test_eof73: cs = 73; goto _test_eof; 
 	_test_eof74: cs = 74; goto _test_eof; 
@@ -2245,11 +2349,11 @@ case 101:
 	_test_eof81: cs = 81; goto _test_eof; 
 	_test_eof82: cs = 82; goto _test_eof; 
 	_test_eof83: cs = 83; goto _test_eof; 
-	_test_eof109: cs = 109; 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_eof114: cs = 114; goto _test_eof; 
 	_test_eof88: cs = 88; goto _test_eof; 
 	_test_eof89: cs = 89; goto _test_eof; 
 	_test_eof90: cs = 90; goto _test_eof; 
@@ -2264,14 +2368,18 @@ case 101:
 	_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_eof: {}
 	if p == eof {
 	switch cs {
-	case 109:
+	case 114:
 // line 89 "zparse.rl"
 	{ tok.pushInt(data[mark:p]) }
-// line 16 "types.rl"
+// line 20 "types.rl"
 	{
             rr.(*RR_SOA).Hdr = *hdr
             rr.(*RR_SOA).Ns = tok.T[0]
@@ -2283,7 +2391,7 @@ case 101:
             rr.(*RR_SOA).Minttl = uint32(tok.N[4])
         }
 	break
-	case 102:
+	case 106:
 // line 90 "zparse.rl"
 	{ tok.pushString(data[mark:p]) }
 // line 4 "types.rl"
@@ -2296,34 +2404,43 @@ case 101:
 // line 90 "zparse.rl"
 	{ tok.pushString(data[mark:p]) }
 // line 8 "types.rl"
+	{
+            rr.(*RR_AAAA).Hdr = *hdr
+            rr.(*RR_AAAA).AAAA = net.ParseIP(data[mark:p])
+        }
+	break
+	case 112:
+// line 90 "zparse.rl"
+	{ tok.pushString(data[mark:p]) }
+// line 12 "types.rl"
 	{
             rr.(*RR_NS).Hdr = *hdr
             rr.(*RR_NS).Ns = tok.T[0]
         }
 	break
-	case 103:
+	case 108:
 // line 90 "zparse.rl"
 	{ tok.pushString(data[mark:p]) }
-// line 12 "types.rl"
+// line 16 "types.rl"
 	{
             rr.(*RR_CNAME).Hdr = *hdr
             rr.(*RR_CNAME).Cname = tok.T[0]
         }
 	break
-	case 106:
+	case 111:
 // line 90 "zparse.rl"
 	{ tok.pushString(data[mark:p]) }
-// line 26 "types.rl"
+// line 30 "types.rl"
 	{
             rr.(*RR_MX).Hdr = *hdr;
             rr.(*RR_MX).Pref = uint16(tok.N[0])
             rr.(*RR_MX).Mx = tok.T[0]
         }
 	break
-	case 105:
+	case 110:
 // line 90 "zparse.rl"
 	{ tok.pushString(data[mark:p]) }
-// line 31 "types.rl"
+// line 35 "types.rl"
 	{
             rr.(*RR_DS).Hdr = *hdr;
             rr.(*RR_DS).KeyTag = uint16(tok.N[0])
@@ -2332,10 +2449,10 @@ case 101:
             rr.(*RR_DS).Digest = tok.T[0]
         }
 	break
-	case 104:
+	case 109:
 // line 90 "zparse.rl"
 	{ tok.pushString(data[mark:p]) }
-// line 38 "types.rl"
+// line 42 "types.rl"
 	{
             rr.(*RR_DNSKEY).Hdr = *hdr;
             rr.(*RR_DNSKEY).Flags = uint16(tok.N[0])
@@ -2344,10 +2461,10 @@ case 101:
             rr.(*RR_DNSKEY).PublicKey = tok.T[0]
         }
 	break
-	case 108:
+	case 113:
 // line 90 "zparse.rl"
 	{ tok.pushString(data[mark:p]) }
-// line 45 "types.rl"
+// line 49 "types.rl"
 	{
             rr.(*RR_RRSIG).Hdr = *hdr;
             rr.(*RR_RRSIG).TypeCovered = uint16(tok.N[0])
@@ -2361,14 +2478,14 @@ case 101:
             rr.(*RR_RRSIG).Signature = tok.T[1]
         }
 	break
-// line 2365 "zparse.go"
+// line 2482 "zparse.go"
 	}
 	}
 
 	_out: {}
 	}
 
-// line 139 "zparse.rl"
+// line 140 "zparse.rl"
 
 
         if cs < z_first_final {
diff --git a/zparse.rl b/zparse.rl
index 41128f99..1fa41043 100644
--- a/zparse.rl
+++ b/zparse.rl
@@ -122,6 +122,7 @@ func Zparse(q io.Reader) (rr RR, err os.Error) {
                 # RR definitions
                 rhs = (
                        ('A'i         %qtype bl t) %rdata_a
+                     | ('AAAA'i      %qtype bl t) %rdata_aaaa
                      | ('NS'i        %qtype bl t) %rdata_ns
                      | ('CNAME'i     %qtype bl t) %rdata_cname
                      | ('SOA'i       %qtype bl t bl t bl n bl n bl n bl n bl n) %rdata_soa