diff --git a/client.go b/client.go
index 2433424b..8cf8968b 100644
--- a/client.go
+++ b/client.go
@@ -108,7 +108,7 @@ func (mux *QueryMux) HandleQueryFunc(pattern string, handler func(RequestWriter,
 func (mux *QueryMux) QueryDNS(w RequestWriter, r *Msg) {
 	h := mux.match(r.Question[0].Name)
 	if h == nil {
-                panic("dns: no handler found for " + r.Question[0].Name)
+		panic("dns: no handler found for " + r.Question[0].Name)
 	}
 	h.QueryDNS(w, r)
 }
@@ -122,7 +122,7 @@ type Client struct {
 	ReadTimeout  int64             // the net.Conn.SetReadTimeout value for new connections
 	WriteTimeout int64             // the net.Conn.SetWriteTimeout value for new connections
 	TsigSecret   map[string]string // secret(s) for Tsig map[<zonename>]<base64 secret>
-        // LocalAddr string            // Local address to use
+	// LocalAddr string            // Local address to use
 }
 
 // Create a new client, with some defaults.
@@ -144,7 +144,7 @@ func (q *Query) Query() os.Error {
 	if handler == nil {
 		handler = DefaultQueryMux
 	}
-//forever:
+	//forever:
 	for {
 		select {
 		case in := <-q.ChannelQuery:
@@ -210,7 +210,7 @@ func (c *Client) Exchange(m *Msg, a string) *Msg {
 		return nil
 	}
 	p = p[:n]
-        r := new(Msg)
+	r := new(Msg)
 	if ok := r.Unpack(p); !ok {
 		return nil
 	}
diff --git a/client_test.go b/client_test.go
index f4b17380..51a52fa5 100644
--- a/client_test.go
+++ b/client_test.go
@@ -2,7 +2,7 @@ package dns
 
 import (
 	"testing"
-        "time"
+	"time"
 )
 
 func TestClientSync(t *testing.T) {
@@ -80,19 +80,19 @@ func TestClientTsigAXFR(t *testing.T) {
 	m := new(Msg)
 	m.SetAxfr("miek.nl")
 
-        m.SetTsig("axfr", HmacMD5, 300, uint64(time.Seconds()))
-        secrets := make(map[string]string)
-        secrets["axfr"] = "so6ZGir4GPAqINNh9U5c3A=="
+	m.SetTsig("axfr", HmacMD5, 300, uint64(time.Seconds()))
+	secrets := make(map[string]string)
+	secrets["axfr"] = "so6ZGir4GPAqINNh9U5c3A=="
 
-        c := NewClient()
-        c.Net = "tcp"
-        c.TsigSecret = secrets
+	c := NewClient()
+	c.Net = "tcp"
+	c.TsigSecret = secrets
 
-        c.XfrReceive(m, "85.223.71.124:53")
-        /*
-        if err != nil {
-                t.Log("%s\n", err.String())
-                t.Fail()
-        }
-        */
+	c.XfrReceive(m, "85.223.71.124:53")
+	/*
+	   if err != nil {
+	           t.Log("%s\n", err.String())
+	           t.Fail()
+	   }
+	*/
 }
diff --git a/clientconfig.go b/clientconfig.go
index 85243782..750c5e55 100644
--- a/clientconfig.go
+++ b/clientconfig.go
@@ -38,7 +38,7 @@ func ClientConfigFromFile(conf string) (*ClientConfig, os.Error) {
 	b := bufio.NewReader(file)
 	c.Servers = make([]string, 3)[0:0] // small, but the standard limit
 	c.Search = make([]string, 0)
-        c.Port = "53"
+	c.Port = "53"
 	c.Ndots = 1
 	c.Timeout = 5
 	c.Attempts = 2
diff --git a/dnssec.go b/dnssec.go
index 0d31997c..3b31e0ed 100644
--- a/dnssec.go
+++ b/dnssec.go
@@ -6,8 +6,8 @@ import (
 	"crypto/sha1"
 	"crypto/sha256"
 	"crypto/sha512"
-        "crypto/ecdsa"
-        "crypto/elliptic"
+	"crypto/ecdsa"
+	"crypto/elliptic"
 	"crypto/rsa"
 	"crypto/rand"
 	"encoding/hex"
@@ -22,25 +22,25 @@ import (
 
 // DNSSEC encryption algorithm codes.
 const (
-	RSAMD5    = 1
-	DH        = 2
-	DSA       = 3
-	ECC       = 4
-	RSASHA1   = 5
-	RSASHA256 = 8
-	RSASHA512 = 10
-	ECCGOST   = 12
-        ECDSAP256SHA256 = 13
-        ECDSAP384SHA384 = 14
+	RSAMD5          = 1
+	DH              = 2
+	DSA             = 3
+	ECC             = 4
+	RSASHA1         = 5
+	RSASHA256       = 8
+	RSASHA512       = 10
+	ECCGOST         = 12
+	ECDSAP256SHA256 = 13
+	ECDSAP384SHA384 = 14
 )
 
 // DNSSEC hashing algorithm codes.
 const (
-	_ = iota
-	SHA1        // RFC 4034
-	SHA256      // RFC 4509 
-	GOST94      // RFC 5933
-        SHA384      // Experimental
+	_      = iota
+	SHA1   // RFC 4034
+	SHA256 // RFC 4509 
+	GOST94 // RFC 5933
+	SHA384 // Experimental
 )
 
 // DNSKEY flag values.
@@ -151,8 +151,8 @@ func (k *RR_DNSKEY) ToDS(h int) *RR_DS {
 		s := sha256.New()
 		io.WriteString(s, string(digest))
 		ds.Digest = hex.EncodeToString(s.Sum())
-        case SHA384:
-                s := sha512.New384()
+	case SHA384:
+		s := sha512.New384()
 		io.WriteString(s, string(digest))
 		ds.Digest = hex.EncodeToString(s.Sum())
 	case GOST94:
@@ -213,49 +213,49 @@ func (s *RR_RRSIG) Sign(k PrivateKey, rrset RRset) bool {
 	}
 	signdata = append(signdata, wire...)
 
-        var sighash []byte
-        var h hash.Hash
-	var ch crypto.Hash      // Only need for RSA
-        switch s.Algorithm {
-                case RSAMD5:
-                        h = md5.New()
-			ch = crypto.MD5
-	        case RSASHA1:
-                        h = sha1.New()
-			ch = crypto.SHA1
-                case RSASHA256, ECDSAP256SHA256:
-                        h = sha256.New()
-			ch = crypto.SHA256
-                case ECDSAP384SHA384:
-                        h = sha512.New384()
-                case RSASHA512:
-                        h = sha512.New()
-			ch = crypto.SHA512
-                default:
-                        return false            // Illegal alg
-        }
-        io.WriteString(h, string(signdata))
-        sighash = h.Sum()
+	var sighash []byte
+	var h hash.Hash
+	var ch crypto.Hash // Only need for RSA
+	switch s.Algorithm {
+	case RSAMD5:
+		h = md5.New()
+		ch = crypto.MD5
+	case RSASHA1:
+		h = sha1.New()
+		ch = crypto.SHA1
+	case RSASHA256, ECDSAP256SHA256:
+		h = sha256.New()
+		ch = crypto.SHA256
+	case ECDSAP384SHA384:
+		h = sha512.New384()
+	case RSASHA512:
+		h = sha512.New()
+		ch = crypto.SHA512
+	default:
+		return false // Illegal alg
+	}
+	io.WriteString(h, string(signdata))
+	sighash = h.Sum()
 
-        switch p := k.(type) {
-        case *rsa.PrivateKey:
-                signature, err := rsa.SignPKCS1v15(rand.Reader, p, ch, sighash)
-                if err != nil {
-                        return false
-                }
-                s.Signature = unpackBase64(signature)
-        case *ecdsa.PrivateKey:
-                r1, s1, err := ecdsa.Sign(rand.Reader, p, sighash)
-                if err != nil {
-                        return false
-                }
-                signature := r1.Bytes()
-                signature = append(signature, s1.Bytes()...)
-                s.Signature =unpackBase64(signature)
-        default:
-                // Not given the correct key
-                return false
-        }
+	switch p := k.(type) {
+	case *rsa.PrivateKey:
+		signature, err := rsa.SignPKCS1v15(rand.Reader, p, ch, sighash)
+		if err != nil {
+			return false
+		}
+		s.Signature = unpackBase64(signature)
+	case *ecdsa.PrivateKey:
+		r1, s1, err := ecdsa.Sign(rand.Reader, p, sighash)
+		if err != nil {
+			return false
+		}
+		signature := r1.Bytes()
+		signature = append(signature, s1.Bytes()...)
+		s.Signature = unpackBase64(signature)
+	default:
+		// Not given the correct key
+		return false
+	}
 	return true
 }
 
@@ -394,23 +394,23 @@ func (k *RR_DNSKEY) pubKeyRSA() *rsa.PublicKey {
 
 // Extract the Curve public key from the Key record
 func (k *RR_DNSKEY) pubKeyCurve() *ecdsa.PublicKey {
-        keybuf, err := packBase64([]byte(k.PublicKey))
-        if err != nil {
-                return nil
-        }
-        var c *elliptic.Curve
-        switch k.Algorithm {
-        case ECDSAP256SHA256:
-                c = elliptic.P256()
-        case ECDSAP384SHA384:
-                c = elliptic.P384()
-        }
-        x, y := c.Unmarshal(keybuf)
-        pubkey := new(ecdsa.PublicKey)
-        pubkey.X = x
-        pubkey.Y = y
-        pubkey.Curve = c
-        return pubkey
+	keybuf, err := packBase64([]byte(k.PublicKey))
+	if err != nil {
+		return nil
+	}
+	var c *elliptic.Curve
+	switch k.Algorithm {
+	case ECDSAP256SHA256:
+		c = elliptic.P256()
+	case ECDSAP384SHA384:
+		c = elliptic.P384()
+	}
+	x, y := c.Unmarshal(keybuf)
+	pubkey := new(ecdsa.PublicKey)
+	pubkey.X = x
+	pubkey.Y = y
+	pubkey.Curve = c
+	return pubkey
 }
 
 // Set the public key (the value E and N)
@@ -426,12 +426,12 @@ func (k *RR_DNSKEY) setPublicKeyRSA(_E int, _N *big.Int) bool {
 
 // Set the public key for Elliptic Curves
 func (k *RR_DNSKEY) setPublicKeyCurve(_X, _Y *big.Int) bool {
-        if _X == nil || _Y == nil {
-                return false
-        }
-        buf := curveToBuf(_X, _Y)
-        k.PublicKey = unpackBase64(buf)
-        return true
+	if _X == nil || _Y == nil {
+		return false
+	}
+	buf := curveToBuf(_X, _Y)
+	k.PublicKey = unpackBase64(buf)
+	return true
 }
 
 // Set the public key (the values E and N) for RSA
@@ -455,9 +455,9 @@ func exponentToBuf(_E int) []byte {
 // Set the public key for X and Y for Curve
 // Experimental
 func curveToBuf(_X, _Y *big.Int) []byte {
-        buf := _X.Bytes()
-        buf = append(buf, _Y.Bytes()...)
-        return buf
+	buf := _X.Bytes()
+	buf = append(buf, _Y.Bytes()...)
+	return buf
 }
 
 // return a saw signature data 
@@ -500,13 +500,13 @@ func rawSignatureData(rrset RRset, s *RR_RRSIG) (buf []byte) {
 
 // Map for algorithm names.
 var alg_str = map[uint8]string{
-	RSAMD5:    "RSAMD5",
-	DH:        "DH",
-	DSA:       "DSA",
-	RSASHA1:   "RSASHA1",
-	RSASHA256: "RSASHA256",
-	RSASHA512: "RSASHA512",
-	ECCGOST:   "ECC-GOST",
-        ECDSAP256SHA256: "ECDSAP256SHA256",
-        ECDSAP384SHA384: "ECDSAP384SHA384",
+	RSAMD5:          "RSAMD5",
+	DH:              "DH",
+	DSA:             "DSA",
+	RSASHA1:         "RSASHA1",
+	RSASHA256:       "RSASHA256",
+	RSASHA512:       "RSASHA512",
+	ECCGOST:         "ECC-GOST",
+	ECDSAP256SHA256: "ECDSAP256SHA256",
+	ECDSAP384SHA384: "ECDSAP384SHA384",
 }
diff --git a/dnssec_test.go b/dnssec_test.go
index 4c4c9930..5428a4c5 100644
--- a/dnssec_test.go
+++ b/dnssec_test.go
@@ -119,10 +119,10 @@ func TestSignVerify(t *testing.T) {
 }
 
 func TestKeyGen(t *testing.T) {
-        algs := []uint8{RSASHA256, ECDSAP256SHA256}
-        bits := []int{1024, 256}
+	algs := []uint8{RSASHA256, ECDSAP256SHA256}
+	bits := []int{1024, 256}
 
-        i := 0
+	i := 0
 	key := new(RR_DNSKEY)
 	key.Hdr.Name = "keygen.miek.nl."
 	key.Hdr.Rrtype = TypeDNSKEY
@@ -130,13 +130,13 @@ func TestKeyGen(t *testing.T) {
 	key.Hdr.Ttl = 3600
 	key.Flags = 256
 	key.Protocol = 3
-        for _, v := range algs {
-                key.Algorithm = v
-                key.Generate(bits[i])
-                i++
-                t.Logf("%s\n", key)
-        }
-        //Really hard to figure out what to check here... Parse it back to a proper key?
+	for _, v := range algs {
+		key.Algorithm = v
+		key.Generate(bits[i])
+		i++
+		t.Logf("%s\n", key)
+	}
+	//Really hard to figure out what to check here... Parse it back to a proper key?
 }
 
 /*
diff --git a/keygen.go b/keygen.go
index 5ff118fd..02ea8921 100644
--- a/keygen.go
+++ b/keygen.go
@@ -2,12 +2,12 @@ package dns
 
 import (
 	"os"
-        "io"
+	"io"
 	"big"
 	"strconv"
 	"crypto/rsa"
-        "crypto/ecdsa"
-        "crypto/elliptic"
+	"crypto/ecdsa"
+	"crypto/elliptic"
 	"crypto/rand"
 )
 
@@ -31,14 +31,14 @@ func (r *RR_DNSKEY) Generate(bits int) (PrivateKey, os.Error) {
 		if bits < 1024 || bits > 4096 {
 			return nil, ErrKeySize
 		}
-        case ECDSAP256SHA256:
-                if bits != 256 {
-                        return nil, ErrKeySize
-                }
-        case ECDSAP384SHA384:
-                if bits != 384 {
-                        return nil, ErrKeySize
-                }
+	case ECDSAP256SHA256:
+		if bits != 256 {
+			return nil, ErrKeySize
+		}
+	case ECDSAP384SHA384:
+		if bits != 384 {
+			return nil, ErrKeySize
+		}
 	}
 
 	switch r.Algorithm {
@@ -47,22 +47,22 @@ func (r *RR_DNSKEY) Generate(bits int) (PrivateKey, os.Error) {
 		if err != nil {
 			return nil, err
 		}
-                r.setPublicKeyRSA(priv.PublicKey.E, priv.PublicKey.N)
+		r.setPublicKeyRSA(priv.PublicKey.E, priv.PublicKey.N)
+		return priv, nil
+	case ECDSAP256SHA256, ECDSAP384SHA384:
+		var c *elliptic.Curve
+		switch r.Algorithm {
+		case ECDSAP256SHA256:
+			c = elliptic.P256()
+		case ECDSAP384SHA384:
+			c = elliptic.P384()
+		}
+		priv, err := ecdsa.GenerateKey(c, rand.Reader)
+		if err != nil {
+			return nil, err
+		}
+		r.setPublicKeyCurve(priv.PublicKey.X, priv.PublicKey.Y)
 		return priv, nil
-        case ECDSAP256SHA256, ECDSAP384SHA384:
-                var c *elliptic.Curve
-                switch r.Algorithm {
-                case ECDSAP256SHA256:
-                        c = elliptic.P256()
-                case ECDSAP384SHA384:
-                        c = elliptic.P384()
-                }
-                priv, err := ecdsa.GenerateKey(c, rand.Reader)
-                if err != nil {
-                        return nil, err
-                }
-                r.setPublicKeyCurve(priv.PublicKey.X, priv.PublicKey.Y)
-                return priv, nil
 	default:
 		return nil, ErrAlg
 	}
@@ -106,81 +106,81 @@ func (r *RR_DNSKEY) PrivateKeyString(p PrivateKey) (s string) {
 			"Exponent1: " + exponent1 + "\n" +
 			"Exponent2: " + exponent2 + "\n" +
 			"Coefficient: " + coefficient + "\n"
-        case *ecdsa.PrivateKey:
-                //
+	case *ecdsa.PrivateKey:
+		//
 	}
 	return
 }
 
 func (k *RR_DNSKEY) Read(q io.Reader) os.Error {
-        p := NewParser(q)
-        r := p.RR()
-        if r == nil {
-                return nil
-        }
-        if _, ok := r.(*RR_DNSKEY); !ok {
-                panic("did not read a DNSKEY")
-        }
-        k.Hdr = r.(*RR_DNSKEY).Hdr
-        k.Flags = r.(*RR_DNSKEY).Flags
-        k.Protocol = r.(*RR_DNSKEY).Protocol
-        k.Algorithm = r.(*RR_DNSKEY).Algorithm
-        k.PublicKey = r.(*RR_DNSKEY).PublicKey
-        return nil
+	p := NewParser(q)
+	r := p.RR()
+	if r == nil {
+		return nil
+	}
+	if _, ok := r.(*RR_DNSKEY); !ok {
+		panic("did not read a DNSKEY")
+	}
+	k.Hdr = r.(*RR_DNSKEY).Hdr
+	k.Flags = r.(*RR_DNSKEY).Flags
+	k.Protocol = r.(*RR_DNSKEY).Protocol
+	k.Algorithm = r.(*RR_DNSKEY).Algorithm
+	k.PublicKey = r.(*RR_DNSKEY).PublicKey
+	return nil
 }
 
 func (k *RR_DNSKEY) ReadPrivateKey(q io.Reader) (PrivateKey, os.Error) {
-        p := NewParser(q)
-        kv, _ := p.PrivateKey()
-        if _, ok := kv["private-key-format"]; !ok {
-                return nil, ErrPrivKey
-        }
-        if kv["private-key-format"] != "v1.2" && kv["private-key-format"] != "v1.3" {
-                return nil, ErrPrivKey
-        }
-        switch kv["algorithm"] {
-        case "RSAMD5", "RSASHA1", "RSASHA256", "RSASHA512":
-                return k.readPrivateKeyRSA(kv)
-        case "ECDSAP256SHA256", "ECDSAP384SHA384":
-                return k.readPrivateKeyECDSA(kv)
-        }
+	p := NewParser(q)
+	kv, _ := p.PrivateKey()
+	if _, ok := kv["private-key-format"]; !ok {
+		return nil, ErrPrivKey
+	}
+	if kv["private-key-format"] != "v1.2" && kv["private-key-format"] != "v1.3" {
+		return nil, ErrPrivKey
+	}
+	switch kv["algorithm"] {
+	case "RSAMD5", "RSASHA1", "RSASHA256", "RSASHA512":
+		return k.readPrivateKeyRSA(kv)
+	case "ECDSAP256SHA256", "ECDSAP384SHA384":
+		return k.readPrivateKeyECDSA(kv)
+	}
 	return nil, ErrPrivKey
 }
 
 // Read a private key (file) string and create a public key. Return the private key.
 func (k *RR_DNSKEY) readPrivateKeyRSA(kv map[string]string) (PrivateKey, os.Error) {
 	p := new(rsa.PrivateKey)
-	p.Primes = []*big.Int{nil,nil}
-        for k, v := range kv {
-                switch k {
-                case "modulus", "publicexponent", "privateexponent", "prime1", "prime2":
-                        v1, err := packBase64([]byte(v))
-                        if err != nil {
-                                return nil, err
-                        }
-                        switch k {
-                        case "modulus":
-                                p.PublicKey.N = big.NewInt(0)
-                                p.PublicKey.N.SetBytes(v1)
-                        case "publicexponent":
-                                i := big.NewInt(0)
-                                i.SetBytes(v1)
-                                p.PublicKey.E = int(i.Int64()) // int64 should be large enough
-                        case "privateexponent":
-                                p.D = big.NewInt(0)
-                                p.D.SetBytes(v1)
-                        case "prime1":
-                                p.Primes[0] = big.NewInt(0)
-                                p.Primes[0].SetBytes(v1)
-                        case "prime2":
-                                p.Primes[1] = big.NewInt(0)
-                                p.Primes[1].SetBytes(v1)
-                        }
-                case "exponent1", "exponent2", "coefficient":
-                        // not used in Go (yet)
-                case "created", "publish", "activate":
-                        // not used in Go (yet)
-                }
+	p.Primes = []*big.Int{nil, nil}
+	for k, v := range kv {
+		switch k {
+		case "modulus", "publicexponent", "privateexponent", "prime1", "prime2":
+			v1, err := packBase64([]byte(v))
+			if err != nil {
+				return nil, err
+			}
+			switch k {
+			case "modulus":
+				p.PublicKey.N = big.NewInt(0)
+				p.PublicKey.N.SetBytes(v1)
+			case "publicexponent":
+				i := big.NewInt(0)
+				i.SetBytes(v1)
+				p.PublicKey.E = int(i.Int64()) // int64 should be large enough
+			case "privateexponent":
+				p.D = big.NewInt(0)
+				p.D.SetBytes(v1)
+			case "prime1":
+				p.Primes[0] = big.NewInt(0)
+				p.Primes[0].SetBytes(v1)
+			case "prime2":
+				p.Primes[1] = big.NewInt(0)
+				p.Primes[1].SetBytes(v1)
+			}
+		case "exponent1", "exponent2", "coefficient":
+			// not used in Go (yet)
+		case "created", "publish", "activate":
+			// not used in Go (yet)
+		}
 	}
 	return p, nil
 }
@@ -188,18 +188,18 @@ func (k *RR_DNSKEY) readPrivateKeyRSA(kv map[string]string) (PrivateKey, os.Erro
 func (k *RR_DNSKEY) readPrivateKeyECDSA(kv map[string]string) (PrivateKey, os.Error) {
 	p := new(ecdsa.PrivateKey)
 	p.D = big.NewInt(0)
-        // Need to check if we have everything
-        for k, v := range kv {
-                switch k {
-                case "privatekey:":
-                        v1, err := packBase64([]byte(v))
-                        if err != nil {
-                                return nil, err
-                        }
-                        p.D.SetBytes(v1)
-                case "created:", "publish:", "activate:":
-                        /* not used in Go (yet) */
-                }
-        }
+	// Need to check if we have everything
+	for k, v := range kv {
+		switch k {
+		case "privatekey:":
+			v1, err := packBase64([]byte(v))
+			if err != nil {
+				return nil, err
+			}
+			p.D.SetBytes(v1)
+		case "created:", "publish:", "activate:":
+			/* not used in Go (yet) */
+		}
+	}
 	return p, nil
 }
diff --git a/kparse.go b/kparse.go
index d92f8392..637ee198 100644
--- a/kparse.go
+++ b/kparse.go
@@ -1,12 +1,11 @@
-
 // line 1 "kparse.rl"
 package dns
 
 // Parse private key files
 
 import (
-    "os"
-    "strings"
+	"os"
+	"strings"
 )
 
 
@@ -25,1562 +24,2414 @@ var k_en_main int = 111
 // A map[string]string is returned with the values. All the keys
 // are in lowercase. The algorithm is returned as m[algorithm] = "RSASHA1"
 func (kp *Parser) PrivateKey() (m map[string]string, err os.Error) {
-        m = make(map[string]string)
-        var (
-            k, data string
-            cs, p, pe int
-        )
-        lines := strings.SplitAfter(string(kp.buf), "\n", -1)
-        for _, data := range lines {
-            cs, p, pe = 0, 0, len(data)
-            mark := 0
+	m = make(map[string]string)
+	var (
+		k, data   string
+		cs, p, pe int
+	)
+	lines := strings.SplitAfter(string(kp.buf), "\n", -1)
+	for _, data := range lines {
+		cs, p, pe = 0, 0, len(data)
+		mark := 0
 
-        
-// line 40 "kparse.go"
-	cs = k_start
+		// line 40 "kparse.go"
+		cs = k_start
 
-// line 43 "kparse.go"
-	{
-	if p == pe { goto _test_eof }
-	switch cs {
-	case -666: // i am a hack D:
-tr13:
-// line 32 "kparse.rl"
-	{ m[k] = data[mark:p] }
-	goto st111
-tr28:
-// line 33 "kparse.rl"
-	{ m[k] = strings.ToUpper(data[mark:p-1]) }
-	goto st111
-tr40:
-// line 32 "kparse.rl"
-	{ m[k] = data[mark:p] }
-// line 33 "kparse.rl"
-	{ m[k] = strings.ToUpper(data[mark:p-1]) }
-	goto st111
-st111:
-	p++
-	if p == pe { goto _test_eof111 }
-	fallthrough
-case 111:
-// line 67 "kparse.go"
-	switch data[p] {
-		case 65: goto tr110
-		case 67: goto tr111
-		case 69: goto tr112
-		case 71: goto tr113
-		case 77: goto tr114
-		case 80: goto tr115
-		case 94: goto st109
-		case 97: goto tr110
-		case 99: goto tr111
-		case 101: goto tr112
-		case 103: goto tr113
-		case 109: goto tr114
-		case 112: goto tr115
-	}
-	goto st0
-st0:
-cs = 0;
-	goto _out;
-tr110:
-// line 30 "kparse.rl"
-	{ mark = p }
-	goto st1
-st1:
-	p++
-	if p == pe { goto _test_eof1 }
-	fallthrough
-case 1:
-// line 96 "kparse.go"
-	switch data[p] {
-		case 67: goto st2
-		case 76: goto st37
-		case 99: goto st2
-		case 108: goto st37
-	}
-	goto st0
-st2:
-	p++
-	if p == pe { goto _test_eof2 }
-	fallthrough
-case 2:
-	switch data[p] {
-		case 84: goto st3
-		case 116: goto st3
-	}
-	goto st0
-st3:
-	p++
-	if p == pe { goto _test_eof3 }
-	fallthrough
-case 3:
-	switch data[p] {
-		case 73: goto st4
-		case 105: goto st4
-	}
-	goto st0
-st4:
-	p++
-	if p == pe { goto _test_eof4 }
-	fallthrough
-case 4:
-	switch data[p] {
-		case 86: goto st5
-		case 118: goto st5
-	}
-	goto st0
-st5:
-	p++
-	if p == pe { goto _test_eof5 }
-	fallthrough
-case 5:
-	switch data[p] {
-		case 65: goto st6
-		case 97: goto st6
-	}
-	goto st0
-st6:
-	p++
-	if p == pe { goto _test_eof6 }
-	fallthrough
-case 6:
-	switch data[p] {
-		case 84: goto st7
-		case 116: goto st7
-	}
-	goto st0
-st7:
-	p++
-	if p == pe { goto _test_eof7 }
-	fallthrough
-case 7:
-	switch data[p] {
-		case 69: goto st8
-		case 101: goto st8
-	}
-	goto st0
-st8:
-	p++
-	if p == pe { goto _test_eof8 }
-	fallthrough
-case 8:
-	if data[p] == 58 { goto tr9 }
-	goto st0
-tr9:
-// line 31 "kparse.rl"
-	{ k = strings.ToLower(data[mark:p]) }
-	goto st9
-st9:
-	p++
-	if p == pe { goto _test_eof9 }
-	fallthrough
-case 9:
-// line 180 "kparse.go"
-	if data[p] == 32 { goto st10 }
-	goto st0
-st10:
-	p++
-	if p == pe { goto _test_eof10 }
-	fallthrough
-case 10:
-	switch data[p] {
-		case 32: goto tr11
-		case 43: goto tr11
-		case 61: goto tr11
-		case 92: goto tr11
-	}
-	if data[p] < 48 {
-		if data[p] > 41 {
-			if 46 <= data[p] && data[p] <= 47 { goto tr11 }
-		} else if data[p] >= 40 {
-			goto tr11
-		}
-	} else if data[p] > 57 {
-		if data[p] > 90 {
-			if 97 <= data[p] && data[p] <= 122 { goto tr11 }
-		} else if data[p] >= 65 {
-			goto tr11
-		}
-	} else {
-		goto tr12
-	}
-	goto st0
-tr11:
-// line 30 "kparse.rl"
-	{ mark = p }
-	goto st11
-st11:
-	p++
-	if p == pe { goto _test_eof11 }
-	fallthrough
-case 11:
-// line 219 "kparse.go"
-	switch data[p] {
-		case 10: goto tr13
-		case 32: goto st11
-		case 43: goto st11
-		case 61: goto st11
-		case 92: goto st11
-	}
-	if data[p] < 46 {
-		if 40 <= data[p] && data[p] <= 41 { goto st11 }
-	} else if data[p] > 57 {
-		if data[p] > 90 {
-			if 97 <= data[p] && data[p] <= 122 { goto st11 }
-		} else if data[p] >= 65 {
-			goto st11
-		}
-	} else {
-		goto st11
-	}
-	goto st0
-tr12:
-// line 30 "kparse.rl"
-	{ mark = p }
-	goto st12
-st12:
-	p++
-	if p == pe { goto _test_eof12 }
-	fallthrough
-case 12:
-// line 248 "kparse.go"
-	switch data[p] {
-		case 9: goto st13
-		case 10: goto tr13
-		case 32: goto st25
-		case 43: goto st11
-		case 61: goto st11
-		case 92: goto st11
-	}
-	if data[p] < 48 {
-		if data[p] > 41 {
-			if 46 <= data[p] && data[p] <= 47 { goto st11 }
-		} else if data[p] >= 40 {
-			goto st11
-		}
-	} else if data[p] > 57 {
-		if data[p] > 90 {
-			if 97 <= data[p] && data[p] <= 122 { goto st11 }
-		} else if data[p] >= 65 {
-			goto st11
-		}
-	} else {
-		goto st12
-	}
-	goto st0
-st13:
-	p++
-	if p == pe { goto _test_eof13 }
-	fallthrough
-case 13:
-	switch data[p] {
-		case 9: goto st13
-		case 32: goto st13
-		case 40: goto st14
-	}
-	goto st0
-st14:
-	p++
-	if p == pe { goto _test_eof14 }
-	fallthrough
-case 14:
-	switch data[p] {
-		case 82: goto tr19
-		case 114: goto tr19
-	}
-	goto st0
-tr19:
-// line 30 "kparse.rl"
-	{ mark = p }
-	goto st15
-st15:
-	p++
-	if p == pe { goto _test_eof15 }
-	fallthrough
-case 15:
-// line 303 "kparse.go"
-	switch data[p] {
-		case 83: goto st16
-		case 115: goto st16
-	}
-	goto st0
-st16:
-	p++
-	if p == pe { goto _test_eof16 }
-	fallthrough
-case 16:
-	switch data[p] {
-		case 65: goto st17
-		case 97: goto st17
-	}
-	goto st0
-st17:
-	p++
-	if p == pe { goto _test_eof17 }
-	fallthrough
-case 17:
-	switch data[p] {
-		case 83: goto st18
-		case 115: goto st18
-	}
-	goto st0
-st18:
-	p++
-	if p == pe { goto _test_eof18 }
-	fallthrough
-case 18:
-	switch data[p] {
-		case 72: goto st19
-		case 104: goto st19
-	}
-	goto st0
-st19:
-	p++
-	if p == pe { goto _test_eof19 }
-	fallthrough
-case 19:
-	switch data[p] {
-		case 65: goto st20
-		case 97: goto st20
-	}
-	goto st0
-st20:
-	p++
-	if p == pe { goto _test_eof20 }
-	fallthrough
-case 20:
-	switch data[p] {
-		case 49: goto st21
-		case 50: goto st23
-	}
-	goto st0
-st21:
-	p++
-	if p == pe { goto _test_eof21 }
-	fallthrough
-case 21:
-	if data[p] == 41 { goto st22 }
-	goto st0
-st22:
-	p++
-	if p == pe { goto _test_eof22 }
-	fallthrough
-case 22:
-	if data[p] == 10 { goto tr28 }
-	goto st0
-st23:
-	p++
-	if p == pe { goto _test_eof23 }
-	fallthrough
-case 23:
-	if data[p] == 53 { goto st24 }
-	goto st0
-st24:
-	p++
-	if p == pe { goto _test_eof24 }
-	fallthrough
-case 24:
-	if data[p] == 54 { goto st21 }
-	goto st0
-st25:
-	p++
-	if p == pe { goto _test_eof25 }
-	fallthrough
-case 25:
-	switch data[p] {
-		case 9: goto st13
-		case 10: goto tr13
-		case 32: goto st25
-		case 40: goto st26
-		case 41: goto st11
-		case 43: goto st11
-		case 61: goto st11
-		case 92: goto st11
-	}
-	if data[p] < 65 {
-		if 46 <= data[p] && data[p] <= 57 { goto st11 }
-	} else if data[p] > 90 {
-		if 97 <= data[p] && data[p] <= 122 { goto st11 }
-	} else {
-		goto st11
-	}
-	goto st0
-st26:
-	p++
-	if p == pe { goto _test_eof26 }
-	fallthrough
-case 26:
-	switch data[p] {
-		case 10: goto tr13
-		case 32: goto st11
-		case 43: goto st11
-		case 61: goto st11
-		case 82: goto tr31
-		case 92: goto st11
-		case 114: goto tr31
-	}
-	if data[p] < 46 {
-		if 40 <= data[p] && data[p] <= 41 { goto st11 }
-	} else if data[p] > 57 {
-		if data[p] > 90 {
-			if 97 <= data[p] && data[p] <= 122 { goto st11 }
-		} else if data[p] >= 65 {
-			goto st11
-		}
-	} else {
-		goto st11
-	}
-	goto st0
-tr31:
-// line 30 "kparse.rl"
-	{ mark = p }
-	goto st27
-st27:
-	p++
-	if p == pe { goto _test_eof27 }
-	fallthrough
-case 27:
-// line 445 "kparse.go"
-	switch data[p] {
-		case 10: goto tr13
-		case 32: goto st11
-		case 43: goto st11
-		case 61: goto st11
-		case 83: goto st28
-		case 92: goto st11
-		case 115: goto st28
-	}
-	if data[p] < 46 {
-		if 40 <= data[p] && data[p] <= 41 { goto st11 }
-	} else if data[p] > 57 {
-		if data[p] > 90 {
-			if 97 <= data[p] && data[p] <= 122 { goto st11 }
-		} else if data[p] >= 65 {
-			goto st11
-		}
-	} else {
-		goto st11
-	}
-	goto st0
-st28:
-	p++
-	if p == pe { goto _test_eof28 }
-	fallthrough
-case 28:
-	switch data[p] {
-		case 10: goto tr13
-		case 32: goto st11
-		case 43: goto st11
-		case 61: goto st11
-		case 65: goto st29
-		case 92: goto st11
-		case 97: goto st29
-	}
-	if data[p] < 46 {
-		if 40 <= data[p] && data[p] <= 41 { goto st11 }
-	} else if data[p] > 57 {
-		if data[p] > 90 {
-			if 98 <= data[p] && data[p] <= 122 { goto st11 }
-		} else if data[p] >= 66 {
-			goto st11
-		}
-	} else {
-		goto st11
-	}
-	goto st0
-st29:
-	p++
-	if p == pe { goto _test_eof29 }
-	fallthrough
-case 29:
-	switch data[p] {
-		case 10: goto tr13
-		case 32: goto st11
-		case 43: goto st11
-		case 61: goto st11
-		case 83: goto st30
-		case 92: goto st11
-		case 115: goto st30
-	}
-	if data[p] < 46 {
-		if 40 <= data[p] && data[p] <= 41 { goto st11 }
-	} else if data[p] > 57 {
-		if data[p] > 90 {
-			if 97 <= data[p] && data[p] <= 122 { goto st11 }
-		} else if data[p] >= 65 {
-			goto st11
-		}
-	} else {
-		goto st11
-	}
-	goto st0
-st30:
-	p++
-	if p == pe { goto _test_eof30 }
-	fallthrough
-case 30:
-	switch data[p] {
-		case 10: goto tr13
-		case 32: goto st11
-		case 43: goto st11
-		case 61: goto st11
-		case 72: goto st31
-		case 92: goto st11
-		case 104: goto st31
-	}
-	if data[p] < 46 {
-		if 40 <= data[p] && data[p] <= 41 { goto st11 }
-	} else if data[p] > 57 {
-		if data[p] > 90 {
-			if 97 <= data[p] && data[p] <= 122 { goto st11 }
-		} else if data[p] >= 65 {
-			goto st11
-		}
-	} else {
-		goto st11
-	}
-	goto st0
-st31:
-	p++
-	if p == pe { goto _test_eof31 }
-	fallthrough
-case 31:
-	switch data[p] {
-		case 10: goto tr13
-		case 32: goto st11
-		case 43: goto st11
-		case 61: goto st11
-		case 65: goto st32
-		case 92: goto st11
-		case 97: goto st32
-	}
-	if data[p] < 46 {
-		if 40 <= data[p] && data[p] <= 41 { goto st11 }
-	} else if data[p] > 57 {
-		if data[p] > 90 {
-			if 98 <= data[p] && data[p] <= 122 { goto st11 }
-		} else if data[p] >= 66 {
-			goto st11
-		}
-	} else {
-		goto st11
-	}
-	goto st0
-st32:
-	p++
-	if p == pe { goto _test_eof32 }
-	fallthrough
-case 32:
-	switch data[p] {
-		case 10: goto tr13
-		case 32: goto st11
-		case 43: goto st11
-		case 49: goto st33
-		case 50: goto st35
-		case 61: goto st11
-		case 92: goto st11
-	}
-	if data[p] < 46 {
-		if 40 <= data[p] && data[p] <= 41 { goto st11 }
-	} else if data[p] > 57 {
-		if data[p] > 90 {
-			if 97 <= data[p] && data[p] <= 122 { goto st11 }
-		} else if data[p] >= 65 {
-			goto st11
-		}
-	} else {
-		goto st11
-	}
-	goto st0
-st33:
-	p++
-	if p == pe { goto _test_eof33 }
-	fallthrough
-case 33:
-	switch data[p] {
-		case 10: goto tr13
-		case 32: goto st11
-		case 40: goto st11
-		case 41: goto st34
-		case 43: goto st11
-		case 61: goto st11
-		case 92: goto st11
-	}
-	if data[p] < 65 {
-		if 46 <= data[p] && data[p] <= 57 { goto st11 }
-	} else if data[p] > 90 {
-		if 97 <= data[p] && data[p] <= 122 { goto st11 }
-	} else {
-		goto st11
-	}
-	goto st0
-st34:
-	p++
-	if p == pe { goto _test_eof34 }
-	fallthrough
-case 34:
-	switch data[p] {
-		case 10: goto tr40
-		case 32: goto st11
-		case 43: goto st11
-		case 61: goto st11
-		case 92: goto st11
-	}
-	if data[p] < 46 {
-		if 40 <= data[p] && data[p] <= 41 { goto st11 }
-	} else if data[p] > 57 {
-		if data[p] > 90 {
-			if 97 <= data[p] && data[p] <= 122 { goto st11 }
-		} else if data[p] >= 65 {
-			goto st11
-		}
-	} else {
-		goto st11
-	}
-	goto st0
-st35:
-	p++
-	if p == pe { goto _test_eof35 }
-	fallthrough
-case 35:
-	switch data[p] {
-		case 10: goto tr13
-		case 32: goto st11
-		case 43: goto st11
-		case 53: goto st36
-		case 61: goto st11
-		case 92: goto st11
-	}
-	if data[p] < 46 {
-		if 40 <= data[p] && data[p] <= 41 { goto st11 }
-	} else if data[p] > 57 {
-		if data[p] > 90 {
-			if 97 <= data[p] && data[p] <= 122 { goto st11 }
-		} else if data[p] >= 65 {
-			goto st11
-		}
-	} else {
-		goto st11
-	}
-	goto st0
-st36:
-	p++
-	if p == pe { goto _test_eof36 }
-	fallthrough
-case 36:
-	switch data[p] {
-		case 10: goto tr13
-		case 32: goto st11
-		case 43: goto st11
-		case 54: goto st33
-		case 61: goto st11
-		case 92: goto st11
-	}
-	if data[p] < 46 {
-		if 40 <= data[p] && data[p] <= 41 { goto st11 }
-	} else if data[p] > 57 {
-		if data[p] > 90 {
-			if 97 <= data[p] && data[p] <= 122 { goto st11 }
-		} else if data[p] >= 65 {
-			goto st11
-		}
-	} else {
-		goto st11
-	}
-	goto st0
-st37:
-	p++
-	if p == pe { goto _test_eof37 }
-	fallthrough
-case 37:
-	switch data[p] {
-		case 71: goto st38
-		case 103: goto st38
-	}
-	goto st0
-st38:
-	p++
-	if p == pe { goto _test_eof38 }
-	fallthrough
-case 38:
-	switch data[p] {
-		case 79: goto st39
-		case 111: goto st39
-	}
-	goto st0
-st39:
-	p++
-	if p == pe { goto _test_eof39 }
-	fallthrough
-case 39:
-	switch data[p] {
-		case 82: goto st40
-		case 114: goto st40
-	}
-	goto st0
-st40:
-	p++
-	if p == pe { goto _test_eof40 }
-	fallthrough
-case 40:
-	switch data[p] {
-		case 73: goto st41
-		case 105: goto st41
-	}
-	goto st0
-st41:
-	p++
-	if p == pe { goto _test_eof41 }
-	fallthrough
-case 41:
-	switch data[p] {
-		case 84: goto st42
-		case 116: goto st42
-	}
-	goto st0
-st42:
-	p++
-	if p == pe { goto _test_eof42 }
-	fallthrough
-case 42:
-	switch data[p] {
-		case 72: goto st43
-		case 104: goto st43
-	}
-	goto st0
-st43:
-	p++
-	if p == pe { goto _test_eof43 }
-	fallthrough
-case 43:
-	switch data[p] {
-		case 77: goto st8
-		case 109: goto st8
-	}
-	goto st0
-tr111:
-// line 30 "kparse.rl"
-	{ mark = p }
-	goto st44
-st44:
-	p++
-	if p == pe { goto _test_eof44 }
-	fallthrough
-case 44:
-// line 772 "kparse.go"
-	switch data[p] {
-		case 79: goto st45
-		case 82: goto st54
-		case 111: goto st45
-		case 114: goto st54
-	}
-	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 70: goto st47
-		case 102: goto st47
-	}
-	goto st0
-st47:
-	p++
-	if p == pe { goto _test_eof47 }
-	fallthrough
-case 47:
-	switch data[p] {
-		case 70: goto st48
-		case 102: goto st48
-	}
-	goto st0
-st48:
-	p++
-	if p == pe { goto _test_eof48 }
-	fallthrough
-case 48:
-	switch data[p] {
-		case 73: goto st49
-		case 105: goto st49
-	}
-	goto st0
-st49:
-	p++
-	if p == pe { goto _test_eof49 }
-	fallthrough
-case 49:
-	switch data[p] {
-		case 67: goto st50
-		case 99: goto st50
-	}
-	goto st0
-st50:
-	p++
-	if p == pe { goto _test_eof50 }
-	fallthrough
-case 50:
-	switch data[p] {
-		case 73: goto st51
-		case 105: goto st51
-	}
-	goto st0
-st51:
-	p++
-	if p == pe { goto _test_eof51 }
-	fallthrough
-case 51:
-	switch data[p] {
-		case 69: goto st52
-		case 101: goto st52
-	}
-	goto st0
-st52:
-	p++
-	if p == pe { goto _test_eof52 }
-	fallthrough
-case 52:
-	switch data[p] {
-		case 78: goto st53
-		case 110: goto st53
-	}
-	goto st0
-st53:
-	p++
-	if p == pe { goto _test_eof53 }
-	fallthrough
-case 53:
-	switch data[p] {
-		case 84: goto st8
-		case 116: goto st8
-	}
-	goto st0
-st54:
-	p++
-	if p == pe { goto _test_eof54 }
-	fallthrough
-case 54:
-	switch data[p] {
-		case 69: goto st55
-		case 101: goto st55
-	}
-	goto st0
-st55:
-	p++
-	if p == pe { goto _test_eof55 }
-	fallthrough
-case 55:
-	switch data[p] {
-		case 65: goto st56
-		case 97: goto st56
-	}
-	goto st0
-st56:
-	p++
-	if p == pe { goto _test_eof56 }
-	fallthrough
-case 56:
-	switch data[p] {
-		case 84: goto st57
-		case 116: goto st57
-	}
-	goto st0
-st57:
-	p++
-	if p == pe { goto _test_eof57 }
-	fallthrough
-case 57:
-	switch data[p] {
-		case 69: goto st58
-		case 101: goto st58
-	}
-	goto st0
-st58:
-	p++
-	if p == pe { goto _test_eof58 }
-	fallthrough
-case 58:
-	switch data[p] {
-		case 68: goto st8
-		case 100: goto st8
-	}
-	goto st0
-tr112:
-// line 30 "kparse.rl"
-	{ mark = p }
-	goto st59
-st59:
-	p++
-	if p == pe { goto _test_eof59 }
-	fallthrough
-case 59:
-// line 929 "kparse.go"
-	switch data[p] {
-		case 88: goto st60
-		case 120: goto st60
-	}
-	goto st0
-st60:
-	p++
-	if p == pe { goto _test_eof60 }
-	fallthrough
-case 60:
-	switch data[p] {
-		case 80: goto st61
-		case 112: goto st61
-	}
-	goto st0
-st61:
-	p++
-	if p == pe { goto _test_eof61 }
-	fallthrough
-case 61:
-	switch data[p] {
-		case 79: goto st62
-		case 111: goto st62
-	}
-	goto st0
-st62:
-	p++
-	if p == pe { goto _test_eof62 }
-	fallthrough
-case 62:
-	switch data[p] {
-		case 78: goto st63
-		case 110: goto st63
-	}
-	goto st0
-st63:
-	p++
-	if p == pe { goto _test_eof63 }
-	fallthrough
-case 63:
-	switch data[p] {
-		case 69: goto st64
-		case 101: goto st64
-	}
-	goto st0
-st64:
-	p++
-	if p == pe { goto _test_eof64 }
-	fallthrough
-case 64:
-	switch data[p] {
-		case 78: goto st65
-		case 110: goto st65
-	}
-	goto st0
-st65:
-	p++
-	if p == pe { goto _test_eof65 }
-	fallthrough
-case 65:
-	switch data[p] {
-		case 84: goto st66
-		case 116: goto st66
-	}
-	goto st0
-st66:
-	p++
-	if p == pe { goto _test_eof66 }
-	fallthrough
-case 66:
-	if 49 <= data[p] && data[p] <= 50 { goto st8 }
-	goto st0
-tr113:
-// line 30 "kparse.rl"
-	{ mark = p }
-	goto st67
-st67:
-	p++
-	if p == pe { goto _test_eof67 }
-	fallthrough
-case 67:
-// line 1011 "kparse.go"
-	switch data[p] {
-		case 79: goto st68
-		case 111: goto st68
-	}
-	goto st0
-st68:
-	p++
-	if p == pe { goto _test_eof68 }
-	fallthrough
-case 68:
-	switch data[p] {
-		case 83: goto st69
-		case 115: goto st69
-	}
-	goto st0
-st69:
-	p++
-	if p == pe { goto _test_eof69 }
-	fallthrough
-case 69:
-	switch data[p] {
-		case 84: goto st70
-		case 116: goto st70
-	}
-	goto st0
-st70:
-	p++
-	if p == pe { goto _test_eof70 }
-	fallthrough
-case 70:
-	switch data[p] {
-		case 65: goto st71
-		case 97: goto st71
-	}
-	goto st0
-st71:
-	p++
-	if p == pe { goto _test_eof71 }
-	fallthrough
-case 71:
-	switch data[p] {
-		case 83: goto st72
-		case 115: goto st72
-	}
-	goto st0
-st72:
-	p++
-	if p == pe { goto _test_eof72 }
-	fallthrough
-case 72:
-	switch data[p] {
-		case 78: goto st73
-		case 110: goto st73
-	}
-	goto st0
-st73:
-	p++
-	if p == pe { goto _test_eof73 }
-	fallthrough
-case 73:
-	if data[p] == 49 { goto st8 }
-	goto st0
-tr114:
-// line 30 "kparse.rl"
-	{ mark = p }
-	goto st74
-st74:
-	p++
-	if p == pe { goto _test_eof74 }
-	fallthrough
-case 74:
-// line 1083 "kparse.go"
-	switch data[p] {
-		case 79: goto st75
-		case 111: goto st75
-	}
-	goto st0
-st75:
-	p++
-	if p == pe { goto _test_eof75 }
-	fallthrough
-case 75:
-	switch data[p] {
-		case 68: goto st76
-		case 100: goto st76
-	}
-	goto st0
-st76:
-	p++
-	if p == pe { goto _test_eof76 }
-	fallthrough
-case 76:
-	switch data[p] {
-		case 85: goto st77
-		case 117: goto st77
-	}
-	goto st0
-st77:
-	p++
-	if p == pe { goto _test_eof77 }
-	fallthrough
-case 77:
-	switch data[p] {
-		case 76: goto st78
-		case 108: goto st78
-	}
-	goto st0
-st78:
-	p++
-	if p == pe { goto _test_eof78 }
-	fallthrough
-case 78:
-	switch data[p] {
-		case 85: goto st79
-		case 117: goto st79
-	}
-	goto st0
-st79:
-	p++
-	if p == pe { goto _test_eof79 }
-	fallthrough
-case 79:
-	switch data[p] {
-		case 83: goto st8
-		case 115: goto st8
-	}
-	goto st0
-tr115:
-// line 30 "kparse.rl"
-	{ mark = p }
-	goto st80
-st80:
-	p++
-	if p == pe { goto _test_eof80 }
-	fallthrough
-case 80:
-// line 1148 "kparse.go"
-	switch data[p] {
-		case 82: goto st81
-		case 85: goto st103
-		case 114: goto st81
-		case 117: goto st103
-	}
-	goto st0
-st81:
-	p++
-	if p == pe { goto _test_eof81 }
-	fallthrough
-case 81:
-	switch data[p] {
-		case 73: goto st82
-		case 105: goto st82
-	}
-	goto st0
-st82:
-	p++
-	if p == pe { goto _test_eof82 }
-	fallthrough
-case 82:
-	switch data[p] {
-		case 77: goto st83
-		case 86: goto st84
-		case 109: goto st83
-		case 118: goto st84
-	}
-	goto st0
-st83:
-	p++
-	if p == pe { goto _test_eof83 }
-	fallthrough
-case 83:
-	switch data[p] {
-		case 69: goto st66
-		case 101: goto st66
-	}
-	goto st0
-st84:
-	p++
-	if p == pe { goto _test_eof84 }
-	fallthrough
-case 84:
-	switch data[p] {
-		case 65: goto st85
-		case 97: goto st85
-	}
-	goto st0
-st85:
-	p++
-	if p == pe { goto _test_eof85 }
-	fallthrough
-case 85:
-	switch data[p] {
-		case 84: goto st86
-		case 116: goto st86
-	}
-	goto st0
-st86:
-	p++
-	if p == pe { goto _test_eof86 }
-	fallthrough
-case 86:
-	switch data[p] {
-		case 69: goto st87
-		case 101: goto st87
-	}
-	goto st0
-st87:
-	p++
-	if p == pe { goto _test_eof87 }
-	fallthrough
-case 87:
-	switch data[p] {
-		case 45: goto st88
-		case 69: goto st97
-		case 75: goto st101
-		case 101: goto st97
-		case 107: goto st101
-	}
-	goto st0
-st88:
-	p++
-	if p == pe { goto _test_eof88 }
-	fallthrough
-case 88:
-	switch data[p] {
-		case 75: goto st89
-		case 107: goto st89
-	}
-	goto st0
-st89:
-	p++
-	if p == pe { goto _test_eof89 }
-	fallthrough
-case 89:
-	switch data[p] {
-		case 69: goto st90
-		case 101: goto st90
-	}
-	goto st0
-st90:
-	p++
-	if p == pe { goto _test_eof90 }
-	fallthrough
-case 90:
-	switch data[p] {
-		case 89: goto st91
-		case 121: goto st91
-	}
-	goto st0
-st91:
-	p++
-	if p == pe { goto _test_eof91 }
-	fallthrough
-case 91:
-	if data[p] == 45 { goto st92 }
-	goto st0
-st92:
-	p++
-	if p == pe { goto _test_eof92 }
-	fallthrough
-case 92:
-	switch data[p] {
-		case 70: goto st93
-		case 102: goto st93
-	}
-	goto st0
-st93:
-	p++
-	if p == pe { goto _test_eof93 }
-	fallthrough
-case 93:
-	switch data[p] {
-		case 79: goto st94
-		case 111: goto st94
-	}
-	goto st0
-st94:
-	p++
-	if p == pe { goto _test_eof94 }
-	fallthrough
-case 94:
-	switch data[p] {
-		case 82: goto st95
-		case 114: goto st95
-	}
-	goto st0
-st95:
-	p++
-	if p == pe { goto _test_eof95 }
-	fallthrough
-case 95:
-	switch data[p] {
-		case 77: goto st96
-		case 109: goto st96
-	}
-	goto st0
-st96:
-	p++
-	if p == pe { goto _test_eof96 }
-	fallthrough
-case 96:
-	switch data[p] {
-		case 65: goto st53
-		case 97: goto st53
-	}
-	goto st0
-st97:
-	p++
-	if p == pe { goto _test_eof97 }
-	fallthrough
-case 97:
-	switch data[p] {
-		case 88: goto st98
-		case 120: goto st98
-	}
-	goto st0
-st98:
-	p++
-	if p == pe { goto _test_eof98 }
-	fallthrough
-case 98:
-	switch data[p] {
-		case 80: goto st99
-		case 112: goto st99
-	}
-	goto st0
-st99:
-	p++
-	if p == pe { goto _test_eof99 }
-	fallthrough
-case 99:
-	switch data[p] {
-		case 79: goto st100
-		case 111: goto st100
-	}
-	goto st0
-st100:
-	p++
-	if p == pe { goto _test_eof100 }
-	fallthrough
-case 100:
-	switch data[p] {
-		case 78: goto st51
-		case 110: goto st51
-	}
-	goto st0
-st101:
-	p++
-	if p == pe { goto _test_eof101 }
-	fallthrough
-case 101:
-	switch data[p] {
-		case 69: goto st102
-		case 101: goto st102
-	}
-	goto st0
-st102:
-	p++
-	if p == pe { goto _test_eof102 }
-	fallthrough
-case 102:
-	switch data[p] {
-		case 89: goto st8
-		case 121: goto st8
-	}
-	goto st0
-st103:
-	p++
-	if p == pe { goto _test_eof103 }
-	fallthrough
-case 103:
-	switch data[p] {
-		case 66: goto st104
-		case 98: goto st104
-	}
-	goto st0
-st104:
-	p++
-	if p == pe { goto _test_eof104 }
-	fallthrough
-case 104:
-	switch data[p] {
-		case 76: goto st105
-		case 108: goto st105
-	}
-	goto st0
-st105:
-	p++
-	if p == pe { goto _test_eof105 }
-	fallthrough
-case 105:
-	switch data[p] {
-		case 73: goto st106
-		case 105: goto st106
-	}
-	goto st0
-st106:
-	p++
-	if p == pe { goto _test_eof106 }
-	fallthrough
-case 106:
-	switch data[p] {
-		case 67: goto st107
-		case 83: goto st108
-		case 99: goto st107
-		case 115: goto st108
-	}
-	goto st0
-st107:
-	p++
-	if p == pe { goto _test_eof107 }
-	fallthrough
-case 107:
-	switch data[p] {
-		case 69: goto st97
-		case 101: goto st97
-	}
-	goto st0
-st108:
-	p++
-	if p == pe { goto _test_eof108 }
-	fallthrough
-case 108:
-	switch data[p] {
-		case 72: goto st8
-		case 104: goto st8
-	}
-	goto st0
-st109:
-	p++
-	if p == pe { goto _test_eof109 }
-	fallthrough
-case 109:
-	if data[p] == 59 { goto st110 }
-	goto st0
-st110:
-	p++
-	if p == pe { goto _test_eof110 }
-	fallthrough
-case 110:
-	if data[p] == 10 { goto st111 }
-	goto st0
-	}
-	_test_eof111: cs = 111; 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; 
+		// line 43 "kparse.go"
+		{
+			if p == pe {
+				goto _test_eof
+			}
+			switch cs {
+			case -666: // i am a hack D:
+			tr13:
+				// line 32 "kparse.rl"
+				{
+					m[k] = data[mark:p]
+				}
+				goto st111
+			tr28:
+				// line 33 "kparse.rl"
+				{
+					m[k] = strings.ToUpper(data[mark : p-1])
+				}
+				goto st111
+			tr40:
+				// line 32 "kparse.rl"
+				{
+					m[k] = data[mark:p]
+				}
+				// line 33 "kparse.rl"
+				{
+					m[k] = strings.ToUpper(data[mark : p-1])
+				}
+				goto st111
+			st111:
+				p++
+				if p == pe {
+					goto _test_eof111
+				}
+				fallthrough
+			case 111:
+				// line 67 "kparse.go"
+				switch data[p] {
+				case 65:
+					goto tr110
+				case 67:
+					goto tr111
+				case 69:
+					goto tr112
+				case 71:
+					goto tr113
+				case 77:
+					goto tr114
+				case 80:
+					goto tr115
+				case 94:
+					goto st109
+				case 97:
+					goto tr110
+				case 99:
+					goto tr111
+				case 101:
+					goto tr112
+				case 103:
+					goto tr113
+				case 109:
+					goto tr114
+				case 112:
+					goto tr115
+				}
+				goto st0
+			st0:
+				cs = 0
+				goto _out
+			tr110:
+				// line 30 "kparse.rl"
+				{
+					mark = p
+				}
+				goto st1
+			st1:
+				p++
+				if p == pe {
+					goto _test_eof1
+				}
+				fallthrough
+			case 1:
+				// line 96 "kparse.go"
+				switch data[p] {
+				case 67:
+					goto st2
+				case 76:
+					goto st37
+				case 99:
+					goto st2
+				case 108:
+					goto st37
+				}
+				goto st0
+			st2:
+				p++
+				if p == pe {
+					goto _test_eof2
+				}
+				fallthrough
+			case 2:
+				switch data[p] {
+				case 84:
+					goto st3
+				case 116:
+					goto st3
+				}
+				goto st0
+			st3:
+				p++
+				if p == pe {
+					goto _test_eof3
+				}
+				fallthrough
+			case 3:
+				switch data[p] {
+				case 73:
+					goto st4
+				case 105:
+					goto st4
+				}
+				goto st0
+			st4:
+				p++
+				if p == pe {
+					goto _test_eof4
+				}
+				fallthrough
+			case 4:
+				switch data[p] {
+				case 86:
+					goto st5
+				case 118:
+					goto st5
+				}
+				goto st0
+			st5:
+				p++
+				if p == pe {
+					goto _test_eof5
+				}
+				fallthrough
+			case 5:
+				switch data[p] {
+				case 65:
+					goto st6
+				case 97:
+					goto st6
+				}
+				goto st0
+			st6:
+				p++
+				if p == pe {
+					goto _test_eof6
+				}
+				fallthrough
+			case 6:
+				switch data[p] {
+				case 84:
+					goto st7
+				case 116:
+					goto st7
+				}
+				goto st0
+			st7:
+				p++
+				if p == pe {
+					goto _test_eof7
+				}
+				fallthrough
+			case 7:
+				switch data[p] {
+				case 69:
+					goto st8
+				case 101:
+					goto st8
+				}
+				goto st0
+			st8:
+				p++
+				if p == pe {
+					goto _test_eof8
+				}
+				fallthrough
+			case 8:
+				if data[p] == 58 {
+					goto tr9
+				}
+				goto st0
+			tr9:
+				// line 31 "kparse.rl"
+				{
+					k = strings.ToLower(data[mark:p])
+				}
+				goto st9
+			st9:
+				p++
+				if p == pe {
+					goto _test_eof9
+				}
+				fallthrough
+			case 9:
+				// line 180 "kparse.go"
+				if data[p] == 32 {
+					goto st10
+				}
+				goto st0
+			st10:
+				p++
+				if p == pe {
+					goto _test_eof10
+				}
+				fallthrough
+			case 10:
+				switch data[p] {
+				case 32:
+					goto tr11
+				case 43:
+					goto tr11
+				case 61:
+					goto tr11
+				case 92:
+					goto tr11
+				}
+				if data[p] < 48 {
+					if data[p] > 41 {
+						if 46 <= data[p] && data[p] <= 47 {
+							goto tr11
+						}
+					} else if data[p] >= 40 {
+						goto tr11
+					}
+				} else if data[p] > 57 {
+					if data[p] > 90 {
+						if 97 <= data[p] && data[p] <= 122 {
+							goto tr11
+						}
+					} else if data[p] >= 65 {
+						goto tr11
+					}
+				} else {
+					goto tr12
+				}
+				goto st0
+			tr11:
+				// line 30 "kparse.rl"
+				{
+					mark = p
+				}
+				goto st11
+			st11:
+				p++
+				if p == pe {
+					goto _test_eof11
+				}
+				fallthrough
+			case 11:
+				// line 219 "kparse.go"
+				switch data[p] {
+				case 10:
+					goto tr13
+				case 32:
+					goto st11
+				case 43:
+					goto st11
+				case 61:
+					goto st11
+				case 92:
+					goto st11
+				}
+				if data[p] < 46 {
+					if 40 <= data[p] && data[p] <= 41 {
+						goto st11
+					}
+				} else if data[p] > 57 {
+					if data[p] > 90 {
+						if 97 <= data[p] && data[p] <= 122 {
+							goto st11
+						}
+					} else if data[p] >= 65 {
+						goto st11
+					}
+				} else {
+					goto st11
+				}
+				goto st0
+			tr12:
+				// line 30 "kparse.rl"
+				{
+					mark = p
+				}
+				goto st12
+			st12:
+				p++
+				if p == pe {
+					goto _test_eof12
+				}
+				fallthrough
+			case 12:
+				// line 248 "kparse.go"
+				switch data[p] {
+				case 9:
+					goto st13
+				case 10:
+					goto tr13
+				case 32:
+					goto st25
+				case 43:
+					goto st11
+				case 61:
+					goto st11
+				case 92:
+					goto st11
+				}
+				if data[p] < 48 {
+					if data[p] > 41 {
+						if 46 <= data[p] && data[p] <= 47 {
+							goto st11
+						}
+					} else if data[p] >= 40 {
+						goto st11
+					}
+				} else if data[p] > 57 {
+					if data[p] > 90 {
+						if 97 <= data[p] && data[p] <= 122 {
+							goto st11
+						}
+					} else if data[p] >= 65 {
+						goto st11
+					}
+				} else {
+					goto st12
+				}
+				goto st0
+			st13:
+				p++
+				if p == pe {
+					goto _test_eof13
+				}
+				fallthrough
+			case 13:
+				switch data[p] {
+				case 9:
+					goto st13
+				case 32:
+					goto st13
+				case 40:
+					goto st14
+				}
+				goto st0
+			st14:
+				p++
+				if p == pe {
+					goto _test_eof14
+				}
+				fallthrough
+			case 14:
+				switch data[p] {
+				case 82:
+					goto tr19
+				case 114:
+					goto tr19
+				}
+				goto st0
+			tr19:
+				// line 30 "kparse.rl"
+				{
+					mark = p
+				}
+				goto st15
+			st15:
+				p++
+				if p == pe {
+					goto _test_eof15
+				}
+				fallthrough
+			case 15:
+				// line 303 "kparse.go"
+				switch data[p] {
+				case 83:
+					goto st16
+				case 115:
+					goto st16
+				}
+				goto st0
+			st16:
+				p++
+				if p == pe {
+					goto _test_eof16
+				}
+				fallthrough
+			case 16:
+				switch data[p] {
+				case 65:
+					goto st17
+				case 97:
+					goto st17
+				}
+				goto st0
+			st17:
+				p++
+				if p == pe {
+					goto _test_eof17
+				}
+				fallthrough
+			case 17:
+				switch data[p] {
+				case 83:
+					goto st18
+				case 115:
+					goto st18
+				}
+				goto st0
+			st18:
+				p++
+				if p == pe {
+					goto _test_eof18
+				}
+				fallthrough
+			case 18:
+				switch data[p] {
+				case 72:
+					goto st19
+				case 104:
+					goto st19
+				}
+				goto st0
+			st19:
+				p++
+				if p == pe {
+					goto _test_eof19
+				}
+				fallthrough
+			case 19:
+				switch data[p] {
+				case 65:
+					goto st20
+				case 97:
+					goto st20
+				}
+				goto st0
+			st20:
+				p++
+				if p == pe {
+					goto _test_eof20
+				}
+				fallthrough
+			case 20:
+				switch data[p] {
+				case 49:
+					goto st21
+				case 50:
+					goto st23
+				}
+				goto st0
+			st21:
+				p++
+				if p == pe {
+					goto _test_eof21
+				}
+				fallthrough
+			case 21:
+				if data[p] == 41 {
+					goto st22
+				}
+				goto st0
+			st22:
+				p++
+				if p == pe {
+					goto _test_eof22
+				}
+				fallthrough
+			case 22:
+				if data[p] == 10 {
+					goto tr28
+				}
+				goto st0
+			st23:
+				p++
+				if p == pe {
+					goto _test_eof23
+				}
+				fallthrough
+			case 23:
+				if data[p] == 53 {
+					goto st24
+				}
+				goto st0
+			st24:
+				p++
+				if p == pe {
+					goto _test_eof24
+				}
+				fallthrough
+			case 24:
+				if data[p] == 54 {
+					goto st21
+				}
+				goto st0
+			st25:
+				p++
+				if p == pe {
+					goto _test_eof25
+				}
+				fallthrough
+			case 25:
+				switch data[p] {
+				case 9:
+					goto st13
+				case 10:
+					goto tr13
+				case 32:
+					goto st25
+				case 40:
+					goto st26
+				case 41:
+					goto st11
+				case 43:
+					goto st11
+				case 61:
+					goto st11
+				case 92:
+					goto st11
+				}
+				if data[p] < 65 {
+					if 46 <= data[p] && data[p] <= 57 {
+						goto st11
+					}
+				} else if data[p] > 90 {
+					if 97 <= data[p] && data[p] <= 122 {
+						goto st11
+					}
+				} else {
+					goto st11
+				}
+				goto st0
+			st26:
+				p++
+				if p == pe {
+					goto _test_eof26
+				}
+				fallthrough
+			case 26:
+				switch data[p] {
+				case 10:
+					goto tr13
+				case 32:
+					goto st11
+				case 43:
+					goto st11
+				case 61:
+					goto st11
+				case 82:
+					goto tr31
+				case 92:
+					goto st11
+				case 114:
+					goto tr31
+				}
+				if data[p] < 46 {
+					if 40 <= data[p] && data[p] <= 41 {
+						goto st11
+					}
+				} else if data[p] > 57 {
+					if data[p] > 90 {
+						if 97 <= data[p] && data[p] <= 122 {
+							goto st11
+						}
+					} else if data[p] >= 65 {
+						goto st11
+					}
+				} else {
+					goto st11
+				}
+				goto st0
+			tr31:
+				// line 30 "kparse.rl"
+				{
+					mark = p
+				}
+				goto st27
+			st27:
+				p++
+				if p == pe {
+					goto _test_eof27
+				}
+				fallthrough
+			case 27:
+				// line 445 "kparse.go"
+				switch data[p] {
+				case 10:
+					goto tr13
+				case 32:
+					goto st11
+				case 43:
+					goto st11
+				case 61:
+					goto st11
+				case 83:
+					goto st28
+				case 92:
+					goto st11
+				case 115:
+					goto st28
+				}
+				if data[p] < 46 {
+					if 40 <= data[p] && data[p] <= 41 {
+						goto st11
+					}
+				} else if data[p] > 57 {
+					if data[p] > 90 {
+						if 97 <= data[p] && data[p] <= 122 {
+							goto st11
+						}
+					} else if data[p] >= 65 {
+						goto st11
+					}
+				} else {
+					goto st11
+				}
+				goto st0
+			st28:
+				p++
+				if p == pe {
+					goto _test_eof28
+				}
+				fallthrough
+			case 28:
+				switch data[p] {
+				case 10:
+					goto tr13
+				case 32:
+					goto st11
+				case 43:
+					goto st11
+				case 61:
+					goto st11
+				case 65:
+					goto st29
+				case 92:
+					goto st11
+				case 97:
+					goto st29
+				}
+				if data[p] < 46 {
+					if 40 <= data[p] && data[p] <= 41 {
+						goto st11
+					}
+				} else if data[p] > 57 {
+					if data[p] > 90 {
+						if 98 <= data[p] && data[p] <= 122 {
+							goto st11
+						}
+					} else if data[p] >= 66 {
+						goto st11
+					}
+				} else {
+					goto st11
+				}
+				goto st0
+			st29:
+				p++
+				if p == pe {
+					goto _test_eof29
+				}
+				fallthrough
+			case 29:
+				switch data[p] {
+				case 10:
+					goto tr13
+				case 32:
+					goto st11
+				case 43:
+					goto st11
+				case 61:
+					goto st11
+				case 83:
+					goto st30
+				case 92:
+					goto st11
+				case 115:
+					goto st30
+				}
+				if data[p] < 46 {
+					if 40 <= data[p] && data[p] <= 41 {
+						goto st11
+					}
+				} else if data[p] > 57 {
+					if data[p] > 90 {
+						if 97 <= data[p] && data[p] <= 122 {
+							goto st11
+						}
+					} else if data[p] >= 65 {
+						goto st11
+					}
+				} else {
+					goto st11
+				}
+				goto st0
+			st30:
+				p++
+				if p == pe {
+					goto _test_eof30
+				}
+				fallthrough
+			case 30:
+				switch data[p] {
+				case 10:
+					goto tr13
+				case 32:
+					goto st11
+				case 43:
+					goto st11
+				case 61:
+					goto st11
+				case 72:
+					goto st31
+				case 92:
+					goto st11
+				case 104:
+					goto st31
+				}
+				if data[p] < 46 {
+					if 40 <= data[p] && data[p] <= 41 {
+						goto st11
+					}
+				} else if data[p] > 57 {
+					if data[p] > 90 {
+						if 97 <= data[p] && data[p] <= 122 {
+							goto st11
+						}
+					} else if data[p] >= 65 {
+						goto st11
+					}
+				} else {
+					goto st11
+				}
+				goto st0
+			st31:
+				p++
+				if p == pe {
+					goto _test_eof31
+				}
+				fallthrough
+			case 31:
+				switch data[p] {
+				case 10:
+					goto tr13
+				case 32:
+					goto st11
+				case 43:
+					goto st11
+				case 61:
+					goto st11
+				case 65:
+					goto st32
+				case 92:
+					goto st11
+				case 97:
+					goto st32
+				}
+				if data[p] < 46 {
+					if 40 <= data[p] && data[p] <= 41 {
+						goto st11
+					}
+				} else if data[p] > 57 {
+					if data[p] > 90 {
+						if 98 <= data[p] && data[p] <= 122 {
+							goto st11
+						}
+					} else if data[p] >= 66 {
+						goto st11
+					}
+				} else {
+					goto st11
+				}
+				goto st0
+			st32:
+				p++
+				if p == pe {
+					goto _test_eof32
+				}
+				fallthrough
+			case 32:
+				switch data[p] {
+				case 10:
+					goto tr13
+				case 32:
+					goto st11
+				case 43:
+					goto st11
+				case 49:
+					goto st33
+				case 50:
+					goto st35
+				case 61:
+					goto st11
+				case 92:
+					goto st11
+				}
+				if data[p] < 46 {
+					if 40 <= data[p] && data[p] <= 41 {
+						goto st11
+					}
+				} else if data[p] > 57 {
+					if data[p] > 90 {
+						if 97 <= data[p] && data[p] <= 122 {
+							goto st11
+						}
+					} else if data[p] >= 65 {
+						goto st11
+					}
+				} else {
+					goto st11
+				}
+				goto st0
+			st33:
+				p++
+				if p == pe {
+					goto _test_eof33
+				}
+				fallthrough
+			case 33:
+				switch data[p] {
+				case 10:
+					goto tr13
+				case 32:
+					goto st11
+				case 40:
+					goto st11
+				case 41:
+					goto st34
+				case 43:
+					goto st11
+				case 61:
+					goto st11
+				case 92:
+					goto st11
+				}
+				if data[p] < 65 {
+					if 46 <= data[p] && data[p] <= 57 {
+						goto st11
+					}
+				} else if data[p] > 90 {
+					if 97 <= data[p] && data[p] <= 122 {
+						goto st11
+					}
+				} else {
+					goto st11
+				}
+				goto st0
+			st34:
+				p++
+				if p == pe {
+					goto _test_eof34
+				}
+				fallthrough
+			case 34:
+				switch data[p] {
+				case 10:
+					goto tr40
+				case 32:
+					goto st11
+				case 43:
+					goto st11
+				case 61:
+					goto st11
+				case 92:
+					goto st11
+				}
+				if data[p] < 46 {
+					if 40 <= data[p] && data[p] <= 41 {
+						goto st11
+					}
+				} else if data[p] > 57 {
+					if data[p] > 90 {
+						if 97 <= data[p] && data[p] <= 122 {
+							goto st11
+						}
+					} else if data[p] >= 65 {
+						goto st11
+					}
+				} else {
+					goto st11
+				}
+				goto st0
+			st35:
+				p++
+				if p == pe {
+					goto _test_eof35
+				}
+				fallthrough
+			case 35:
+				switch data[p] {
+				case 10:
+					goto tr13
+				case 32:
+					goto st11
+				case 43:
+					goto st11
+				case 53:
+					goto st36
+				case 61:
+					goto st11
+				case 92:
+					goto st11
+				}
+				if data[p] < 46 {
+					if 40 <= data[p] && data[p] <= 41 {
+						goto st11
+					}
+				} else if data[p] > 57 {
+					if data[p] > 90 {
+						if 97 <= data[p] && data[p] <= 122 {
+							goto st11
+						}
+					} else if data[p] >= 65 {
+						goto st11
+					}
+				} else {
+					goto st11
+				}
+				goto st0
+			st36:
+				p++
+				if p == pe {
+					goto _test_eof36
+				}
+				fallthrough
+			case 36:
+				switch data[p] {
+				case 10:
+					goto tr13
+				case 32:
+					goto st11
+				case 43:
+					goto st11
+				case 54:
+					goto st33
+				case 61:
+					goto st11
+				case 92:
+					goto st11
+				}
+				if data[p] < 46 {
+					if 40 <= data[p] && data[p] <= 41 {
+						goto st11
+					}
+				} else if data[p] > 57 {
+					if data[p] > 90 {
+						if 97 <= data[p] && data[p] <= 122 {
+							goto st11
+						}
+					} else if data[p] >= 65 {
+						goto st11
+					}
+				} else {
+					goto st11
+				}
+				goto st0
+			st37:
+				p++
+				if p == pe {
+					goto _test_eof37
+				}
+				fallthrough
+			case 37:
+				switch data[p] {
+				case 71:
+					goto st38
+				case 103:
+					goto st38
+				}
+				goto st0
+			st38:
+				p++
+				if p == pe {
+					goto _test_eof38
+				}
+				fallthrough
+			case 38:
+				switch data[p] {
+				case 79:
+					goto st39
+				case 111:
+					goto st39
+				}
+				goto st0
+			st39:
+				p++
+				if p == pe {
+					goto _test_eof39
+				}
+				fallthrough
+			case 39:
+				switch data[p] {
+				case 82:
+					goto st40
+				case 114:
+					goto st40
+				}
+				goto st0
+			st40:
+				p++
+				if p == pe {
+					goto _test_eof40
+				}
+				fallthrough
+			case 40:
+				switch data[p] {
+				case 73:
+					goto st41
+				case 105:
+					goto st41
+				}
+				goto st0
+			st41:
+				p++
+				if p == pe {
+					goto _test_eof41
+				}
+				fallthrough
+			case 41:
+				switch data[p] {
+				case 84:
+					goto st42
+				case 116:
+					goto st42
+				}
+				goto st0
+			st42:
+				p++
+				if p == pe {
+					goto _test_eof42
+				}
+				fallthrough
+			case 42:
+				switch data[p] {
+				case 72:
+					goto st43
+				case 104:
+					goto st43
+				}
+				goto st0
+			st43:
+				p++
+				if p == pe {
+					goto _test_eof43
+				}
+				fallthrough
+			case 43:
+				switch data[p] {
+				case 77:
+					goto st8
+				case 109:
+					goto st8
+				}
+				goto st0
+			tr111:
+				// line 30 "kparse.rl"
+				{
+					mark = p
+				}
+				goto st44
+			st44:
+				p++
+				if p == pe {
+					goto _test_eof44
+				}
+				fallthrough
+			case 44:
+				// line 772 "kparse.go"
+				switch data[p] {
+				case 79:
+					goto st45
+				case 82:
+					goto st54
+				case 111:
+					goto st45
+				case 114:
+					goto st54
+				}
+				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 70:
+					goto st47
+				case 102:
+					goto st47
+				}
+				goto st0
+			st47:
+				p++
+				if p == pe {
+					goto _test_eof47
+				}
+				fallthrough
+			case 47:
+				switch data[p] {
+				case 70:
+					goto st48
+				case 102:
+					goto st48
+				}
+				goto st0
+			st48:
+				p++
+				if p == pe {
+					goto _test_eof48
+				}
+				fallthrough
+			case 48:
+				switch data[p] {
+				case 73:
+					goto st49
+				case 105:
+					goto st49
+				}
+				goto st0
+			st49:
+				p++
+				if p == pe {
+					goto _test_eof49
+				}
+				fallthrough
+			case 49:
+				switch data[p] {
+				case 67:
+					goto st50
+				case 99:
+					goto st50
+				}
+				goto st0
+			st50:
+				p++
+				if p == pe {
+					goto _test_eof50
+				}
+				fallthrough
+			case 50:
+				switch data[p] {
+				case 73:
+					goto st51
+				case 105:
+					goto st51
+				}
+				goto st0
+			st51:
+				p++
+				if p == pe {
+					goto _test_eof51
+				}
+				fallthrough
+			case 51:
+				switch data[p] {
+				case 69:
+					goto st52
+				case 101:
+					goto st52
+				}
+				goto st0
+			st52:
+				p++
+				if p == pe {
+					goto _test_eof52
+				}
+				fallthrough
+			case 52:
+				switch data[p] {
+				case 78:
+					goto st53
+				case 110:
+					goto st53
+				}
+				goto st0
+			st53:
+				p++
+				if p == pe {
+					goto _test_eof53
+				}
+				fallthrough
+			case 53:
+				switch data[p] {
+				case 84:
+					goto st8
+				case 116:
+					goto st8
+				}
+				goto st0
+			st54:
+				p++
+				if p == pe {
+					goto _test_eof54
+				}
+				fallthrough
+			case 54:
+				switch data[p] {
+				case 69:
+					goto st55
+				case 101:
+					goto st55
+				}
+				goto st0
+			st55:
+				p++
+				if p == pe {
+					goto _test_eof55
+				}
+				fallthrough
+			case 55:
+				switch data[p] {
+				case 65:
+					goto st56
+				case 97:
+					goto st56
+				}
+				goto st0
+			st56:
+				p++
+				if p == pe {
+					goto _test_eof56
+				}
+				fallthrough
+			case 56:
+				switch data[p] {
+				case 84:
+					goto st57
+				case 116:
+					goto st57
+				}
+				goto st0
+			st57:
+				p++
+				if p == pe {
+					goto _test_eof57
+				}
+				fallthrough
+			case 57:
+				switch data[p] {
+				case 69:
+					goto st58
+				case 101:
+					goto st58
+				}
+				goto st0
+			st58:
+				p++
+				if p == pe {
+					goto _test_eof58
+				}
+				fallthrough
+			case 58:
+				switch data[p] {
+				case 68:
+					goto st8
+				case 100:
+					goto st8
+				}
+				goto st0
+			tr112:
+				// line 30 "kparse.rl"
+				{
+					mark = p
+				}
+				goto st59
+			st59:
+				p++
+				if p == pe {
+					goto _test_eof59
+				}
+				fallthrough
+			case 59:
+				// line 929 "kparse.go"
+				switch data[p] {
+				case 88:
+					goto st60
+				case 120:
+					goto st60
+				}
+				goto st0
+			st60:
+				p++
+				if p == pe {
+					goto _test_eof60
+				}
+				fallthrough
+			case 60:
+				switch data[p] {
+				case 80:
+					goto st61
+				case 112:
+					goto st61
+				}
+				goto st0
+			st61:
+				p++
+				if p == pe {
+					goto _test_eof61
+				}
+				fallthrough
+			case 61:
+				switch data[p] {
+				case 79:
+					goto st62
+				case 111:
+					goto st62
+				}
+				goto st0
+			st62:
+				p++
+				if p == pe {
+					goto _test_eof62
+				}
+				fallthrough
+			case 62:
+				switch data[p] {
+				case 78:
+					goto st63
+				case 110:
+					goto st63
+				}
+				goto st0
+			st63:
+				p++
+				if p == pe {
+					goto _test_eof63
+				}
+				fallthrough
+			case 63:
+				switch data[p] {
+				case 69:
+					goto st64
+				case 101:
+					goto st64
+				}
+				goto st0
+			st64:
+				p++
+				if p == pe {
+					goto _test_eof64
+				}
+				fallthrough
+			case 64:
+				switch data[p] {
+				case 78:
+					goto st65
+				case 110:
+					goto st65
+				}
+				goto st0
+			st65:
+				p++
+				if p == pe {
+					goto _test_eof65
+				}
+				fallthrough
+			case 65:
+				switch data[p] {
+				case 84:
+					goto st66
+				case 116:
+					goto st66
+				}
+				goto st0
+			st66:
+				p++
+				if p == pe {
+					goto _test_eof66
+				}
+				fallthrough
+			case 66:
+				if 49 <= data[p] && data[p] <= 50 {
+					goto st8
+				}
+				goto st0
+			tr113:
+				// line 30 "kparse.rl"
+				{
+					mark = p
+				}
+				goto st67
+			st67:
+				p++
+				if p == pe {
+					goto _test_eof67
+				}
+				fallthrough
+			case 67:
+				// line 1011 "kparse.go"
+				switch data[p] {
+				case 79:
+					goto st68
+				case 111:
+					goto st68
+				}
+				goto st0
+			st68:
+				p++
+				if p == pe {
+					goto _test_eof68
+				}
+				fallthrough
+			case 68:
+				switch data[p] {
+				case 83:
+					goto st69
+				case 115:
+					goto st69
+				}
+				goto st0
+			st69:
+				p++
+				if p == pe {
+					goto _test_eof69
+				}
+				fallthrough
+			case 69:
+				switch data[p] {
+				case 84:
+					goto st70
+				case 116:
+					goto st70
+				}
+				goto st0
+			st70:
+				p++
+				if p == pe {
+					goto _test_eof70
+				}
+				fallthrough
+			case 70:
+				switch data[p] {
+				case 65:
+					goto st71
+				case 97:
+					goto st71
+				}
+				goto st0
+			st71:
+				p++
+				if p == pe {
+					goto _test_eof71
+				}
+				fallthrough
+			case 71:
+				switch data[p] {
+				case 83:
+					goto st72
+				case 115:
+					goto st72
+				}
+				goto st0
+			st72:
+				p++
+				if p == pe {
+					goto _test_eof72
+				}
+				fallthrough
+			case 72:
+				switch data[p] {
+				case 78:
+					goto st73
+				case 110:
+					goto st73
+				}
+				goto st0
+			st73:
+				p++
+				if p == pe {
+					goto _test_eof73
+				}
+				fallthrough
+			case 73:
+				if data[p] == 49 {
+					goto st8
+				}
+				goto st0
+			tr114:
+				// line 30 "kparse.rl"
+				{
+					mark = p
+				}
+				goto st74
+			st74:
+				p++
+				if p == pe {
+					goto _test_eof74
+				}
+				fallthrough
+			case 74:
+				// line 1083 "kparse.go"
+				switch data[p] {
+				case 79:
+					goto st75
+				case 111:
+					goto st75
+				}
+				goto st0
+			st75:
+				p++
+				if p == pe {
+					goto _test_eof75
+				}
+				fallthrough
+			case 75:
+				switch data[p] {
+				case 68:
+					goto st76
+				case 100:
+					goto st76
+				}
+				goto st0
+			st76:
+				p++
+				if p == pe {
+					goto _test_eof76
+				}
+				fallthrough
+			case 76:
+				switch data[p] {
+				case 85:
+					goto st77
+				case 117:
+					goto st77
+				}
+				goto st0
+			st77:
+				p++
+				if p == pe {
+					goto _test_eof77
+				}
+				fallthrough
+			case 77:
+				switch data[p] {
+				case 76:
+					goto st78
+				case 108:
+					goto st78
+				}
+				goto st0
+			st78:
+				p++
+				if p == pe {
+					goto _test_eof78
+				}
+				fallthrough
+			case 78:
+				switch data[p] {
+				case 85:
+					goto st79
+				case 117:
+					goto st79
+				}
+				goto st0
+			st79:
+				p++
+				if p == pe {
+					goto _test_eof79
+				}
+				fallthrough
+			case 79:
+				switch data[p] {
+				case 83:
+					goto st8
+				case 115:
+					goto st8
+				}
+				goto st0
+			tr115:
+				// line 30 "kparse.rl"
+				{
+					mark = p
+				}
+				goto st80
+			st80:
+				p++
+				if p == pe {
+					goto _test_eof80
+				}
+				fallthrough
+			case 80:
+				// line 1148 "kparse.go"
+				switch data[p] {
+				case 82:
+					goto st81
+				case 85:
+					goto st103
+				case 114:
+					goto st81
+				case 117:
+					goto st103
+				}
+				goto st0
+			st81:
+				p++
+				if p == pe {
+					goto _test_eof81
+				}
+				fallthrough
+			case 81:
+				switch data[p] {
+				case 73:
+					goto st82
+				case 105:
+					goto st82
+				}
+				goto st0
+			st82:
+				p++
+				if p == pe {
+					goto _test_eof82
+				}
+				fallthrough
+			case 82:
+				switch data[p] {
+				case 77:
+					goto st83
+				case 86:
+					goto st84
+				case 109:
+					goto st83
+				case 118:
+					goto st84
+				}
+				goto st0
+			st83:
+				p++
+				if p == pe {
+					goto _test_eof83
+				}
+				fallthrough
+			case 83:
+				switch data[p] {
+				case 69:
+					goto st66
+				case 101:
+					goto st66
+				}
+				goto st0
+			st84:
+				p++
+				if p == pe {
+					goto _test_eof84
+				}
+				fallthrough
+			case 84:
+				switch data[p] {
+				case 65:
+					goto st85
+				case 97:
+					goto st85
+				}
+				goto st0
+			st85:
+				p++
+				if p == pe {
+					goto _test_eof85
+				}
+				fallthrough
+			case 85:
+				switch data[p] {
+				case 84:
+					goto st86
+				case 116:
+					goto st86
+				}
+				goto st0
+			st86:
+				p++
+				if p == pe {
+					goto _test_eof86
+				}
+				fallthrough
+			case 86:
+				switch data[p] {
+				case 69:
+					goto st87
+				case 101:
+					goto st87
+				}
+				goto st0
+			st87:
+				p++
+				if p == pe {
+					goto _test_eof87
+				}
+				fallthrough
+			case 87:
+				switch data[p] {
+				case 45:
+					goto st88
+				case 69:
+					goto st97
+				case 75:
+					goto st101
+				case 101:
+					goto st97
+				case 107:
+					goto st101
+				}
+				goto st0
+			st88:
+				p++
+				if p == pe {
+					goto _test_eof88
+				}
+				fallthrough
+			case 88:
+				switch data[p] {
+				case 75:
+					goto st89
+				case 107:
+					goto st89
+				}
+				goto st0
+			st89:
+				p++
+				if p == pe {
+					goto _test_eof89
+				}
+				fallthrough
+			case 89:
+				switch data[p] {
+				case 69:
+					goto st90
+				case 101:
+					goto st90
+				}
+				goto st0
+			st90:
+				p++
+				if p == pe {
+					goto _test_eof90
+				}
+				fallthrough
+			case 90:
+				switch data[p] {
+				case 89:
+					goto st91
+				case 121:
+					goto st91
+				}
+				goto st0
+			st91:
+				p++
+				if p == pe {
+					goto _test_eof91
+				}
+				fallthrough
+			case 91:
+				if data[p] == 45 {
+					goto st92
+				}
+				goto st0
+			st92:
+				p++
+				if p == pe {
+					goto _test_eof92
+				}
+				fallthrough
+			case 92:
+				switch data[p] {
+				case 70:
+					goto st93
+				case 102:
+					goto st93
+				}
+				goto st0
+			st93:
+				p++
+				if p == pe {
+					goto _test_eof93
+				}
+				fallthrough
+			case 93:
+				switch data[p] {
+				case 79:
+					goto st94
+				case 111:
+					goto st94
+				}
+				goto st0
+			st94:
+				p++
+				if p == pe {
+					goto _test_eof94
+				}
+				fallthrough
+			case 94:
+				switch data[p] {
+				case 82:
+					goto st95
+				case 114:
+					goto st95
+				}
+				goto st0
+			st95:
+				p++
+				if p == pe {
+					goto _test_eof95
+				}
+				fallthrough
+			case 95:
+				switch data[p] {
+				case 77:
+					goto st96
+				case 109:
+					goto st96
+				}
+				goto st0
+			st96:
+				p++
+				if p == pe {
+					goto _test_eof96
+				}
+				fallthrough
+			case 96:
+				switch data[p] {
+				case 65:
+					goto st53
+				case 97:
+					goto st53
+				}
+				goto st0
+			st97:
+				p++
+				if p == pe {
+					goto _test_eof97
+				}
+				fallthrough
+			case 97:
+				switch data[p] {
+				case 88:
+					goto st98
+				case 120:
+					goto st98
+				}
+				goto st0
+			st98:
+				p++
+				if p == pe {
+					goto _test_eof98
+				}
+				fallthrough
+			case 98:
+				switch data[p] {
+				case 80:
+					goto st99
+				case 112:
+					goto st99
+				}
+				goto st0
+			st99:
+				p++
+				if p == pe {
+					goto _test_eof99
+				}
+				fallthrough
+			case 99:
+				switch data[p] {
+				case 79:
+					goto st100
+				case 111:
+					goto st100
+				}
+				goto st0
+			st100:
+				p++
+				if p == pe {
+					goto _test_eof100
+				}
+				fallthrough
+			case 100:
+				switch data[p] {
+				case 78:
+					goto st51
+				case 110:
+					goto st51
+				}
+				goto st0
+			st101:
+				p++
+				if p == pe {
+					goto _test_eof101
+				}
+				fallthrough
+			case 101:
+				switch data[p] {
+				case 69:
+					goto st102
+				case 101:
+					goto st102
+				}
+				goto st0
+			st102:
+				p++
+				if p == pe {
+					goto _test_eof102
+				}
+				fallthrough
+			case 102:
+				switch data[p] {
+				case 89:
+					goto st8
+				case 121:
+					goto st8
+				}
+				goto st0
+			st103:
+				p++
+				if p == pe {
+					goto _test_eof103
+				}
+				fallthrough
+			case 103:
+				switch data[p] {
+				case 66:
+					goto st104
+				case 98:
+					goto st104
+				}
+				goto st0
+			st104:
+				p++
+				if p == pe {
+					goto _test_eof104
+				}
+				fallthrough
+			case 104:
+				switch data[p] {
+				case 76:
+					goto st105
+				case 108:
+					goto st105
+				}
+				goto st0
+			st105:
+				p++
+				if p == pe {
+					goto _test_eof105
+				}
+				fallthrough
+			case 105:
+				switch data[p] {
+				case 73:
+					goto st106
+				case 105:
+					goto st106
+				}
+				goto st0
+			st106:
+				p++
+				if p == pe {
+					goto _test_eof106
+				}
+				fallthrough
+			case 106:
+				switch data[p] {
+				case 67:
+					goto st107
+				case 83:
+					goto st108
+				case 99:
+					goto st107
+				case 115:
+					goto st108
+				}
+				goto st0
+			st107:
+				p++
+				if p == pe {
+					goto _test_eof107
+				}
+				fallthrough
+			case 107:
+				switch data[p] {
+				case 69:
+					goto st97
+				case 101:
+					goto st97
+				}
+				goto st0
+			st108:
+				p++
+				if p == pe {
+					goto _test_eof108
+				}
+				fallthrough
+			case 108:
+				switch data[p] {
+				case 72:
+					goto st8
+				case 104:
+					goto st8
+				}
+				goto st0
+			st109:
+				p++
+				if p == pe {
+					goto _test_eof109
+				}
+				fallthrough
+			case 109:
+				if data[p] == 59 {
+					goto st110
+				}
+				goto st0
+			st110:
+				p++
+				if p == pe {
+					goto _test_eof110
+				}
+				fallthrough
+			case 110:
+				if data[p] == 10 {
+					goto st111
+				}
+				goto st0
+			}
+		_test_eof111:
+			cs = 111
+			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_eof:
+			{
+			}
+		_out:
+			{
+			}
+		}
+
+		// line 65 "kparse.rl"
 
-	_test_eof: {}
-	_out: {}
 	}
 
-// line 65 "kparse.rl"
-
-        }
-
-        if cs < k_first_final {
-                if p == pe {
-                        //return nil, os.ErrorString("unexpected eof")
-                        println("err unexp eof")
-                        return m, nil
-                } else {
-                        //return nil, os.ErrorString(fmt.Sprintf("error at position %d", p))
-                        println("err ", p, "data:", data[p])
-                        return nil, nil
-                }
-        }
-        return m, nil
+	if cs < k_first_final {
+		if p == pe {
+			//return nil, os.ErrorString("unexpected eof")
+			println("err unexp eof")
+			return m, nil
+		} else {
+			//return nil, os.ErrorString(fmt.Sprintf("error at position %d", p))
+			println("err ", p, "data:", data[p])
+			return nil, nil
+		}
+	}
+	return m, nil
 }
diff --git a/msg.go b/msg.go
index 2df04c7b..dd8e78bf 100644
--- a/msg.go
+++ b/msg.go
@@ -127,7 +127,7 @@ var Class_str = map[uint16]string{
 	ClassCSNET:  "CS",
 	ClassCHAOS:  "CH",
 	ClassHESIOD: "HS",
-        ClassNONE:   "NONE",
+	ClassNONE:   "NONE",
 	ClassANY:    "ANY",
 }
 
@@ -363,8 +363,8 @@ func packStructValue(val reflect.Value, msg []byte, off int) (off1 int, ok bool)
 			i := fv.Uint()
 			switch fv.Type().Kind() {
 			default:
-                                //fmt.Fprintf(os.Stderr, "dns: unknown packing type %v\n", f.Type)
-                                return len(msg), false
+				//fmt.Fprintf(os.Stderr, "dns: unknown packing type %v\n", f.Type)
+				return len(msg), false
 			case reflect.Uint8:
 				if off+1 > len(msg) {
 					//fmt.Fprintf(os.Stderr, "dns: overflow packing uint8")
@@ -597,8 +597,8 @@ func unpackStructValue(val reflect.Value, msg []byte, off int) (off1 int, ok boo
 		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
 			switch fv.Type().Kind() {
 			default:
-                                //fmt.Fprintf(os.Stderr, "dns: unknown packing type %v\n", f.Type)
-                                return len(msg), false
+				//fmt.Fprintf(os.Stderr, "dns: unknown packing type %v\n", f.Type)
+				return len(msg), false
 
 			case reflect.Uint8:
 				if off+1 > len(msg) {
diff --git a/parse_test.go b/parse_test.go
index de2a18f8..d2cd9eeb 100644
--- a/parse_test.go
+++ b/parse_test.go
@@ -1,10 +1,10 @@
 package dns
 
 import (
-        "os"
-        "time"
-        "bufio"
-        "strings"
+	"os"
+	"time"
+	"bufio"
+	"strings"
 	"testing"
 	"crypto/rsa"
 )
@@ -27,21 +27,21 @@ Publish: 20110302104537
 Activate: 20110302104537`
 
 	k := new(RR_DNSKEY)
-        k.Read(strings.NewReader(pub))
+	k.Read(strings.NewReader(pub))
 	p, err := k.ReadPrivateKey(strings.NewReader(priv))
-        if err != nil {
-                t.Logf("%v\n", err)
-                t.Fail()
-        }
+	if err != nil {
+		t.Logf("%v\n", err)
+		t.Fail()
+	}
 	switch priv := p.(type) {
 	case *rsa.PrivateKey:
 		if 65537 != priv.PublicKey.E {
 			t.Log("Exponenent should be 65537")
 			t.Fail()
 		}
-        default:
-                t.Logf("We should have read an RSA key: %v", priv)
-                t.Fail()
+	default:
+		t.Logf("We should have read an RSA key: %v", priv)
+		t.Fail()
 	}
 	if k.KeyTag() != 37350 {
 		t.Logf("%d %v\n", k.KeyTag(), k)
@@ -68,113 +68,111 @@ Activate: 20110302104537`
 	sig.Algorithm = k.Algorithm
 
 	sig.Sign(p, []RR{soa})
-        if sig.Signature != "D5zsobpQcmMmYsUMLxCVEtgAdCvTu8V/IEeP4EyLBjqPJmjt96bwM9kqihsccofA5LIJ7DN91qkCORjWSTwNhzCv7bMyr2o5vBZElrlpnRzlvsFIoAZCD9xg6ZY7ZyzUJmU6IcTwG4v3xEYajcpbJJiyaw/RqR90MuRdKPiBzSo=" {
-                t.Log("Signature is not correct")
-                t.Logf("%v\n", sig)
-                t.Fail()
-        }
+	if sig.Signature != "D5zsobpQcmMmYsUMLxCVEtgAdCvTu8V/IEeP4EyLBjqPJmjt96bwM9kqihsccofA5LIJ7DN91qkCORjWSTwNhzCv7bMyr2o5vBZElrlpnRzlvsFIoAZCD9xg6ZY7ZyzUJmU6IcTwG4v3xEYajcpbJJiyaw/RqR90MuRdKPiBzSo=" {
+		t.Log("Signature is not correct")
+		t.Logf("%v\n", sig)
+		t.Fail()
+	}
 }
 
 func TestDotInName(t *testing.T) {
 	buf := make([]byte, 20)
 	packDomainName("aa\\.bb.nl.", buf, 0)
-        // index 3 must be a real dot
-        if buf[3] != '.' {
-                t.Log("Dot should be a real dot")
-                t.Fail()
-        }
+	// index 3 must be a real dot
+	if buf[3] != '.' {
+		t.Log("Dot should be a real dot")
+		t.Fail()
+	}
 
-        if buf[6] != 2 {
-                t.Log("This must have the value 2")
-                t.Fail()
-        }
-        dom, _, _ := unpackDomainName(buf, 0)
-        // printing it should yield the backspace again
-        if dom != "aa\\.bb.nl." {
-                t.Log("Dot should have been escaped: " + dom)
-                t.Fail()
-        }
+	if buf[6] != 2 {
+		t.Log("This must have the value 2")
+		t.Fail()
+	}
+	dom, _, _ := unpackDomainName(buf, 0)
+	// printing it should yield the backspace again
+	if dom != "aa\\.bb.nl." {
+		t.Log("Dot should have been escaped: " + dom)
+		t.Fail()
+	}
 }
 
 // Make this a decend test case. For now, good enough
 // New style (Ragel) parsing
 func TestParse(t *testing.T) {
-        tests := map[string]string{
-                "miek.nl. 3600 IN A 127.0.0.1": "miek.nl.\t3600\tIN\tA\t127.0.0.1",
-                "miek.nl. 3600 IN MX 10 elektron.atoom.net.": "miek.nl.\t3600\tIN\tMX\t10 elektron.atoom.net.",
-                "miek.nl. IN 3600 A 127.0.0.1": "miek.nl.\t3600\tIN\tA\t127.0.0.1",
-                "miek.nl. A 127.0.0.1":         "miek.nl.\t0\tCLASS0\tA\t127.0.0.1",
-                "miek.nl. IN AAAA ::1":         "miek.nl.\t0\tIN\tAAAA\t::1",
-                "miek.nl. IN A 127.0.0.1":      "miek.nl.\t0\tIN\tA\t127.0.0.1",
-                "miek.nl. IN DNSKEY 256 3 5 AwEAAb+8lGNCxJgLS8rYVer6EnHVuIkQDghdjdtewDzU3G5R7PbMbKVRvH2Ma7pQyYceoaqWZQirSj72euPWfPxQnMy9ucCylA+FuH9cSjIcPf4PqJfdupHk9X6EBYjxrCLY4p1/yBwgyBIRJtZtAqM3ceAH2WovEJD6rTtOuHo5AluJ":
-                        "miek.nl.\t0\tIN\tDNSKEY\t256 3 5 AwEAAb+8lGNCxJgLS8rYVer6EnHVuIkQDghdjdtewDzU3G5R7PbMbKVRvH2Ma7pQyYceoaqWZQirSj72euPWfPxQnMy9ucCylA+FuH9cSjIcPf4PqJfdupHk9X6EBYjxrCLY4p1/yBwgyBIRJtZtAqM3ceAH2WovEJD6rTtOuHo5AluJ",
-                "nlnetlabs.nl. 3175 IN DNSKEY 256 3 8 AwEAAdR7XR95OaAN9Rz7TbtPalQ9guQk7zfxTHYNKhsiwTZA9z+F16nD0VeBlk7dNik3ETpT2GLAwr9sntG898JwurCDe353wHPvjZtMCdiTVp3cRCrjuCEvoFpmZNN82H0gaH/4v8mkv/QBDAkDSncYjz/FqHKAeYy3cMcjY6RyVweh":
-                        "nlnetlabs.nl.\t3175\tIN\tDNSKEY\t256 3 8 AwEAAdR7XR95OaAN9Rz7TbtPalQ9guQk7zfxTHYNKhsiwTZA9z+F16nD0VeBlk7dNik3ETpT2GLAwr9sntG898JwurCDe353wHPvjZtMCdiTVp3cRCrjuCEvoFpmZNN82H0gaH/4v8mkv/QBDAkDSncYjz/FqHKAeYy3cMcjY6RyVweh",
-                }
-        for test, result := range tests {
-                p := NewParser(strings.NewReader(test))
-                z, err := p.Zone()
-                if err != nil || z == nil{
-                        t.Logf("Error of nil r %v %s\n", err, test)
-                        t.Fail()
-                }
-                r := z.Pop().(RR)
-                if r.String() != result {
-                        t.Logf("\"%s\" should be equal to\n\"%s\"\n", r, result)
-                        t.Fail()
-                }
-        }
+	tests := map[string]string{
+		"miek.nl. 3600 IN A 127.0.0.1":               "miek.nl.\t3600\tIN\tA\t127.0.0.1",
+		"miek.nl. 3600 IN MX 10 elektron.atoom.net.": "miek.nl.\t3600\tIN\tMX\t10 elektron.atoom.net.",
+		"miek.nl. IN 3600 A 127.0.0.1":               "miek.nl.\t3600\tIN\tA\t127.0.0.1",
+		"miek.nl. A 127.0.0.1":                       "miek.nl.\t0\tCLASS0\tA\t127.0.0.1",
+		"miek.nl. IN AAAA ::1":                       "miek.nl.\t0\tIN\tAAAA\t::1",
+		"miek.nl. IN A 127.0.0.1":                    "miek.nl.\t0\tIN\tA\t127.0.0.1",
+		"miek.nl. IN DNSKEY 256 3 5 AwEAAb+8lGNCxJgLS8rYVer6EnHVuIkQDghdjdtewDzU3G5R7PbMbKVRvH2Ma7pQyYceoaqWZQirSj72euPWfPxQnMy9ucCylA+FuH9cSjIcPf4PqJfdupHk9X6EBYjxrCLY4p1/yBwgyBIRJtZtAqM3ceAH2WovEJD6rTtOuHo5AluJ":           "miek.nl.\t0\tIN\tDNSKEY\t256 3 5 AwEAAb+8lGNCxJgLS8rYVer6EnHVuIkQDghdjdtewDzU3G5R7PbMbKVRvH2Ma7pQyYceoaqWZQirSj72euPWfPxQnMy9ucCylA+FuH9cSjIcPf4PqJfdupHk9X6EBYjxrCLY4p1/yBwgyBIRJtZtAqM3ceAH2WovEJD6rTtOuHo5AluJ",
+		"nlnetlabs.nl. 3175 IN DNSKEY 256 3 8 AwEAAdR7XR95OaAN9Rz7TbtPalQ9guQk7zfxTHYNKhsiwTZA9z+F16nD0VeBlk7dNik3ETpT2GLAwr9sntG898JwurCDe353wHPvjZtMCdiTVp3cRCrjuCEvoFpmZNN82H0gaH/4v8mkv/QBDAkDSncYjz/FqHKAeYy3cMcjY6RyVweh": "nlnetlabs.nl.\t3175\tIN\tDNSKEY\t256 3 8 AwEAAdR7XR95OaAN9Rz7TbtPalQ9guQk7zfxTHYNKhsiwTZA9z+F16nD0VeBlk7dNik3ETpT2GLAwr9sntG898JwurCDe353wHPvjZtMCdiTVp3cRCrjuCEvoFpmZNN82H0gaH/4v8mkv/QBDAkDSncYjz/FqHKAeYy3cMcjY6RyVweh",
+	}
+	for test, result := range tests {
+		p := NewParser(strings.NewReader(test))
+		z, err := p.Zone()
+		if err != nil || z == nil {
+			t.Logf("Error of nil r %v %s\n", err, test)
+			t.Fail()
+		}
+		r := z.Pop().(RR)
+		if r.String() != result {
+			t.Logf("\"%s\" should be equal to\n\"%s\"\n", r, result)
+			t.Fail()
+		}
+	}
 }
 
 func TestSetString(t *testing.T) {
-        a := NewRR("miek.nl. IN A 127.0.0.1")
-        if a.String() != "miek.nl.\t0\tIN\tA\t127.0.0.1" {
-                t.Log(a.String(), "!= miek.nl. IN A 127.0.0.1")
-                t.Fail()
-        }
-        b := NewRR("miek.nl. IN AAAA ::1")
-        if b.String() != "miek.nl.\t0\tIN\tAAAA\t::1" {
-                t.Log(b.String(), "!= miek.nl. IN AAAA ::1")
-                t.Fail()
-        }
-        c := NewRR("miek.nl. IN MX 10 miek.nl.")
-        if c.String() != "miek.nl.\t0\tIN\tMX\t10 miek.nl." {
-                t.Log(c.String(), "!= miek.nl. IN MX 10 miek.nl.")
-                t.Fail()
-        }
-        d := NewRR("miek.nl. IN NS ns1.miek.nl")
-        if d.String() != "miek.nl.\t0\tIN\tNS\tns1.miek.nl" {
-                t.Log(d.String(), "!= miek.nl. IN NS ns1.miek.nl")
-                t.Fail()
-        }
+	a := NewRR("miek.nl. IN A 127.0.0.1")
+	if a.String() != "miek.nl.\t0\tIN\tA\t127.0.0.1" {
+		t.Log(a.String(), "!= miek.nl. IN A 127.0.0.1")
+		t.Fail()
+	}
+	b := NewRR("miek.nl. IN AAAA ::1")
+	if b.String() != "miek.nl.\t0\tIN\tAAAA\t::1" {
+		t.Log(b.String(), "!= miek.nl. IN AAAA ::1")
+		t.Fail()
+	}
+	c := NewRR("miek.nl. IN MX 10 miek.nl.")
+	if c.String() != "miek.nl.\t0\tIN\tMX\t10 miek.nl." {
+		t.Log(c.String(), "!= miek.nl. IN MX 10 miek.nl.")
+		t.Fail()
+	}
+	d := NewRR("miek.nl. IN NS ns1.miek.nl")
+	if d.String() != "miek.nl.\t0\tIN\tNS\tns1.miek.nl" {
+		t.Log(d.String(), "!= miek.nl. IN NS ns1.miek.nl")
+		t.Fail()
+	}
 }
 
 func BenchmarkZoneParsing(b *testing.B) {
-        file, err := os.Open("miek.nl")
-        defer file.Close()
-        if err != nil {
-                return
-        }
-        p := NewParser(bufio.NewReader(file))
-        // Don't care about errors (there shouldn't be any)
-        p.Zone()
+	file, err := os.Open("miek.nl")
+	defer file.Close()
+	if err != nil {
+		return
+	}
+	p := NewParser(bufio.NewReader(file))
+	// Don't care about errors (there shouldn't be any)
+	p.Zone()
 }
 
 func TestZoneParsing(t *testing.T) {
-        file, err := os.Open("miek.nl")
-        defer file.Close()
-        if err != nil {
-                return
-        }
-        p := NewParser(bufio.NewReader(file))
+	file, err := os.Open("miek.nl")
+	defer file.Close()
+	if err != nil {
+		return
+	}
+	p := NewParser(bufio.NewReader(file))
 
-        // Don't care about errors (there shouldn't be any)
-        start := time.Nanoseconds()
-        z, err := p.Zone()
-        if err != nil {
-                t.Logf("error %v\n", err.String())
-                t.Fail()
-        }
-        delta := time.Nanoseconds() - start
-        t.Logf("%d RRs parsed in %.2f s (%.2f RR/s)", z.Len()-1, float32(delta)/1e9, float32(z.Len()-1)/(float32(delta)/1e9))
+	// Don't care about errors (there shouldn't be any)
+	start := time.Nanoseconds()
+	z, err := p.Zone()
+	if err != nil {
+		t.Logf("error %v\n", err.String())
+		t.Fail()
+	}
+	delta := time.Nanoseconds() - start
+	t.Logf("%d RRs parsed in %.2f s (%.2f RR/s)", z.Len()-1, float32(delta)/1e9, float32(z.Len()-1)/(float32(delta)/1e9))
 }
diff --git a/server.go b/server.go
index 111d3c4e..6d5e277a 100644
--- a/server.go
+++ b/server.go
@@ -23,7 +23,7 @@ type Handler interface {
 type ResponseWriter interface {
 	// RemoteAddr returns the net.Addr of the client that sent the current request.
 	RemoteAddr() net.Addr
-        // Write a reply back to the client.
+	// Write a reply back to the client.
 	Write([]byte) (int, os.Error)
 }
 
@@ -164,12 +164,12 @@ func HandleFunc(pattern string, handler func(ResponseWriter, *Msg)) {
 // A Server defines parameters for running an DNS server.
 // Note how much it starts to look like 'Client struct'
 type Server struct {
-	Addr         string  // address to listen on, ":dns" if empty
-	Net          string  // if "tcp" it will invoke a TCP listener, otherwise an UDP one
-	Handler      Handler // handler to invoke, dns.DefaultServeMux if nil
-	ReadTimeout  int64   // the net.Conn.SetReadTimeout value for new connections
-	WriteTimeout int64   // the net.Conn.SetWriteTimeout value for new connections
-        TsigSecret   map[string]string // secret(s) for Tsig map[<zonename>]<base64 secret>
+	Addr         string            // address to listen on, ":dns" if empty
+	Net          string            // if "tcp" it will invoke a TCP listener, otherwise an UDP one
+	Handler      Handler           // handler to invoke, dns.DefaultServeMux if nil
+	ReadTimeout  int64             // the net.Conn.SetReadTimeout value for new connections
+	WriteTimeout int64             // the net.Conn.SetWriteTimeout value for new connections
+	TsigSecret   map[string]string // secret(s) for Tsig map[<zonename>]<base64 secret>
 }
 
 // ...
@@ -333,7 +333,7 @@ func (w *response) Write(data []byte) (n int, err os.Error) {
 	case w.conn._UDP != nil:
 		n, err = w.conn._UDP.WriteTo(data, w.conn.remoteAddr)
 		if err != nil {
-                        println(err.String())
+			println(err.String())
 			return 0, err
 		}
 	case w.conn._TCP != nil:
diff --git a/server_test.go b/server_test.go
index d1e7e41c..d6d09a13 100644
--- a/server_test.go
+++ b/server_test.go
@@ -28,19 +28,19 @@ func TestServing(t *testing.T) {
 }
 
 func BenchmarkServing(b *testing.B) {
-        b.StopTimer()
-        // Again start a server
+	b.StopTimer()
+	// Again start a server
 	HandleFunc("miek.nl.", HelloServer)
 	go func() {
-	        ListenAndServe("127.0.0.1:8053", "udp", nil)
+		ListenAndServe("127.0.0.1:8053", "udp", nil)
 	}()
 
-        c := NewClient()
-        m := new(Msg)
-        m.SetQuestion("miek.nl", TypeSOA)
+	c := NewClient()
+	m := new(Msg)
+	m.SetQuestion("miek.nl", TypeSOA)
 
-        b.StartTimer()
-        for i := 0; i < b.N; i++ {
-                c.Exchange(m, "127.0.0.1:8053")
-        }
+	b.StartTimer()
+	for i := 0; i < b.N; i++ {
+		c.Exchange(m, "127.0.0.1:8053")
+	}
 }
diff --git a/types.go b/types.go
index fa22e7f9..3b03d14b 100644
--- a/types.go
+++ b/types.go
@@ -149,11 +149,11 @@ func (q *Question) String() string {
 // NewRR returns the last RR contained in s.
 func NewRR(s string) RR {
 	p := NewParser(strings.NewReader(s))
-        x := p.RR()
+	x := p.RR()
 	if x == nil {
 		return nil
 	}
-        return x
+	return x
 }
 
 type RR_CNAME struct {
diff --git a/zone.go b/zone.go
index 9c7a4f4c..28a0ebd1 100644
--- a/zone.go
+++ b/zone.go
@@ -5,30 +5,30 @@
 package dns
 
 import (
-        "container/vector"
+	"container/vector"
 )
 
 // Zone implements the concept of RFC 1035 master zone files.
 type Zone struct {
-        v vector.Vector
+	v vector.Vector
 }
 
 // Add a new RR to the zone.
 func (z *Zone) Push(r RR) {
-        z.v.Push(r)
+	z.v.Push(r)
 }
 
 // Remove a RR from the zone.
 func (z *Zone) Pop() RR {
-        return z.v.Pop().(RR)
+	return z.v.Pop().(RR)
 }
 
 // Return the RR at index i of zone.
 func (z *Zone) At(i int) RR {
-        return z.v.At(i).(RR)
+	return z.v.At(i).(RR)
 }
 
 // The number of RRs in zone.
 func (z *Zone) Len() int {
-        return z.v.Len()
+	return z.v.Len()
 }
diff --git a/zparse.go b/zparse.go
index f7014a0c..4e771357 100644
--- a/zparse.go
+++ b/zparse.go
@@ -1,4 +1,3 @@
-
 // line 1 "zparse.rl"
 package dns
 
@@ -6,38 +5,38 @@ package dns
 // With the thankful help of gdnsd and the Go examples for Ragel.
 
 import (
-    "os"
-    "io"
-    "net"
-    "strings"
-    "strconv"
+	"os"
+	"io"
+	"net"
+	"strings"
+	"strconv"
 )
 
 //const _IOBUF = 65365 // See comments in gdnsd
-const _IOBUF = 3e7  // TODO fix sliding window stuff in Ragel
+const _IOBUF = 3e7 // TODO fix sliding window stuff in Ragel
 
 // A Parser represents a DNS parser for a 
 // particular input stream. 
 type Parser struct {
-    // nothing here yet
-    buf    []byte
+	// nothing here yet
+	buf []byte
 }
 
 // NewParser creates a new DNS file parser from r.
 func NewParser(r io.Reader) *Parser {
-        buf := make([]byte, _IOBUF) 
-        n, err := r.Read(buf)
-        if err != nil {
-            return nil
-        }
-        if buf[n-1] != '\n' {
-            buf[n] = '\n'
-            n++
-        }
-        buf = buf[:n]
-        p := new(Parser)
-        p.buf = buf
-        return p
+	buf := make([]byte, _IOBUF)
+	n, err := r.Read(buf)
+	if err != nil {
+		return nil
+	}
+	if buf[n-1] != '\n' {
+		buf[n] = '\n'
+		n++
+	}
+	buf = buf[:n]
+	p := new(Parser)
+	p.buf = buf
+	return p
 }
 
 
@@ -45,26 +44,26 @@ func NewParser(r io.Reader) *Parser {
 // 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
+	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
 }
 
 // Wrapper for strconv.Atoi*().
 func atoi(s string) uint {
-    i, err :=  strconv.Atoui(s)
-    if err != nil {
-        panic("not a number: " + s + " " + err.String())
-    }
-    return i
+	i, err := strconv.Atoui(s)
+	if err != nil {
+		panic("not a number: " + s + " " + err.String())
+	}
+	return i
 }
 
 
@@ -81,2234 +80,3376 @@ var z_en_main int = 134
 
 // RR parses a zone file, but only returns the last RR read.
 func (zp *Parser) RR() RR {
-    z, err := zp.Zone()
-    if err != nil {
-        return nil
-    }
-    return z.Pop().(RR)
+	z, err := zp.Zone()
+	if err != nil {
+		return nil
+	}
+	return z.Pop().(RR)
 }
 
 // Zone parses an DNS master zone file.
 func (zp *Parser) Zone() (z *Zone, err os.Error) {
-        z = new(Zone)
-        data := string(zp.buf)
-        cs, p, pe := 0, 0, len(data)
-        eof := len(data)
+	z = new(Zone)
+	data := string(zp.buf)
+	cs, p, pe := 0, 0, len(data)
+	eof := len(data)
 
-//        brace := false
-        lines := 0
-        mark := 0
-        var hdr RR_Header
+	//        brace := false
+	lines := 0
+	mark := 0
+	var hdr RR_Header
 
-        
-// line 105 "zparse.go"
+	// line 105 "zparse.go"
 	cs = z_start
 
-// line 108 "zparse.go"
+	// line 108 "zparse.go"
 	{
-	if p == pe { goto _test_eof }
-	switch cs {
-	case -666: // i am a hack D:
-tr33:
-// line 5 "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])
-        z.Push(rr)
-    }
-// line 100 "zparse.rl"
-	{ lines++ }
-	goto st134
-tr40:
-// line 14 "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])
-        z.Push(rr)
-    }
-// line 100 "zparse.rl"
-	{ lines++ }
-	goto st134
-tr50:
-// line 179 "types.rl"
-	{
-    }
-// line 100 "zparse.rl"
-	{ lines++ }
-	goto st134
-tr61:
-// line 42 "types.rl"
-	{
-        rdf := fields(data[mark:p], 1)
-        rr := new(RR_CNAME)
-        rr.Hdr = hdr
-        rr.Hdr.Rrtype = TypeCNAME
-        rr.Cname = rdf[0]
-        z.Push(rr)
-    }
-// line 100 "zparse.rl"
-	{ lines++ }
-	goto st134
-tr70:
-// line 78 "types.rl"
-	{
-        rdf := fields(data[mark:p], 4)
-        rr := new(RR_DLV)
-        rr.Hdr = hdr
-        rr.Hdr.Rrtype = TypeDLV
-        rr.KeyTag = uint16(atoi(rdf[0]))
-        rr.Algorithm = uint8(atoi(rdf[1]))
-        rr.DigestType = uint8(atoi(rdf[2]))
-        rr.Digest = rdf[3]
-        z.Push(rr)
-    }
-// line 100 "zparse.rl"
-	{ lines++ }
-	goto st134
-tr79:
-// line 185 "types.rl"
-	{
-    }
-// line 100 "zparse.rl"
-	{ lines++ }
-	goto st134
-tr87:
-// line 102 "types.rl"
-	{
-        rdf := fields(data[mark:p], 4)
-        rr := new(RR_DNSKEY)
-        rr.Hdr = hdr
-        rr.Hdr.Rrtype = TypeDNSKEY
-        rr.Flags = uint16(atoi(rdf[0]))
-        rr.Protocol = uint8(atoi(rdf[1]))
-        rr.Algorithm = uint8(atoi(rdf[2]))
-        rr.PublicKey = rdf[3]
-        z.Push(rr)
-    }
-// line 100 "zparse.rl"
-	{ lines++ }
-	goto st134
-tr92:
-// line 66 "types.rl"
-	{
-        rdf := fields(data[mark:p], 4)
-        rr := new(RR_DS)
-        rr.Hdr = hdr
-        rr.Hdr.Rrtype = TypeDS
-        rr.KeyTag = uint16(atoi(rdf[0]))
-        rr.Algorithm = uint8(atoi(rdf[1]))
-        rr.DigestType = uint8(atoi(rdf[2]))
-        rr.Digest = rdf[3]
-        z.Push(rr)
-    }
-// line 100 "zparse.rl"
-	{ lines++ }
-	goto st134
-tr98:
-// line 32 "types.rl"
-	{
-        rdf := fields(data[mark:p], 2)
-        rr := new(RR_MX)
-        rr.Hdr = hdr
-        rr.Hdr.Rrtype = TypeMX
-        rr.Pref = uint16(atoi(rdf[0]))
-        rr.Mx = rdf[1]
-        z.Push(rr)
-    }
-// line 100 "zparse.rl"
-	{ lines++ }
-	goto st134
-tr108:
-// line 188 "types.rl"
-	{
-    }
-// line 100 "zparse.rl"
-	{ lines++ }
-	goto st134
-tr114:
-// line 23 "types.rl"
-	{
-        rdf := fields(data[mark:p], 1)
-        rr := new(RR_NS)
-        rr.Hdr = hdr
-        rr.Hdr.Rrtype = TypeNS
-        rr.Ns = rdf[0]
-        z.Push(rr)
-    }
-// line 100 "zparse.rl"
-	{ lines++ }
-	goto st134
-tr121:
-// line 131 "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[rdf[i]]
-        }
-        z.Push(rr)
-    }
-// line 100 "zparse.rl"
-	{ lines++ }
-	goto st134
-tr127:
-// line 146 "types.rl"
-	{
-        rdf := fields(data[mark:p], 0)
-        rr := new(RR_NSEC3)
-        rr.Hdr = hdr
-        rr.Hdr.Rrtype = TypeNSEC3
-        rr.Hash = uint8(atoi(rdf[0]))
-        rr.Flags = uint8(atoi(rdf[1]))
-        rr.Iterations = uint16(atoi(rdf[2]))
-        rr.SaltLength = uint8(atoi(rdf[3]))
-        rr.Salt = rdf[4]
-        rr.HashLength = uint8(atoi(rdf[4]))
-        rr.NextDomain = rdf[5]
-        rr.TypeBitMap = make([]uint16, len(rdf)-6)
-        // Fill the Type Bit Map
-        for i := 6; i < len(rdf); i++ {
-            // Check if its there in the map TODO
-            rr.TypeBitMap[i-6] = str_rr[rdf[i]]
-        }
-        z.Push(rr)
-    }
-// line 100 "zparse.rl"
-	{ lines++ }
-	goto st134
-tr136:
-// line 167 "types.rl"
-	{
-    }
-// line 100 "zparse.rl"
-	{ lines++ }
-	goto st134
-tr143:
-// line 182 "types.rl"
-	{
-    }
-// line 100 "zparse.rl"
-	{ lines++ }
-	goto st134
-tr152:
-// line 114 "types.rl"
-	{
-        rdf := fields(data[mark:p], 9)
-        rr := new(RR_RRSIG)
-        rr.Hdr = hdr
-        rr.Hdr.Rrtype = TypeRRSIG
-        rr.TypeCovered = uint16(atoi(rdf[0]))
-        rr.Algorithm = uint8(atoi(rdf[1]))
-        rr.Labels = uint8(atoi(rdf[2]))
-        rr.OrigTtl = uint32(atoi(rdf[3]))
-        rr.Expiration = uint32(atoi(rdf[4]))
-        rr.Inception = uint32(atoi(rdf[5]))
-        rr.KeyTag = uint16(atoi(rdf[6]))
-        rr.SignerName = rdf[7]
-        rr.Signature = rdf[9]
-        z.Push(rr)
-    }
-// line 100 "zparse.rl"
-	{ lines++ }
-	goto st134
-tr160:
-// line 51 "types.rl"
-	{
-        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]
-        rr.Serial = uint32(atoi(rdf[2]))
-        rr.Refresh = uint32(atoi(rdf[3]))
-        rr.Retry = uint32(atoi(rdf[4]))
-        rr.Expire = uint32(atoi(rdf[5]))
-        rr.Minttl = uint32(atoi(rdf[6]))
-        z.Push(rr)
-    }
-// line 100 "zparse.rl"
-	{ lines++ }
-	goto st134
-tr166:
-// line 176 "types.rl"
-	{
-    }
-// line 100 "zparse.rl"
-	{ lines++ }
-	goto st134
-tr173:
-// line 90 "types.rl"
-	{
-        rdf := fields(data[mark:p], 4)
-        rr := new(RR_TA)
-        rr.Hdr = hdr
-        rr.Hdr.Rrtype = TypeTA
-        rr.KeyTag = uint16(atoi(rdf[0]))
-        rr.Algorithm = uint8(atoi(rdf[1]))
-        rr.DigestType = uint8(atoi(rdf[2]))
-        rr.Digest = rdf[3]
-        z.Push(rr)
-    }
-// line 100 "zparse.rl"
-	{ lines++ }
-	goto st134
-tr179:
-// line 173 "types.rl"
-	{
-    }
-// line 100 "zparse.rl"
-	{ lines++ }
-	goto st134
-tr189:
-// line 100 "zparse.rl"
-	{ lines++ }
-	goto st134
-st134:
-	p++
-	if p == pe { goto _test_eof134 }
-	fallthrough
-case 134:
-// line 385 "zparse.go"
-	switch data[p] {
-		case 9: goto st1
-		case 10: goto tr189
-		case 32: goto st1
-		case 59: goto st133
-		case 95: goto tr190
-	}
-	if data[p] < 48 {
-		if 45 <= data[p] && data[p] <= 46 { goto tr190 }
-	} else if data[p] > 57 {
-		if data[p] > 90 {
-			if 97 <= data[p] && data[p] <= 122 { goto tr190 }
-		} else if data[p] >= 65 {
-			goto tr190
+		if p == pe {
+			goto _test_eof
 		}
-	} else {
-		goto tr190
-	}
-	goto st0
-st0:
-cs = 0;
-	goto _out;
-tr186:
-// line 96 "zparse.rl"
-	{ hdr.Name = data[mark:p] }
-	goto st1
-st1:
-	p++
-	if p == pe { goto _test_eof1 }
-	fallthrough
-case 1:
-// line 417 "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 98 "zparse.rl"
-	{ /* ... */ }
-// line 95 "zparse.rl"
-	{ mark = p }
-	goto st2
-st2:
-	p++
-	if p == pe { goto _test_eof2 }
-	fallthrough
-case 2:
-// line 457 "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 99 "zparse.rl"
-	{ ttl := atoi(data[mark:p]); hdr.Ttl = uint32(ttl) }
-	goto st3
-st3:
-	p++
-	if p == pe { goto _test_eof3 }
-	fallthrough
-case 3:
-// line 473 "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 st114
-		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 st114
-	}
-	goto st0
-tr3:
-// line 98 "zparse.rl"
-	{ /* ... */ }
-	goto st4
-st4:
-	p++
-	if p == pe { goto _test_eof4 }
-	fallthrough
-case 4:
-// line 510 "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 95 "zparse.rl"
-	{ mark = p }
-	goto st6
-st6:
-	p++
-	if p == pe { goto _test_eof6 }
-	fallthrough
-case 6:
-// line 538 "zparse.go"
-	if data[p] == 10 { goto tr33 }
-	goto st6
-tr31:
-// line 95 "zparse.rl"
-	{ mark = p }
-	goto st7
-st7:
-	p++
-	if p == pe { goto _test_eof7 }
-	fallthrough
-case 7:
-// line 550 "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 95 "zparse.rl"
-	{ mark = p }
-	goto st12
-st12:
-	p++
-	if p == pe { goto _test_eof12 }
-	fallthrough
-case 12:
-// line 607 "zparse.go"
-	if data[p] == 10 { goto tr40 }
-	goto st12
-tr38:
-// line 95 "zparse.rl"
-	{ mark = p }
-	goto st13
-st13:
-	p++
-	if p == pe { goto _test_eof13 }
-	fallthrough
-case 13:
-// line 619 "zparse.go"
-	switch data[p] {
-		case 9: goto tr38
-		case 10: goto tr40
-		case 32: goto tr38
-	}
-	goto tr37
-tr18:
-// line 95 "zparse.rl"
-	{ mark = p }
-	goto st14
-st14:
-	p++
-	if p == pe { goto _test_eof14 }
-	fallthrough
-case 14:
-// line 635 "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 95 "zparse.rl"
-	{ mark = p }
-	goto st19
-st19:
-	p++
-	if p == pe { goto _test_eof19 }
-	fallthrough
-case 19:
-// line 695 "zparse.go"
-	if data[p] == 10 { goto tr50 }
-	goto st19
-tr48:
-// line 95 "zparse.rl"
-	{ mark = p }
-	goto st20
-st20:
-	p++
-	if p == pe { goto _test_eof20 }
-	fallthrough
-case 20:
-// line 707 "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
-tr184:
-// line 99 "zparse.rl"
-	{ ttl := atoi(data[mark:p]); hdr.Ttl = uint32(ttl) }
-	goto st22
-tr51:
-// line 97 "zparse.rl"
-	{ hdr.Class = str_class[data[mark:p]] }
-	goto st22
-st22:
-	p++
-	if p == pe { goto _test_eof22 }
-	fallthrough
-case 22:
-// line 737 "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 st114
-		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 st114
-	}
-	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 95 "zparse.rl"
-	{ mark = p }
-	goto st29
-st29:
-	p++
-	if p == pe { goto _test_eof29 }
-	fallthrough
-case 29:
-// line 833 "zparse.go"
-	if data[p] == 10 { goto tr61 }
-	goto st29
-tr59:
-// line 95 "zparse.rl"
-	{ mark = p }
-	goto st30
-st30:
-	p++
-	if p == pe { goto _test_eof30 }
-	fallthrough
-case 30:
-// line 845 "zparse.go"
-	switch data[p] {
-		case 9: goto tr59
-		case 10: goto tr61
-		case 32: goto tr59
-	}
-	goto tr58
-tr5:
-// line 98 "zparse.rl"
-	{ /* ... */ }
-	goto st31
-st31:
-	p++
-	if p == pe { goto _test_eof31 }
-	fallthrough
-case 31:
-// line 861 "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 95 "zparse.rl"
-	{ mark = p }
-	goto st35
-st35:
-	p++
-	if p == pe { goto _test_eof35 }
-	fallthrough
-case 35:
-// line 911 "zparse.go"
-	if data[p] == 10 { goto tr70 }
-	goto st35
-tr68:
-// line 95 "zparse.rl"
-	{ mark = p }
-	goto st36
-st36:
-	p++
-	if p == pe { goto _test_eof36 }
-	fallthrough
-case 36:
-// line 923 "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 95 "zparse.rl"
-	{ mark = p }
-	goto st42
-st42:
-	p++
-	if p == pe { goto _test_eof42 }
-	fallthrough
-case 42:
-// line 992 "zparse.go"
-	if data[p] == 10 { goto tr79 }
-	goto st42
-tr77:
-// line 95 "zparse.rl"
-	{ mark = p }
-	goto st43
-st43:
-	p++
-	if p == pe { goto _test_eof43 }
-	fallthrough
-case 43:
-// line 1004 "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 95 "zparse.rl"
-	{ mark = p }
-	goto st49
-st49:
-	p++
-	if p == pe { goto _test_eof49 }
-	fallthrough
-case 49:
-// line 1071 "zparse.go"
-	if data[p] == 10 { goto tr87 }
-	goto st49
-tr85:
-// line 95 "zparse.rl"
-	{ mark = p }
-	goto st50
-st50:
-	p++
-	if p == pe { goto _test_eof50 }
-	fallthrough
-case 50:
-// line 1083 "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 95 "zparse.rl"
-	{ mark = p }
-	goto st53
-st53:
-	p++
-	if p == pe { goto _test_eof53 }
-	fallthrough
-case 53:
-// line 1120 "zparse.go"
-	if data[p] == 10 { goto tr92 }
-	goto st53
-tr90:
-// line 95 "zparse.rl"
-	{ mark = p }
-	goto st54
-st54:
-	p++
-	if p == pe { goto _test_eof54 }
-	fallthrough
-case 54:
-// line 1132 "zparse.go"
-	switch data[p] {
-		case 9: goto tr90
-		case 10: goto tr92
-		case 32: goto tr90
-	}
-	goto tr89
-tr8:
-// line 98 "zparse.rl"
-	{ /* ... */ }
-	goto st55
-st55:
-	p++
-	if p == pe { goto _test_eof55 }
-	fallthrough
-case 55:
-// line 1148 "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 95 "zparse.rl"
-	{ mark = p }
-	goto st58
-st58:
-	p++
-	if p == pe { goto _test_eof58 }
-	fallthrough
-case 58:
-// line 1184 "zparse.go"
-	if data[p] == 10 { goto tr98 }
-	goto st58
-tr96:
-// line 95 "zparse.rl"
-	{ mark = p }
-	goto st59
-st59:
-	p++
-	if p == pe { goto _test_eof59 }
-	fallthrough
-case 59:
-// line 1196 "zparse.go"
-	switch data[p] {
-		case 9: goto tr96
-		case 10: goto tr98
-		case 32: goto tr96
-	}
-	goto tr95
-tr9:
-// line 98 "zparse.rl"
-	{ /* ... */ }
-	goto st60
-st60:
-	p++
-	if p == pe { goto _test_eof60 }
-	fallthrough
-case 60:
-// line 1212 "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 95 "zparse.rl"
-	{ mark = p }
-	goto st66
-st66:
-	p++
-	if p == pe { goto _test_eof66 }
-	fallthrough
-case 66:
-// line 1280 "zparse.go"
-	if data[p] == 10 { goto tr108 }
-	goto st66
-tr106:
-// line 95 "zparse.rl"
-	{ mark = p }
-	goto st67
-st67:
-	p++
-	if p == pe { goto _test_eof67 }
-	fallthrough
-case 67:
-// line 1292 "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 95 "zparse.rl"
-	{ mark = p }
-	goto st70
-st70:
-	p++
-	if p == pe { goto _test_eof70 }
-	fallthrough
-case 70:
-// line 1331 "zparse.go"
-	if data[p] == 10 { goto tr114 }
-	goto st70
-tr112:
-// line 95 "zparse.rl"
-	{ mark = p }
-	goto st71
-st71:
-	p++
-	if p == pe { goto _test_eof71 }
-	fallthrough
-case 71:
-// line 1343 "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 95 "zparse.rl"
-	{ mark = p }
-	goto st75
-st75:
-	p++
-	if p == pe { goto _test_eof75 }
-	fallthrough
-case 75:
-// line 1391 "zparse.go"
-	if data[p] == 10 { goto tr121 }
-	goto st75
-tr119:
-// line 95 "zparse.rl"
-	{ mark = p }
-	goto st76
-st76:
-	p++
-	if p == pe { goto _test_eof76 }
-	fallthrough
-case 76:
-// line 1403 "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 95 "zparse.rl"
-	{ mark = p }
-	goto st79
-st79:
-	p++
-	if p == pe { goto _test_eof79 }
-	fallthrough
-case 79:
-// line 1442 "zparse.go"
-	if data[p] == 10 { goto tr127 }
-	goto st79
-tr125:
-// line 95 "zparse.rl"
-	{ mark = p }
-	goto st80
-st80:
-	p++
-	if p == pe { goto _test_eof80 }
-	fallthrough
-case 80:
-// line 1454 "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 95 "zparse.rl"
-	{ mark = p }
-	goto st87
-st87:
-	p++
-	if p == pe { goto _test_eof87 }
-	fallthrough
-case 87:
-// line 1531 "zparse.go"
-	if data[p] == 10 { goto tr136 }
-	goto st87
-tr134:
-// line 95 "zparse.rl"
-	{ mark = p }
-	goto st88
-st88:
-	p++
-	if p == pe { goto _test_eof88 }
-	fallthrough
-case 88:
-// line 1543 "zparse.go"
-	switch data[p] {
-		case 9: goto tr134
-		case 10: goto tr136
-		case 32: goto tr134
-	}
-	goto tr133
-tr10:
-// line 98 "zparse.rl"
-	{ /* ... */ }
-	goto st89
-st89:
-	p++
-	if p == pe { goto _test_eof89 }
-	fallthrough
-case 89:
-// line 1559 "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 95 "zparse.rl"
-	{ mark = p }
-	goto st93
-st93:
-	p++
-	if p == pe { goto _test_eof93 }
-	fallthrough
-case 93:
-// line 1605 "zparse.go"
-	if data[p] == 10 { goto tr143 }
-	goto st93
-tr141:
-// line 95 "zparse.rl"
-	{ mark = p }
-	goto st94
-st94:
-	p++
-	if p == pe { goto _test_eof94 }
-	fallthrough
-case 94:
-// line 1617 "zparse.go"
-	switch data[p] {
-		case 9: goto tr141
-		case 10: goto tr143
-		case 32: goto tr141
-	}
-	goto tr140
-tr11:
-// line 98 "zparse.rl"
-	{ /* ... */ }
-	goto st95
-st95:
-	p++
-	if p == pe { goto _test_eof95 }
-	fallthrough
-case 95:
-// line 1633 "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 95 "zparse.rl"
-	{ mark = p }
-	goto st101
-st101:
-	p++
-	if p == pe { goto _test_eof101 }
-	fallthrough
-case 101:
-// line 1699 "zparse.go"
-	if data[p] == 10 { goto tr152 }
-	goto st101
-tr150:
-// line 95 "zparse.rl"
-	{ mark = p }
-	goto st102
-st102:
-	p++
-	if p == pe { goto _test_eof102 }
-	fallthrough
-case 102:
-// line 1711 "zparse.go"
-	switch data[p] {
-		case 9: goto tr150
-		case 10: goto tr152
-		case 32: goto tr150
-	}
-	goto tr149
-tr12:
-// line 98 "zparse.rl"
-	{ /* ... */ }
-	goto st103
-st103:
-	p++
-	if p == pe { goto _test_eof103 }
-	fallthrough
-case 103:
-// line 1727 "zparse.go"
-	switch data[p] {
-		case 79: goto st104
-		case 82: goto st109
-		case 111: goto st104
-		case 114: goto st109
-	}
-	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 tr158
-		case 10: goto st0
-		case 32: goto tr158
-	}
-	goto tr157
-tr157:
-// line 95 "zparse.rl"
-	{ mark = p }
-	goto st107
-st107:
-	p++
-	if p == pe { goto _test_eof107 }
-	fallthrough
-case 107:
-// line 1775 "zparse.go"
-	if data[p] == 10 { goto tr160 }
-	goto st107
-tr158:
-// line 95 "zparse.rl"
-	{ mark = p }
-	goto st108
-st108:
-	p++
-	if p == pe { goto _test_eof108 }
-	fallthrough
-case 108:
-// line 1787 "zparse.go"
-	switch data[p] {
-		case 9: goto tr158
-		case 10: goto tr160
-		case 32: goto tr158
-	}
-	goto tr157
-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 tr164
-		case 10: goto st0
-		case 32: goto tr164
-	}
-	goto tr163
-tr163:
-// line 95 "zparse.rl"
-	{ mark = p }
-	goto st112
-st112:
-	p++
-	if p == pe { goto _test_eof112 }
-	fallthrough
-case 112:
-// line 1834 "zparse.go"
-	if data[p] == 10 { goto tr166 }
-	goto st112
-tr164:
-// line 95 "zparse.rl"
-	{ mark = p }
-	goto st113
-st113:
-	p++
-	if p == pe { goto _test_eof113 }
-	fallthrough
-case 113:
-// line 1846 "zparse.go"
-	switch data[p] {
-		case 9: goto tr164
-		case 10: goto tr166
-		case 32: goto tr164
-	}
-	goto tr163
-tr13:
-// line 98 "zparse.rl"
-	{ /* ... */ }
-	goto st114
-st114:
-	p++
-	if p == pe { goto _test_eof114 }
-	fallthrough
-case 114:
-// line 1862 "zparse.go"
-	switch data[p] {
-		case 65: goto st115
-		case 88: goto st119
-		case 97: goto st115
-		case 120: goto st119
-	}
-	goto st0
-st115:
-	p++
-	if p == pe { goto _test_eof115 }
-	fallthrough
-case 115:
-	switch data[p] {
-		case 9: goto st116
-		case 32: goto st116
-	}
-	goto st0
-st116:
-	p++
-	if p == pe { goto _test_eof116 }
-	fallthrough
-case 116:
-	switch data[p] {
-		case 9: goto tr171
-		case 10: goto st0
-		case 32: goto tr171
-	}
-	goto tr170
-tr170:
-// line 95 "zparse.rl"
-	{ mark = p }
-	goto st117
-st117:
-	p++
-	if p == pe { goto _test_eof117 }
-	fallthrough
-case 117:
-// line 1900 "zparse.go"
-	if data[p] == 10 { goto tr173 }
-	goto st117
-tr171:
-// line 95 "zparse.rl"
-	{ mark = p }
-	goto st118
-st118:
-	p++
-	if p == pe { goto _test_eof118 }
-	fallthrough
-case 118:
-// line 1912 "zparse.go"
-	switch data[p] {
-		case 9: goto tr171
-		case 10: goto tr173
-		case 32: goto tr171
-	}
-	goto tr170
-st119:
-	p++
-	if p == pe { goto _test_eof119 }
-	fallthrough
-case 119:
-	switch data[p] {
-		case 84: goto st120
-		case 116: goto st120
-	}
-	goto st0
-st120:
-	p++
-	if p == pe { goto _test_eof120 }
-	fallthrough
-case 120:
-	switch data[p] {
-		case 9: goto st121
-		case 32: goto st121
-	}
-	goto st0
-st121:
-	p++
-	if p == pe { goto _test_eof121 }
-	fallthrough
-case 121:
-	switch data[p] {
-		case 9: goto tr177
-		case 10: goto st0
-		case 32: goto tr177
-	}
-	goto tr176
-tr176:
-// line 95 "zparse.rl"
-	{ mark = p }
-	goto st122
-st122:
-	p++
-	if p == pe { goto _test_eof122 }
-	fallthrough
-case 122:
-// line 1959 "zparse.go"
-	if data[p] == 10 { goto tr179 }
-	goto st122
-tr177:
-// line 95 "zparse.rl"
-	{ mark = p }
-	goto st123
-st123:
-	p++
-	if p == pe { goto _test_eof123 }
-	fallthrough
-case 123:
-// line 1971 "zparse.go"
-	switch data[p] {
-		case 9: goto tr177
-		case 10: goto tr179
-		case 32: goto tr177
-	}
-	goto tr176
-tr20:
-// line 95 "zparse.rl"
-	{ mark = p }
-	goto st124
-st124:
-	p++
-	if p == pe { goto _test_eof124 }
-	fallthrough
-case 124:
-// line 1987 "zparse.go"
-	switch data[p] {
-		case 83: goto st21
-		case 115: goto st21
-	}
-	goto st0
-tr21:
-// line 95 "zparse.rl"
-	{ mark = p }
-	goto st125
-st125:
-	p++
-	if p == pe { goto _test_eof125 }
-	fallthrough
-case 125:
-// line 2002 "zparse.go"
-	switch data[p] {
-		case 78: goto st21
-		case 110: goto st21
-	}
-	goto st0
-tr4:
-// line 98 "zparse.rl"
-	{ /* ... */ }
-// line 95 "zparse.rl"
-	{ mark = p }
-	goto st126
-st126:
-	p++
-	if p == pe { goto _test_eof126 }
-	fallthrough
-case 126:
-// line 2019 "zparse.go"
-	switch data[p] {
-		case 69: goto st15
-		case 72: goto st127
-		case 78: goto st24
-		case 101: goto st15
-		case 104: goto st127
-		case 110: goto st24
-	}
-	goto st0
-st127:
-	p++
-	if p == pe { goto _test_eof127 }
-	fallthrough
-case 127:
-	switch data[p] {
-		case 9: goto tr181
-		case 32: goto tr181
-	}
-	goto st0
-tr181:
-// line 97 "zparse.rl"
-	{ hdr.Class = str_class[data[mark:p]] }
-	goto st128
-st128:
-	p++
-	if p == pe { goto _test_eof128 }
-	fallthrough
-case 128:
-// line 2048 "zparse.go"
-	switch data[p] {
-		case 9: goto st128
-		case 32: goto st128
-		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 st114
-		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 st114
-	}
-	if 48 <= data[p] && data[p] <= 57 { goto tr183 }
-	goto st0
-tr183:
-// line 95 "zparse.rl"
-	{ mark = p }
-	goto st129
-st129:
-	p++
-	if p == pe { goto _test_eof129 }
-	fallthrough
-case 129:
-// line 2082 "zparse.go"
-	switch data[p] {
-		case 9: goto tr184
-		case 32: goto tr184
-	}
-	if 48 <= data[p] && data[p] <= 57 { goto st129 }
-	goto st0
-tr6:
-// line 98 "zparse.rl"
-	{ /* ... */ }
-// line 95 "zparse.rl"
-	{ mark = p }
-	goto st130
-st130:
-	p++
-	if p == pe { goto _test_eof130 }
-	fallthrough
-case 130:
-// line 2100 "zparse.go"
-	switch data[p] {
-		case 83: goto st127
-		case 115: goto st127
-	}
-	goto st0
-tr7:
-// line 98 "zparse.rl"
-	{ /* ... */ }
-// line 95 "zparse.rl"
-	{ mark = p }
-	goto st131
-st131:
-	p++
-	if p == pe { goto _test_eof131 }
-	fallthrough
-case 131:
-// line 2117 "zparse.go"
-	switch data[p] {
-		case 78: goto st127
-		case 110: goto st127
-	}
-	goto st0
-tr190:
-// line 95 "zparse.rl"
-	{ mark = p }
-	goto st132
-st132:
-	p++
-	if p == pe { goto _test_eof132 }
-	fallthrough
-case 132:
-// line 2132 "zparse.go"
-	switch data[p] {
-		case 9: goto tr186
-		case 32: goto tr186
-		case 95: goto st132
-	}
-	if data[p] < 48 {
-		if 45 <= data[p] && data[p] <= 46 { goto st132 }
-	} else if data[p] > 57 {
-		if data[p] > 90 {
-			if 97 <= data[p] && data[p] <= 122 { goto st132 }
-		} else if data[p] >= 65 {
+		switch cs {
+		case -666: // i am a hack D:
+		tr33:
+			// line 5 "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])
+				z.Push(rr)
+			}
+			// line 100 "zparse.rl"
+			{
+				lines++
+			}
+			goto st134
+		tr40:
+			// line 14 "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])
+				z.Push(rr)
+			}
+			// line 100 "zparse.rl"
+			{
+				lines++
+			}
+			goto st134
+		tr50:
+			// line 179 "types.rl"
+			{
+			}
+			// line 100 "zparse.rl"
+			{
+				lines++
+			}
+			goto st134
+		tr61:
+			// line 42 "types.rl"
+			{
+				rdf := fields(data[mark:p], 1)
+				rr := new(RR_CNAME)
+				rr.Hdr = hdr
+				rr.Hdr.Rrtype = TypeCNAME
+				rr.Cname = rdf[0]
+				z.Push(rr)
+			}
+			// line 100 "zparse.rl"
+			{
+				lines++
+			}
+			goto st134
+		tr70:
+			// line 78 "types.rl"
+			{
+				rdf := fields(data[mark:p], 4)
+				rr := new(RR_DLV)
+				rr.Hdr = hdr
+				rr.Hdr.Rrtype = TypeDLV
+				rr.KeyTag = uint16(atoi(rdf[0]))
+				rr.Algorithm = uint8(atoi(rdf[1]))
+				rr.DigestType = uint8(atoi(rdf[2]))
+				rr.Digest = rdf[3]
+				z.Push(rr)
+			}
+			// line 100 "zparse.rl"
+			{
+				lines++
+			}
+			goto st134
+		tr79:
+			// line 185 "types.rl"
+			{
+			}
+			// line 100 "zparse.rl"
+			{
+				lines++
+			}
+			goto st134
+		tr87:
+			// line 102 "types.rl"
+			{
+				rdf := fields(data[mark:p], 4)
+				rr := new(RR_DNSKEY)
+				rr.Hdr = hdr
+				rr.Hdr.Rrtype = TypeDNSKEY
+				rr.Flags = uint16(atoi(rdf[0]))
+				rr.Protocol = uint8(atoi(rdf[1]))
+				rr.Algorithm = uint8(atoi(rdf[2]))
+				rr.PublicKey = rdf[3]
+				z.Push(rr)
+			}
+			// line 100 "zparse.rl"
+			{
+				lines++
+			}
+			goto st134
+		tr92:
+			// line 66 "types.rl"
+			{
+				rdf := fields(data[mark:p], 4)
+				rr := new(RR_DS)
+				rr.Hdr = hdr
+				rr.Hdr.Rrtype = TypeDS
+				rr.KeyTag = uint16(atoi(rdf[0]))
+				rr.Algorithm = uint8(atoi(rdf[1]))
+				rr.DigestType = uint8(atoi(rdf[2]))
+				rr.Digest = rdf[3]
+				z.Push(rr)
+			}
+			// line 100 "zparse.rl"
+			{
+				lines++
+			}
+			goto st134
+		tr98:
+			// line 32 "types.rl"
+			{
+				rdf := fields(data[mark:p], 2)
+				rr := new(RR_MX)
+				rr.Hdr = hdr
+				rr.Hdr.Rrtype = TypeMX
+				rr.Pref = uint16(atoi(rdf[0]))
+				rr.Mx = rdf[1]
+				z.Push(rr)
+			}
+			// line 100 "zparse.rl"
+			{
+				lines++
+			}
+			goto st134
+		tr108:
+			// line 188 "types.rl"
+			{
+			}
+			// line 100 "zparse.rl"
+			{
+				lines++
+			}
+			goto st134
+		tr114:
+			// line 23 "types.rl"
+			{
+				rdf := fields(data[mark:p], 1)
+				rr := new(RR_NS)
+				rr.Hdr = hdr
+				rr.Hdr.Rrtype = TypeNS
+				rr.Ns = rdf[0]
+				z.Push(rr)
+			}
+			// line 100 "zparse.rl"
+			{
+				lines++
+			}
+			goto st134
+		tr121:
+			// line 131 "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[rdf[i]]
+				}
+				z.Push(rr)
+			}
+			// line 100 "zparse.rl"
+			{
+				lines++
+			}
+			goto st134
+		tr127:
+			// line 146 "types.rl"
+			{
+				rdf := fields(data[mark:p], 0)
+				rr := new(RR_NSEC3)
+				rr.Hdr = hdr
+				rr.Hdr.Rrtype = TypeNSEC3
+				rr.Hash = uint8(atoi(rdf[0]))
+				rr.Flags = uint8(atoi(rdf[1]))
+				rr.Iterations = uint16(atoi(rdf[2]))
+				rr.SaltLength = uint8(atoi(rdf[3]))
+				rr.Salt = rdf[4]
+				rr.HashLength = uint8(atoi(rdf[4]))
+				rr.NextDomain = rdf[5]
+				rr.TypeBitMap = make([]uint16, len(rdf)-6)
+				// Fill the Type Bit Map
+				for i := 6; i < len(rdf); i++ {
+					// Check if its there in the map TODO
+					rr.TypeBitMap[i-6] = str_rr[rdf[i]]
+				}
+				z.Push(rr)
+			}
+			// line 100 "zparse.rl"
+			{
+				lines++
+			}
+			goto st134
+		tr136:
+			// line 167 "types.rl"
+			{
+			}
+			// line 100 "zparse.rl"
+			{
+				lines++
+			}
+			goto st134
+		tr143:
+			// line 182 "types.rl"
+			{
+			}
+			// line 100 "zparse.rl"
+			{
+				lines++
+			}
+			goto st134
+		tr152:
+			// line 114 "types.rl"
+			{
+				rdf := fields(data[mark:p], 9)
+				rr := new(RR_RRSIG)
+				rr.Hdr = hdr
+				rr.Hdr.Rrtype = TypeRRSIG
+				rr.TypeCovered = uint16(atoi(rdf[0]))
+				rr.Algorithm = uint8(atoi(rdf[1]))
+				rr.Labels = uint8(atoi(rdf[2]))
+				rr.OrigTtl = uint32(atoi(rdf[3]))
+				rr.Expiration = uint32(atoi(rdf[4]))
+				rr.Inception = uint32(atoi(rdf[5]))
+				rr.KeyTag = uint16(atoi(rdf[6]))
+				rr.SignerName = rdf[7]
+				rr.Signature = rdf[9]
+				z.Push(rr)
+			}
+			// line 100 "zparse.rl"
+			{
+				lines++
+			}
+			goto st134
+		tr160:
+			// line 51 "types.rl"
+			{
+				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]
+				rr.Serial = uint32(atoi(rdf[2]))
+				rr.Refresh = uint32(atoi(rdf[3]))
+				rr.Retry = uint32(atoi(rdf[4]))
+				rr.Expire = uint32(atoi(rdf[5]))
+				rr.Minttl = uint32(atoi(rdf[6]))
+				z.Push(rr)
+			}
+			// line 100 "zparse.rl"
+			{
+				lines++
+			}
+			goto st134
+		tr166:
+			// line 176 "types.rl"
+			{
+			}
+			// line 100 "zparse.rl"
+			{
+				lines++
+			}
+			goto st134
+		tr173:
+			// line 90 "types.rl"
+			{
+				rdf := fields(data[mark:p], 4)
+				rr := new(RR_TA)
+				rr.Hdr = hdr
+				rr.Hdr.Rrtype = TypeTA
+				rr.KeyTag = uint16(atoi(rdf[0]))
+				rr.Algorithm = uint8(atoi(rdf[1]))
+				rr.DigestType = uint8(atoi(rdf[2]))
+				rr.Digest = rdf[3]
+				z.Push(rr)
+			}
+			// line 100 "zparse.rl"
+			{
+				lines++
+			}
+			goto st134
+		tr179:
+			// line 173 "types.rl"
+			{
+			}
+			// line 100 "zparse.rl"
+			{
+				lines++
+			}
+			goto st134
+		tr189:
+			// line 100 "zparse.rl"
+			{
+				lines++
+			}
+			goto st134
+		st134:
+			p++
+			if p == pe {
+				goto _test_eof134
+			}
+			fallthrough
+		case 134:
+			// line 385 "zparse.go"
+			switch data[p] {
+			case 9:
+				goto st1
+			case 10:
+				goto tr189
+			case 32:
+				goto st1
+			case 59:
+				goto st133
+			case 95:
+				goto tr190
+			}
+			if data[p] < 48 {
+				if 45 <= data[p] && data[p] <= 46 {
+					goto tr190
+				}
+			} else if data[p] > 57 {
+				if data[p] > 90 {
+					if 97 <= data[p] && data[p] <= 122 {
+						goto tr190
+					}
+				} else if data[p] >= 65 {
+					goto tr190
+				}
+			} else {
+				goto tr190
+			}
+			goto st0
+		st0:
+			cs = 0
+			goto _out
+		tr186:
+			// line 96 "zparse.rl"
+			{
+				hdr.Name = data[mark:p]
+			}
+			goto st1
+		st1:
+			p++
+			if p == pe {
+				goto _test_eof1
+			}
+			fallthrough
+		case 1:
+			// line 417 "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 98 "zparse.rl"
+			{ /* ... */
+			}
+			// line 95 "zparse.rl"
+			{
+				mark = p
+			}
+			goto st2
+		st2:
+			p++
+			if p == pe {
+				goto _test_eof2
+			}
+			fallthrough
+		case 2:
+			// line 457 "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 99 "zparse.rl"
+			{
+				ttl := atoi(data[mark:p])
+				hdr.Ttl = uint32(ttl)
+			}
+			goto st3
+		st3:
+			p++
+			if p == pe {
+				goto _test_eof3
+			}
+			fallthrough
+		case 3:
+			// line 473 "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 st114
+			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 st114
+			}
+			goto st0
+		tr3:
+			// line 98 "zparse.rl"
+			{ /* ... */
+			}
+			goto st4
+		st4:
+			p++
+			if p == pe {
+				goto _test_eof4
+			}
+			fallthrough
+		case 4:
+			// line 510 "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 95 "zparse.rl"
+			{
+				mark = p
+			}
+			goto st6
+		st6:
+			p++
+			if p == pe {
+				goto _test_eof6
+			}
+			fallthrough
+		case 6:
+			// line 538 "zparse.go"
+			if data[p] == 10 {
+				goto tr33
+			}
+			goto st6
+		tr31:
+			// line 95 "zparse.rl"
+			{
+				mark = p
+			}
+			goto st7
+		st7:
+			p++
+			if p == pe {
+				goto _test_eof7
+			}
+			fallthrough
+		case 7:
+			// line 550 "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 95 "zparse.rl"
+			{
+				mark = p
+			}
+			goto st12
+		st12:
+			p++
+			if p == pe {
+				goto _test_eof12
+			}
+			fallthrough
+		case 12:
+			// line 607 "zparse.go"
+			if data[p] == 10 {
+				goto tr40
+			}
+			goto st12
+		tr38:
+			// line 95 "zparse.rl"
+			{
+				mark = p
+			}
+			goto st13
+		st13:
+			p++
+			if p == pe {
+				goto _test_eof13
+			}
+			fallthrough
+		case 13:
+			// line 619 "zparse.go"
+			switch data[p] {
+			case 9:
+				goto tr38
+			case 10:
+				goto tr40
+			case 32:
+				goto tr38
+			}
+			goto tr37
+		tr18:
+			// line 95 "zparse.rl"
+			{
+				mark = p
+			}
+			goto st14
+		st14:
+			p++
+			if p == pe {
+				goto _test_eof14
+			}
+			fallthrough
+		case 14:
+			// line 635 "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 95 "zparse.rl"
+			{
+				mark = p
+			}
+			goto st19
+		st19:
+			p++
+			if p == pe {
+				goto _test_eof19
+			}
+			fallthrough
+		case 19:
+			// line 695 "zparse.go"
+			if data[p] == 10 {
+				goto tr50
+			}
+			goto st19
+		tr48:
+			// line 95 "zparse.rl"
+			{
+				mark = p
+			}
+			goto st20
+		st20:
+			p++
+			if p == pe {
+				goto _test_eof20
+			}
+			fallthrough
+		case 20:
+			// line 707 "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
+		tr184:
+			// line 99 "zparse.rl"
+			{
+				ttl := atoi(data[mark:p])
+				hdr.Ttl = uint32(ttl)
+			}
+			goto st22
+		tr51:
+			// line 97 "zparse.rl"
+			{
+				hdr.Class = str_class[data[mark:p]]
+			}
+			goto st22
+		st22:
+			p++
+			if p == pe {
+				goto _test_eof22
+			}
+			fallthrough
+		case 22:
+			// line 737 "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 st114
+			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 st114
+			}
+			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 95 "zparse.rl"
+			{
+				mark = p
+			}
+			goto st29
+		st29:
+			p++
+			if p == pe {
+				goto _test_eof29
+			}
+			fallthrough
+		case 29:
+			// line 833 "zparse.go"
+			if data[p] == 10 {
+				goto tr61
+			}
+			goto st29
+		tr59:
+			// line 95 "zparse.rl"
+			{
+				mark = p
+			}
+			goto st30
+		st30:
+			p++
+			if p == pe {
+				goto _test_eof30
+			}
+			fallthrough
+		case 30:
+			// line 845 "zparse.go"
+			switch data[p] {
+			case 9:
+				goto tr59
+			case 10:
+				goto tr61
+			case 32:
+				goto tr59
+			}
+			goto tr58
+		tr5:
+			// line 98 "zparse.rl"
+			{ /* ... */
+			}
+			goto st31
+		st31:
+			p++
+			if p == pe {
+				goto _test_eof31
+			}
+			fallthrough
+		case 31:
+			// line 861 "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 95 "zparse.rl"
+			{
+				mark = p
+			}
+			goto st35
+		st35:
+			p++
+			if p == pe {
+				goto _test_eof35
+			}
+			fallthrough
+		case 35:
+			// line 911 "zparse.go"
+			if data[p] == 10 {
+				goto tr70
+			}
+			goto st35
+		tr68:
+			// line 95 "zparse.rl"
+			{
+				mark = p
+			}
+			goto st36
+		st36:
+			p++
+			if p == pe {
+				goto _test_eof36
+			}
+			fallthrough
+		case 36:
+			// line 923 "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 95 "zparse.rl"
+			{
+				mark = p
+			}
+			goto st42
+		st42:
+			p++
+			if p == pe {
+				goto _test_eof42
+			}
+			fallthrough
+		case 42:
+			// line 992 "zparse.go"
+			if data[p] == 10 {
+				goto tr79
+			}
+			goto st42
+		tr77:
+			// line 95 "zparse.rl"
+			{
+				mark = p
+			}
+			goto st43
+		st43:
+			p++
+			if p == pe {
+				goto _test_eof43
+			}
+			fallthrough
+		case 43:
+			// line 1004 "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 95 "zparse.rl"
+			{
+				mark = p
+			}
+			goto st49
+		st49:
+			p++
+			if p == pe {
+				goto _test_eof49
+			}
+			fallthrough
+		case 49:
+			// line 1071 "zparse.go"
+			if data[p] == 10 {
+				goto tr87
+			}
+			goto st49
+		tr85:
+			// line 95 "zparse.rl"
+			{
+				mark = p
+			}
+			goto st50
+		st50:
+			p++
+			if p == pe {
+				goto _test_eof50
+			}
+			fallthrough
+		case 50:
+			// line 1083 "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 95 "zparse.rl"
+			{
+				mark = p
+			}
+			goto st53
+		st53:
+			p++
+			if p == pe {
+				goto _test_eof53
+			}
+			fallthrough
+		case 53:
+			// line 1120 "zparse.go"
+			if data[p] == 10 {
+				goto tr92
+			}
+			goto st53
+		tr90:
+			// line 95 "zparse.rl"
+			{
+				mark = p
+			}
+			goto st54
+		st54:
+			p++
+			if p == pe {
+				goto _test_eof54
+			}
+			fallthrough
+		case 54:
+			// line 1132 "zparse.go"
+			switch data[p] {
+			case 9:
+				goto tr90
+			case 10:
+				goto tr92
+			case 32:
+				goto tr90
+			}
+			goto tr89
+		tr8:
+			// line 98 "zparse.rl"
+			{ /* ... */
+			}
+			goto st55
+		st55:
+			p++
+			if p == pe {
+				goto _test_eof55
+			}
+			fallthrough
+		case 55:
+			// line 1148 "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 95 "zparse.rl"
+			{
+				mark = p
+			}
+			goto st58
+		st58:
+			p++
+			if p == pe {
+				goto _test_eof58
+			}
+			fallthrough
+		case 58:
+			// line 1184 "zparse.go"
+			if data[p] == 10 {
+				goto tr98
+			}
+			goto st58
+		tr96:
+			// line 95 "zparse.rl"
+			{
+				mark = p
+			}
+			goto st59
+		st59:
+			p++
+			if p == pe {
+				goto _test_eof59
+			}
+			fallthrough
+		case 59:
+			// line 1196 "zparse.go"
+			switch data[p] {
+			case 9:
+				goto tr96
+			case 10:
+				goto tr98
+			case 32:
+				goto tr96
+			}
+			goto tr95
+		tr9:
+			// line 98 "zparse.rl"
+			{ /* ... */
+			}
+			goto st60
+		st60:
+			p++
+			if p == pe {
+				goto _test_eof60
+			}
+			fallthrough
+		case 60:
+			// line 1212 "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 95 "zparse.rl"
+			{
+				mark = p
+			}
+			goto st66
+		st66:
+			p++
+			if p == pe {
+				goto _test_eof66
+			}
+			fallthrough
+		case 66:
+			// line 1280 "zparse.go"
+			if data[p] == 10 {
+				goto tr108
+			}
+			goto st66
+		tr106:
+			// line 95 "zparse.rl"
+			{
+				mark = p
+			}
+			goto st67
+		st67:
+			p++
+			if p == pe {
+				goto _test_eof67
+			}
+			fallthrough
+		case 67:
+			// line 1292 "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 95 "zparse.rl"
+			{
+				mark = p
+			}
+			goto st70
+		st70:
+			p++
+			if p == pe {
+				goto _test_eof70
+			}
+			fallthrough
+		case 70:
+			// line 1331 "zparse.go"
+			if data[p] == 10 {
+				goto tr114
+			}
+			goto st70
+		tr112:
+			// line 95 "zparse.rl"
+			{
+				mark = p
+			}
+			goto st71
+		st71:
+			p++
+			if p == pe {
+				goto _test_eof71
+			}
+			fallthrough
+		case 71:
+			// line 1343 "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 95 "zparse.rl"
+			{
+				mark = p
+			}
+			goto st75
+		st75:
+			p++
+			if p == pe {
+				goto _test_eof75
+			}
+			fallthrough
+		case 75:
+			// line 1391 "zparse.go"
+			if data[p] == 10 {
+				goto tr121
+			}
+			goto st75
+		tr119:
+			// line 95 "zparse.rl"
+			{
+				mark = p
+			}
+			goto st76
+		st76:
+			p++
+			if p == pe {
+				goto _test_eof76
+			}
+			fallthrough
+		case 76:
+			// line 1403 "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 95 "zparse.rl"
+			{
+				mark = p
+			}
+			goto st79
+		st79:
+			p++
+			if p == pe {
+				goto _test_eof79
+			}
+			fallthrough
+		case 79:
+			// line 1442 "zparse.go"
+			if data[p] == 10 {
+				goto tr127
+			}
+			goto st79
+		tr125:
+			// line 95 "zparse.rl"
+			{
+				mark = p
+			}
+			goto st80
+		st80:
+			p++
+			if p == pe {
+				goto _test_eof80
+			}
+			fallthrough
+		case 80:
+			// line 1454 "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 95 "zparse.rl"
+			{
+				mark = p
+			}
+			goto st87
+		st87:
+			p++
+			if p == pe {
+				goto _test_eof87
+			}
+			fallthrough
+		case 87:
+			// line 1531 "zparse.go"
+			if data[p] == 10 {
+				goto tr136
+			}
+			goto st87
+		tr134:
+			// line 95 "zparse.rl"
+			{
+				mark = p
+			}
+			goto st88
+		st88:
+			p++
+			if p == pe {
+				goto _test_eof88
+			}
+			fallthrough
+		case 88:
+			// line 1543 "zparse.go"
+			switch data[p] {
+			case 9:
+				goto tr134
+			case 10:
+				goto tr136
+			case 32:
+				goto tr134
+			}
+			goto tr133
+		tr10:
+			// line 98 "zparse.rl"
+			{ /* ... */
+			}
+			goto st89
+		st89:
+			p++
+			if p == pe {
+				goto _test_eof89
+			}
+			fallthrough
+		case 89:
+			// line 1559 "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 95 "zparse.rl"
+			{
+				mark = p
+			}
+			goto st93
+		st93:
+			p++
+			if p == pe {
+				goto _test_eof93
+			}
+			fallthrough
+		case 93:
+			// line 1605 "zparse.go"
+			if data[p] == 10 {
+				goto tr143
+			}
+			goto st93
+		tr141:
+			// line 95 "zparse.rl"
+			{
+				mark = p
+			}
+			goto st94
+		st94:
+			p++
+			if p == pe {
+				goto _test_eof94
+			}
+			fallthrough
+		case 94:
+			// line 1617 "zparse.go"
+			switch data[p] {
+			case 9:
+				goto tr141
+			case 10:
+				goto tr143
+			case 32:
+				goto tr141
+			}
+			goto tr140
+		tr11:
+			// line 98 "zparse.rl"
+			{ /* ... */
+			}
+			goto st95
+		st95:
+			p++
+			if p == pe {
+				goto _test_eof95
+			}
+			fallthrough
+		case 95:
+			// line 1633 "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 95 "zparse.rl"
+			{
+				mark = p
+			}
+			goto st101
+		st101:
+			p++
+			if p == pe {
+				goto _test_eof101
+			}
+			fallthrough
+		case 101:
+			// line 1699 "zparse.go"
+			if data[p] == 10 {
+				goto tr152
+			}
+			goto st101
+		tr150:
+			// line 95 "zparse.rl"
+			{
+				mark = p
+			}
+			goto st102
+		st102:
+			p++
+			if p == pe {
+				goto _test_eof102
+			}
+			fallthrough
+		case 102:
+			// line 1711 "zparse.go"
+			switch data[p] {
+			case 9:
+				goto tr150
+			case 10:
+				goto tr152
+			case 32:
+				goto tr150
+			}
+			goto tr149
+		tr12:
+			// line 98 "zparse.rl"
+			{ /* ... */
+			}
+			goto st103
+		st103:
+			p++
+			if p == pe {
+				goto _test_eof103
+			}
+			fallthrough
+		case 103:
+			// line 1727 "zparse.go"
+			switch data[p] {
+			case 79:
+				goto st104
+			case 82:
+				goto st109
+			case 111:
+				goto st104
+			case 114:
+				goto st109
+			}
+			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 tr158
+			case 10:
+				goto st0
+			case 32:
+				goto tr158
+			}
+			goto tr157
+		tr157:
+			// line 95 "zparse.rl"
+			{
+				mark = p
+			}
+			goto st107
+		st107:
+			p++
+			if p == pe {
+				goto _test_eof107
+			}
+			fallthrough
+		case 107:
+			// line 1775 "zparse.go"
+			if data[p] == 10 {
+				goto tr160
+			}
+			goto st107
+		tr158:
+			// line 95 "zparse.rl"
+			{
+				mark = p
+			}
+			goto st108
+		st108:
+			p++
+			if p == pe {
+				goto _test_eof108
+			}
+			fallthrough
+		case 108:
+			// line 1787 "zparse.go"
+			switch data[p] {
+			case 9:
+				goto tr158
+			case 10:
+				goto tr160
+			case 32:
+				goto tr158
+			}
+			goto tr157
+		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 tr164
+			case 10:
+				goto st0
+			case 32:
+				goto tr164
+			}
+			goto tr163
+		tr163:
+			// line 95 "zparse.rl"
+			{
+				mark = p
+			}
+			goto st112
+		st112:
+			p++
+			if p == pe {
+				goto _test_eof112
+			}
+			fallthrough
+		case 112:
+			// line 1834 "zparse.go"
+			if data[p] == 10 {
+				goto tr166
+			}
+			goto st112
+		tr164:
+			// line 95 "zparse.rl"
+			{
+				mark = p
+			}
+			goto st113
+		st113:
+			p++
+			if p == pe {
+				goto _test_eof113
+			}
+			fallthrough
+		case 113:
+			// line 1846 "zparse.go"
+			switch data[p] {
+			case 9:
+				goto tr164
+			case 10:
+				goto tr166
+			case 32:
+				goto tr164
+			}
+			goto tr163
+		tr13:
+			// line 98 "zparse.rl"
+			{ /* ... */
+			}
+			goto st114
+		st114:
+			p++
+			if p == pe {
+				goto _test_eof114
+			}
+			fallthrough
+		case 114:
+			// line 1862 "zparse.go"
+			switch data[p] {
+			case 65:
+				goto st115
+			case 88:
+				goto st119
+			case 97:
+				goto st115
+			case 120:
+				goto st119
+			}
+			goto st0
+		st115:
+			p++
+			if p == pe {
+				goto _test_eof115
+			}
+			fallthrough
+		case 115:
+			switch data[p] {
+			case 9:
+				goto st116
+			case 32:
+				goto st116
+			}
+			goto st0
+		st116:
+			p++
+			if p == pe {
+				goto _test_eof116
+			}
+			fallthrough
+		case 116:
+			switch data[p] {
+			case 9:
+				goto tr171
+			case 10:
+				goto st0
+			case 32:
+				goto tr171
+			}
+			goto tr170
+		tr170:
+			// line 95 "zparse.rl"
+			{
+				mark = p
+			}
+			goto st117
+		st117:
+			p++
+			if p == pe {
+				goto _test_eof117
+			}
+			fallthrough
+		case 117:
+			// line 1900 "zparse.go"
+			if data[p] == 10 {
+				goto tr173
+			}
+			goto st117
+		tr171:
+			// line 95 "zparse.rl"
+			{
+				mark = p
+			}
+			goto st118
+		st118:
+			p++
+			if p == pe {
+				goto _test_eof118
+			}
+			fallthrough
+		case 118:
+			// line 1912 "zparse.go"
+			switch data[p] {
+			case 9:
+				goto tr171
+			case 10:
+				goto tr173
+			case 32:
+				goto tr171
+			}
+			goto tr170
+		st119:
+			p++
+			if p == pe {
+				goto _test_eof119
+			}
+			fallthrough
+		case 119:
+			switch data[p] {
+			case 84:
+				goto st120
+			case 116:
+				goto st120
+			}
+			goto st0
+		st120:
+			p++
+			if p == pe {
+				goto _test_eof120
+			}
+			fallthrough
+		case 120:
+			switch data[p] {
+			case 9:
+				goto st121
+			case 32:
+				goto st121
+			}
+			goto st0
+		st121:
+			p++
+			if p == pe {
+				goto _test_eof121
+			}
+			fallthrough
+		case 121:
+			switch data[p] {
+			case 9:
+				goto tr177
+			case 10:
+				goto st0
+			case 32:
+				goto tr177
+			}
+			goto tr176
+		tr176:
+			// line 95 "zparse.rl"
+			{
+				mark = p
+			}
+			goto st122
+		st122:
+			p++
+			if p == pe {
+				goto _test_eof122
+			}
+			fallthrough
+		case 122:
+			// line 1959 "zparse.go"
+			if data[p] == 10 {
+				goto tr179
+			}
+			goto st122
+		tr177:
+			// line 95 "zparse.rl"
+			{
+				mark = p
+			}
+			goto st123
+		st123:
+			p++
+			if p == pe {
+				goto _test_eof123
+			}
+			fallthrough
+		case 123:
+			// line 1971 "zparse.go"
+			switch data[p] {
+			case 9:
+				goto tr177
+			case 10:
+				goto tr179
+			case 32:
+				goto tr177
+			}
+			goto tr176
+		tr20:
+			// line 95 "zparse.rl"
+			{
+				mark = p
+			}
+			goto st124
+		st124:
+			p++
+			if p == pe {
+				goto _test_eof124
+			}
+			fallthrough
+		case 124:
+			// line 1987 "zparse.go"
+			switch data[p] {
+			case 83:
+				goto st21
+			case 115:
+				goto st21
+			}
+			goto st0
+		tr21:
+			// line 95 "zparse.rl"
+			{
+				mark = p
+			}
+			goto st125
+		st125:
+			p++
+			if p == pe {
+				goto _test_eof125
+			}
+			fallthrough
+		case 125:
+			// line 2002 "zparse.go"
+			switch data[p] {
+			case 78:
+				goto st21
+			case 110:
+				goto st21
+			}
+			goto st0
+		tr4:
+			// line 98 "zparse.rl"
+			{ /* ... */
+			}
+			// line 95 "zparse.rl"
+			{
+				mark = p
+			}
+			goto st126
+		st126:
+			p++
+			if p == pe {
+				goto _test_eof126
+			}
+			fallthrough
+		case 126:
+			// line 2019 "zparse.go"
+			switch data[p] {
+			case 69:
+				goto st15
+			case 72:
+				goto st127
+			case 78:
+				goto st24
+			case 101:
+				goto st15
+			case 104:
+				goto st127
+			case 110:
+				goto st24
+			}
+			goto st0
+		st127:
+			p++
+			if p == pe {
+				goto _test_eof127
+			}
+			fallthrough
+		case 127:
+			switch data[p] {
+			case 9:
+				goto tr181
+			case 32:
+				goto tr181
+			}
+			goto st0
+		tr181:
+			// line 97 "zparse.rl"
+			{
+				hdr.Class = str_class[data[mark:p]]
+			}
+			goto st128
+		st128:
+			p++
+			if p == pe {
+				goto _test_eof128
+			}
+			fallthrough
+		case 128:
+			// line 2048 "zparse.go"
+			switch data[p] {
+			case 9:
+				goto st128
+			case 32:
+				goto st128
+			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 st114
+			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 st114
+			}
+			if 48 <= data[p] && data[p] <= 57 {
+				goto tr183
+			}
+			goto st0
+		tr183:
+			// line 95 "zparse.rl"
+			{
+				mark = p
+			}
+			goto st129
+		st129:
+			p++
+			if p == pe {
+				goto _test_eof129
+			}
+			fallthrough
+		case 129:
+			// line 2082 "zparse.go"
+			switch data[p] {
+			case 9:
+				goto tr184
+			case 32:
+				goto tr184
+			}
+			if 48 <= data[p] && data[p] <= 57 {
+				goto st129
+			}
+			goto st0
+		tr6:
+			// line 98 "zparse.rl"
+			{ /* ... */
+			}
+			// line 95 "zparse.rl"
+			{
+				mark = p
+			}
+			goto st130
+		st130:
+			p++
+			if p == pe {
+				goto _test_eof130
+			}
+			fallthrough
+		case 130:
+			// line 2100 "zparse.go"
+			switch data[p] {
+			case 83:
+				goto st127
+			case 115:
+				goto st127
+			}
+			goto st0
+		tr7:
+			// line 98 "zparse.rl"
+			{ /* ... */
+			}
+			// line 95 "zparse.rl"
+			{
+				mark = p
+			}
+			goto st131
+		st131:
+			p++
+			if p == pe {
+				goto _test_eof131
+			}
+			fallthrough
+		case 131:
+			// line 2117 "zparse.go"
+			switch data[p] {
+			case 78:
+				goto st127
+			case 110:
+				goto st127
+			}
+			goto st0
+		tr190:
+			// line 95 "zparse.rl"
+			{
+				mark = p
+			}
 			goto st132
+		st132:
+			p++
+			if p == pe {
+				goto _test_eof132
+			}
+			fallthrough
+		case 132:
+			// line 2132 "zparse.go"
+			switch data[p] {
+			case 9:
+				goto tr186
+			case 32:
+				goto tr186
+			case 95:
+				goto st132
+			}
+			if data[p] < 48 {
+				if 45 <= data[p] && data[p] <= 46 {
+					goto st132
+				}
+			} else if data[p] > 57 {
+				if data[p] > 90 {
+					if 97 <= data[p] && data[p] <= 122 {
+						goto st132
+					}
+				} else if data[p] >= 65 {
+					goto st132
+				}
+			} else {
+				goto st132
+			}
+			goto st0
+		st133:
+			p++
+			if p == pe {
+				goto _test_eof133
+			}
+			fallthrough
+		case 133:
+			if data[p] == 10 {
+				goto tr189
+			}
+			goto st133
 		}
-	} else {
-		goto st132
-	}
-	goto st0
-st133:
-	p++
-	if p == pe { goto _test_eof133 }
-	fallthrough
-case 133:
-	if data[p] == 10 { goto tr189 }
-	goto st133
-	}
-	_test_eof134: cs = 134; 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_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_eof: {}
-	_out: {}
+	_test_eof:
+		{
+		}
+	_out:
+		{
+		}
 	}
 
-// line 156 "zparse.rl"
+	// line 156 "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 ", lines)
-                                return z, nil
-                        } else {
-                                println("error at position ", p, "\"",data[mark:p],"\" at line ", lines)
-                                return z, nil
-                        }
-                }
-        }
-        return z, nil
+
+	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 ", lines)
+				return z, nil
+			} else {
+				println("error at position ", p, "\"", data[mark:p], "\" at line ", lines)
+				return z, nil
+			}
+		}
+	}
+	return z, nil
 }