From 762ba1e59963572e73af1c5707d600aba0f644d1 Mon Sep 17 00:00:00 2001
From: Alex Bramley <a.bramley@gmail.com>
Date: Tue, 22 Feb 2011 21:26:48 +0000
Subject: [PATCH] Type inference proves too costly for ragel-based config...

On the one hand, the complex ragel solution is explicit about the config syntax
and requires little heavy lifting on the Go side, but the ragel definition is
overly complex, too rigid and produces bloody huge binary output. On the other
the simple ragel solution can provide pretty much the same syntax with some
type conversion, but the reflection magic to pack this into objects correctly
is done much better by the JSON module. Forcing parsing of everything tostrings
results in lots of nasty if/case statements in the Go code.

JSON has another benefit in that the config serialisation is two-way, allowing
for web or IRC based configuration. It's a pity it's a bugger to edit by hand.
---
 server/config/parser.go | 7627 ---------------------------------------
 server/config/parser.rl |  241 --
 2 files changed, 7868 deletions(-)
 delete mode 100644 server/config/parser.go
 delete mode 100644 server/config/parser.rl

diff --git a/server/config/parser.go b/server/config/parser.go
deleted file mode 100644
index 40530de..0000000
--- a/server/config/parser.go
+++ /dev/null
@@ -1,7627 +0,0 @@
-
-// line 1 "parser.rl"
-package config
-
-import (
-	"io"
-	"os"
-	"fmt"
-	"net"
-	"strconv"
-)
-
-
-// line 12 "parser.rl"
-
-// line 17 "parser.go"
-var config_start int = 1
-var config_first_final int = 560
-var config_error int = 0
-
-var config_en_main int = 1
-
-
-// line 13 "parser.rl"
-
-// some helpers
-var booleans = map[string]bool {
-	"true": true,
-	"yes": true,
-	"on": true,
-	"1": true,
-	"false": false,
-	"no": false,
-	"off": false,
-	"0": false,
-}
-
-func getbool(val []byte) bool {
-	return booleans[string(val)]
-}
-
-func getint(val []byte) int {
-	if v, err := strconv.Atoi(string(val)); err == nil {
-		return v
-	}
-	return 0
-}
-
-
-// line 208 "parser.rl"
-
-
-func (conf *Config) Parse(r io.Reader) {
-	cs, p, mark, pe, eof, buflen := 0, 0, 0, 0, 0, 16384
-	done := false
-	var cur interface{}
-	data := make([]byte, buflen)
-
-	
-// line 61 "parser.go"
-	cs = config_start
-
-// line 217 "parser.rl"
-
-	for !done {
-		n, err := r.Read(data)
-		pe = p + n
-		if err == os.EOF {
-			fmt.Println("yeahhhhh.")
-			done = true
-			eof = pe
-		}
-
-		
-// line 76 "parser.go"
-	{
-	if p == pe { goto _test_eof }
-	switch cs {
-	case -666: // i am a hack D:
-	fallthrough
-case 1:
-	switch data[p] {
-		case 32: goto st2
-		case 111: goto tr2
-		case 112: goto tr3
-	}
-	if 9 <= data[p] && data[p] <= 13 { goto st2 }
-	goto st0
-st0:
-cs = 0;
-	goto _out;
-st2:
-	p++
-	if p == pe { goto _test_eof2 }
-	fallthrough
-case 2:
-	switch data[p] {
-		case 32: goto st2
-		case 112: goto tr3
-	}
-	if 9 <= data[p] && data[p] <= 13 { goto st2 }
-	goto st0
-tr3:
-// line 77 "parser.rl"
-	{ cur = defaultPort() }
-	goto st3
-tr633:
-// line 78 "parser.rl"
-	{
-		port := cur.(*cPort)
-		conf.Ports[port.Port] = port
-		cur = nil
-	}
-// line 77 "parser.rl"
-	{ cur = defaultPort() }
-	goto st3
-tr637:
-// line 134 "parser.rl"
-	{
-		oper := cur.(*cOper)
-		conf.Opers[oper.Username] = oper
-		cur = nil
-	}
-// line 77 "parser.rl"
-	{ cur = defaultPort() }
-	goto st3
-st3:
-	p++
-	if p == pe { goto _test_eof3 }
-	fallthrough
-case 3:
-// line 133 "parser.go"
-	if data[p] == 111 { goto st4 }
-	goto st0
-st4:
-	p++
-	if p == pe { goto _test_eof4 }
-	fallthrough
-case 4:
-	if data[p] == 114 { goto st5 }
-	goto st0
-st5:
-	p++
-	if p == pe { goto _test_eof5 }
-	fallthrough
-case 5:
-	if data[p] == 116 { goto st6 }
-	goto st0
-st6:
-	p++
-	if p == pe { goto _test_eof6 }
-	fallthrough
-case 6:
-	if data[p] == 32 { goto st7 }
-	goto st0
-st7:
-	p++
-	if p == pe { goto _test_eof7 }
-	fallthrough
-case 7:
-	if data[p] == 32 { goto st7 }
-	if 48 <= data[p] && data[p] <= 57 { goto tr8 }
-	goto st0
-tr8:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st8
-st8:
-	p++
-	if p == pe { goto _test_eof8 }
-	fallthrough
-case 8:
-// line 174 "parser.go"
-	switch data[p] {
-		case 10: goto tr9
-		case 32: goto tr10
-	}
-	if 48 <= data[p] && data[p] <= 57 { goto st8 }
-	goto st0
-tr9:
-// line 85 "parser.rl"
-	{
-		cur.(*cPort).Port = getint(data[mark:p])
-	}
-	goto st560
-tr323:
-// line 91 "parser.rl"
-	{
-		cur.(*cPort).BindIP = net.ParseIP(string(data[mark:p]))
-	}
-	goto st560
-tr584:
-// line 98 "parser.rl"
-	{
-		cur.(*cPort).Class = string(data[mark:p])
-	}
-	goto st560
-tr602:
-// line 105 "parser.rl"
-	{
-		cur.(*cPort).SSL = getbool(data[mark:p])
-	}
-	goto st560
-tr623:
-// line 111 "parser.rl"
-	{
-		cur.(*cPort).Zip = getbool(data[mark:p])
-	}
-	goto st560
-st560:
-	p++
-	if p == pe { goto _test_eof560 }
-	fallthrough
-case 560:
-// line 216 "parser.go"
-	switch data[p] {
-		case 32: goto tr631
-		case 111: goto tr632
-		case 112: goto tr633
-	}
-	if 9 <= data[p] && data[p] <= 13 { goto tr631 }
-	goto st0
-tr631:
-// line 78 "parser.rl"
-	{
-		port := cur.(*cPort)
-		conf.Ports[port.Port] = port
-		cur = nil
-	}
-	goto st561
-tr635:
-// line 134 "parser.rl"
-	{
-		oper := cur.(*cOper)
-		conf.Opers[oper.Username] = oper
-		cur = nil
-	}
-	goto st561
-st561:
-	p++
-	if p == pe { goto _test_eof561 }
-	fallthrough
-case 561:
-// line 245 "parser.go"
-	switch data[p] {
-		case 32: goto st561
-		case 111: goto tr2
-		case 112: goto tr3
-	}
-	if 9 <= data[p] && data[p] <= 13 { goto st561 }
-	goto st0
-tr2:
-// line 133 "parser.rl"
-	{ cur = defaultOper() }
-	goto st9
-tr632:
-// line 78 "parser.rl"
-	{
-		port := cur.(*cPort)
-		conf.Ports[port.Port] = port
-		cur = nil
-	}
-// line 133 "parser.rl"
-	{ cur = defaultOper() }
-	goto st9
-tr636:
-// line 134 "parser.rl"
-	{
-		oper := cur.(*cOper)
-		conf.Opers[oper.Username] = oper
-		cur = nil
-	}
-// line 133 "parser.rl"
-	{ cur = defaultOper() }
-	goto st9
-st9:
-	p++
-	if p == pe { goto _test_eof9 }
-	fallthrough
-case 9:
-// line 282 "parser.go"
-	if data[p] == 112 { goto st10 }
-	goto st0
-st10:
-	p++
-	if p == pe { goto _test_eof10 }
-	fallthrough
-case 10:
-	if data[p] == 101 { goto st11 }
-	goto st0
-st11:
-	p++
-	if p == pe { goto _test_eof11 }
-	fallthrough
-case 11:
-	if data[p] == 114 { goto st12 }
-	goto st0
-st12:
-	p++
-	if p == pe { goto _test_eof12 }
-	fallthrough
-case 12:
-	if data[p] == 32 { goto st13 }
-	goto st0
-st13:
-	p++
-	if p == pe { goto _test_eof13 }
-	fallthrough
-case 13:
-	if data[p] == 32 { goto st13 }
-	if data[p] > 90 {
-		if 97 <= data[p] && data[p] <= 122 { goto tr16 }
-	} else if data[p] >= 65 {
-		goto tr16
-	}
-	goto st0
-tr16:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st14
-st14:
-	p++
-	if p == pe { goto _test_eof14 }
-	fallthrough
-case 14:
-// line 327 "parser.go"
-	if data[p] == 32 { goto tr17 }
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st14 }
-	} else if data[p] > 90 {
-		if 97 <= data[p] && data[p] <= 122 { goto st14 }
-	} else {
-		goto st14
-	}
-	goto st0
-tr17:
-// line 141 "parser.rl"
-	{
-		cur.(*cOper).Username = string(data[mark:p])
-	}
-	goto st15
-st15:
-	p++
-	if p == pe { goto _test_eof15 }
-	fallthrough
-case 15:
-// line 348 "parser.go"
-	switch data[p] {
-		case 32: goto st15
-		case 123: goto st16
-	}
-	goto st0
-st16:
-	p++
-	if p == pe { goto _test_eof16 }
-	fallthrough
-case 16:
-	switch data[p] {
-		case 32: goto st16
-		case 98: goto st17
-		case 104: goto st142
-		case 107: goto st156
-		case 108: goto st175
-		case 112: goto st194
-		case 114: goto st217
-	}
-	if 9 <= data[p] && data[p] <= 13 { goto st16 }
-	goto st0
-st17:
-	p++
-	if p == pe { goto _test_eof17 }
-	fallthrough
-case 17:
-	if data[p] == 97 { goto st18 }
-	goto st0
-st18:
-	p++
-	if p == pe { goto _test_eof18 }
-	fallthrough
-case 18:
-	if data[p] == 110 { goto st19 }
-	goto st0
-st19:
-	p++
-	if p == pe { goto _test_eof19 }
-	fallthrough
-case 19:
-	if data[p] == 32 { goto st20 }
-	goto st0
-st20:
-	p++
-	if p == pe { goto _test_eof20 }
-	fallthrough
-case 20:
-	switch data[p] {
-		case 32: goto st20
-		case 61: goto st21
-	}
-	goto st0
-st21:
-	p++
-	if p == pe { goto _test_eof21 }
-	fallthrough
-case 21:
-	if data[p] == 32 { goto st22 }
-	goto st0
-st22:
-	p++
-	if p == pe { goto _test_eof22 }
-	fallthrough
-case 22:
-	switch data[p] {
-		case 32: goto st22
-		case 102: goto tr33
-		case 110: goto tr34
-		case 111: goto tr35
-		case 116: goto tr36
-		case 121: goto tr37
-	}
-	if 48 <= data[p] && data[p] <= 49 { goto tr32 }
-	goto st0
-tr32:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st23
-st23:
-	p++
-	if p == pe { goto _test_eof23 }
-	fallthrough
-case 23:
-// line 432 "parser.go"
-	switch data[p] {
-		case 10: goto tr39
-		case 32: goto tr40
-		case 125: goto tr41
-	}
-	if 9 <= data[p] && data[p] <= 13 { goto tr38 }
-	goto st0
-tr38:
-// line 168 "parser.rl"
-	{
-		cur.(*cOper).CanBan = getbool(data[mark:p])
-	}
-	goto st24
-tr188:
-// line 154 "parser.rl"
-	{
-		cur.(*cOper).HostMask = append(
-			cur.(*cOper).HostMask, string(data[mark:p]))
-	}
-	goto st24
-tr203:
-// line 162 "parser.rl"
-	{
-		cur.(*cOper).CanKill = getbool(data[mark:p])
-	}
-	goto st24
-tr225:
-// line 180 "parser.rl"
-	{
-		cur.(*cOper).CanLink = getbool(data[mark:p])
-	}
-	goto st24
-tr246:
-// line 147 "parser.rl"
-	{
-		cur.(*cOper).Password = string(data[mark:p])
-	}
-	goto st24
-tr274:
-// line 174 "parser.rl"
-	{
-		cur.(*cOper).CanRenick = getbool(data[mark:p])
-	}
-	goto st24
-st24:
-	p++
-	if p == pe { goto _test_eof24 }
-	fallthrough
-case 24:
-// line 482 "parser.go"
-	switch data[p] {
-		case 32: goto st24
-		case 125: goto st562
-	}
-	if 9 <= data[p] && data[p] <= 13 { goto st24 }
-	goto st0
-tr41:
-// line 168 "parser.rl"
-	{
-		cur.(*cOper).CanBan = getbool(data[mark:p])
-	}
-	goto st562
-tr190:
-// line 154 "parser.rl"
-	{
-		cur.(*cOper).HostMask = append(
-			cur.(*cOper).HostMask, string(data[mark:p]))
-	}
-	goto st562
-tr205:
-// line 162 "parser.rl"
-	{
-		cur.(*cOper).CanKill = getbool(data[mark:p])
-	}
-	goto st562
-tr227:
-// line 180 "parser.rl"
-	{
-		cur.(*cOper).CanLink = getbool(data[mark:p])
-	}
-	goto st562
-tr276:
-// line 174 "parser.rl"
-	{
-		cur.(*cOper).CanRenick = getbool(data[mark:p])
-	}
-	goto st562
-st562:
-	p++
-	if p == pe { goto _test_eof562 }
-	fallthrough
-case 562:
-// line 525 "parser.go"
-	switch data[p] {
-		case 32: goto tr635
-		case 111: goto tr636
-		case 112: goto tr637
-	}
-	if 9 <= data[p] && data[p] <= 13 { goto tr635 }
-	goto st0
-tr39:
-// line 168 "parser.rl"
-	{
-		cur.(*cOper).CanBan = getbool(data[mark:p])
-	}
-	goto st25
-tr85:
-// line 154 "parser.rl"
-	{
-		cur.(*cOper).HostMask = append(
-			cur.(*cOper).HostMask, string(data[mark:p]))
-	}
-	goto st25
-tr99:
-// line 162 "parser.rl"
-	{
-		cur.(*cOper).CanKill = getbool(data[mark:p])
-	}
-	goto st25
-tr120:
-// line 180 "parser.rl"
-	{
-		cur.(*cOper).CanLink = getbool(data[mark:p])
-	}
-	goto st25
-tr140:
-// line 147 "parser.rl"
-	{
-		cur.(*cOper).Password = string(data[mark:p])
-	}
-	goto st25
-tr157:
-// line 174 "parser.rl"
-	{
-		cur.(*cOper).CanRenick = getbool(data[mark:p])
-	}
-	goto st25
-st25:
-	p++
-	if p == pe { goto _test_eof25 }
-	fallthrough
-case 25:
-// line 575 "parser.go"
-	switch data[p] {
-		case 32: goto st25
-		case 98: goto st26
-		case 104: goto st45
-		case 107: goto st59
-		case 108: goto st78
-		case 112: goto st97
-		case 114: goto st109
-		case 125: goto st562
-	}
-	if 9 <= data[p] && data[p] <= 13 { goto st25 }
-	goto st0
-st26:
-	p++
-	if p == pe { goto _test_eof26 }
-	fallthrough
-case 26:
-	if data[p] == 97 { goto st27 }
-	goto st0
-st27:
-	p++
-	if p == pe { goto _test_eof27 }
-	fallthrough
-case 27:
-	if data[p] == 110 { goto st28 }
-	goto st0
-st28:
-	p++
-	if p == pe { goto _test_eof28 }
-	fallthrough
-case 28:
-	if data[p] == 32 { goto st29 }
-	goto st0
-st29:
-	p++
-	if p == pe { goto _test_eof29 }
-	fallthrough
-case 29:
-	switch data[p] {
-		case 32: goto st29
-		case 61: goto st30
-	}
-	goto st0
-st30:
-	p++
-	if p == pe { goto _test_eof30 }
-	fallthrough
-case 30:
-	if data[p] == 32 { goto st31 }
-	goto st0
-st31:
-	p++
-	if p == pe { goto _test_eof31 }
-	fallthrough
-case 31:
-	switch data[p] {
-		case 32: goto st31
-		case 102: goto tr57
-		case 110: goto tr58
-		case 111: goto tr59
-		case 116: goto tr60
-		case 121: goto tr61
-	}
-	if 48 <= data[p] && data[p] <= 49 { goto tr56 }
-	goto st0
-tr56:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st32
-st32:
-	p++
-	if p == pe { goto _test_eof32 }
-	fallthrough
-case 32:
-// line 650 "parser.go"
-	switch data[p] {
-		case 10: goto tr39
-		case 32: goto tr62
-	}
-	goto st0
-tr62:
-// line 168 "parser.rl"
-	{
-		cur.(*cOper).CanBan = getbool(data[mark:p])
-	}
-	goto st33
-tr86:
-// line 154 "parser.rl"
-	{
-		cur.(*cOper).HostMask = append(
-			cur.(*cOper).HostMask, string(data[mark:p]))
-	}
-	goto st33
-tr100:
-// line 162 "parser.rl"
-	{
-		cur.(*cOper).CanKill = getbool(data[mark:p])
-	}
-	goto st33
-tr121:
-// line 180 "parser.rl"
-	{
-		cur.(*cOper).CanLink = getbool(data[mark:p])
-	}
-	goto st33
-tr141:
-// line 147 "parser.rl"
-	{
-		cur.(*cOper).Password = string(data[mark:p])
-	}
-	goto st33
-tr158:
-// line 174 "parser.rl"
-	{
-		cur.(*cOper).CanRenick = getbool(data[mark:p])
-	}
-	goto st33
-st33:
-	p++
-	if p == pe { goto _test_eof33 }
-	fallthrough
-case 33:
-// line 698 "parser.go"
-	switch data[p] {
-		case 10: goto st25
-		case 32: goto st33
-	}
-	goto st0
-tr57:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st34
-st34:
-	p++
-	if p == pe { goto _test_eof34 }
-	fallthrough
-case 34:
-// line 713 "parser.go"
-	if data[p] == 97 { goto st35 }
-	goto st0
-st35:
-	p++
-	if p == pe { goto _test_eof35 }
-	fallthrough
-case 35:
-	if data[p] == 108 { goto st36 }
-	goto st0
-st36:
-	p++
-	if p == pe { goto _test_eof36 }
-	fallthrough
-case 36:
-	if data[p] == 115 { goto st37 }
-	goto st0
-st37:
-	p++
-	if p == pe { goto _test_eof37 }
-	fallthrough
-case 37:
-	if data[p] == 101 { goto st32 }
-	goto st0
-tr58:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st38
-st38:
-	p++
-	if p == pe { goto _test_eof38 }
-	fallthrough
-case 38:
-// line 746 "parser.go"
-	if data[p] == 111 { goto st32 }
-	goto st0
-tr59:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st39
-st39:
-	p++
-	if p == pe { goto _test_eof39 }
-	fallthrough
-case 39:
-// line 758 "parser.go"
-	switch data[p] {
-		case 102: goto st40
-		case 110: goto st32
-	}
-	goto st0
-st40:
-	p++
-	if p == pe { goto _test_eof40 }
-	fallthrough
-case 40:
-	if data[p] == 102 { goto st32 }
-	goto st0
-tr60:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st41
-st41:
-	p++
-	if p == pe { goto _test_eof41 }
-	fallthrough
-case 41:
-// line 780 "parser.go"
-	if data[p] == 114 { goto st42 }
-	goto st0
-st42:
-	p++
-	if p == pe { goto _test_eof42 }
-	fallthrough
-case 42:
-	if data[p] == 117 { goto st37 }
-	goto st0
-tr61:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st43
-st43:
-	p++
-	if p == pe { goto _test_eof43 }
-	fallthrough
-case 43:
-// line 799 "parser.go"
-	if data[p] == 101 { goto st44 }
-	goto st0
-st44:
-	p++
-	if p == pe { goto _test_eof44 }
-	fallthrough
-case 44:
-	if data[p] == 115 { goto st32 }
-	goto st0
-st45:
-	p++
-	if p == pe { goto _test_eof45 }
-	fallthrough
-case 45:
-	if data[p] == 111 { goto st46 }
-	goto st0
-st46:
-	p++
-	if p == pe { goto _test_eof46 }
-	fallthrough
-case 46:
-	if data[p] == 115 { goto st47 }
-	goto st0
-st47:
-	p++
-	if p == pe { goto _test_eof47 }
-	fallthrough
-case 47:
-	if data[p] == 116 { goto st48 }
-	goto st0
-st48:
-	p++
-	if p == pe { goto _test_eof48 }
-	fallthrough
-case 48:
-	if data[p] == 109 { goto st49 }
-	goto st0
-st49:
-	p++
-	if p == pe { goto _test_eof49 }
-	fallthrough
-case 49:
-	if data[p] == 97 { goto st50 }
-	goto st0
-st50:
-	p++
-	if p == pe { goto _test_eof50 }
-	fallthrough
-case 50:
-	if data[p] == 115 { goto st51 }
-	goto st0
-st51:
-	p++
-	if p == pe { goto _test_eof51 }
-	fallthrough
-case 51:
-	if data[p] == 107 { goto st52 }
-	goto st0
-st52:
-	p++
-	if p == pe { goto _test_eof52 }
-	fallthrough
-case 52:
-	if data[p] == 32 { goto st53 }
-	goto st0
-st53:
-	p++
-	if p == pe { goto _test_eof53 }
-	fallthrough
-case 53:
-	switch data[p] {
-		case 32: goto st53
-		case 61: goto st54
-	}
-	goto st0
-st54:
-	p++
-	if p == pe { goto _test_eof54 }
-	fallthrough
-case 54:
-	if data[p] == 32 { goto st55 }
-	goto st0
-st55:
-	p++
-	if p == pe { goto _test_eof55 }
-	fallthrough
-case 55:
-	switch data[p] {
-		case 32: goto st55
-		case 42: goto tr81
-		case 46: goto tr81
-		case 63: goto tr81
-	}
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto tr81 }
-	} else if data[p] > 90 {
-		if 97 <= data[p] && data[p] <= 122 { goto tr81 }
-	} else {
-		goto tr81
-	}
-	goto st0
-tr81:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st56
-st56:
-	p++
-	if p == pe { goto _test_eof56 }
-	fallthrough
-case 56:
-// line 910 "parser.go"
-	switch data[p] {
-		case 42: goto st56
-		case 46: goto st56
-		case 64: goto st57
-	}
-	if data[p] < 63 {
-		if 48 <= data[p] && data[p] <= 57 { goto st56 }
-	} else if data[p] > 90 {
-		if 97 <= data[p] && data[p] <= 122 { goto st56 }
-	} else {
-		goto st56
-	}
-	goto st0
-st57:
-	p++
-	if p == pe { goto _test_eof57 }
-	fallthrough
-case 57:
-	switch data[p] {
-		case 42: goto st58
-		case 46: goto st58
-		case 63: goto st58
-	}
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st58 }
-	} else if data[p] > 90 {
-		if 97 <= data[p] && data[p] <= 122 { goto st58 }
-	} else {
-		goto st58
-	}
-	goto st0
-st58:
-	p++
-	if p == pe { goto _test_eof58 }
-	fallthrough
-case 58:
-	switch data[p] {
-		case 10: goto tr85
-		case 32: goto tr86
-		case 42: goto st58
-		case 46: goto st58
-		case 63: goto st58
-	}
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st58 }
-	} else if data[p] > 90 {
-		if 97 <= data[p] && data[p] <= 122 { goto st58 }
-	} else {
-		goto st58
-	}
-	goto st0
-st59:
-	p++
-	if p == pe { goto _test_eof59 }
-	fallthrough
-case 59:
-	if data[p] == 105 { goto st60 }
-	goto st0
-st60:
-	p++
-	if p == pe { goto _test_eof60 }
-	fallthrough
-case 60:
-	if data[p] == 108 { goto st61 }
-	goto st0
-st61:
-	p++
-	if p == pe { goto _test_eof61 }
-	fallthrough
-case 61:
-	if data[p] == 108 { goto st62 }
-	goto st0
-st62:
-	p++
-	if p == pe { goto _test_eof62 }
-	fallthrough
-case 62:
-	if data[p] == 32 { goto st63 }
-	goto st0
-st63:
-	p++
-	if p == pe { goto _test_eof63 }
-	fallthrough
-case 63:
-	switch data[p] {
-		case 32: goto st63
-		case 61: goto st64
-	}
-	goto st0
-st64:
-	p++
-	if p == pe { goto _test_eof64 }
-	fallthrough
-case 64:
-	if data[p] == 32 { goto st65 }
-	goto st0
-st65:
-	p++
-	if p == pe { goto _test_eof65 }
-	fallthrough
-case 65:
-	switch data[p] {
-		case 32: goto st65
-		case 102: goto tr94
-		case 110: goto tr95
-		case 111: goto tr96
-		case 116: goto tr97
-		case 121: goto tr98
-	}
-	if 48 <= data[p] && data[p] <= 49 { goto tr93 }
-	goto st0
-tr93:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st66
-st66:
-	p++
-	if p == pe { goto _test_eof66 }
-	fallthrough
-case 66:
-// line 1031 "parser.go"
-	switch data[p] {
-		case 10: goto tr99
-		case 32: goto tr100
-	}
-	goto st0
-tr94:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st67
-st67:
-	p++
-	if p == pe { goto _test_eof67 }
-	fallthrough
-case 67:
-// line 1046 "parser.go"
-	if data[p] == 97 { goto st68 }
-	goto st0
-st68:
-	p++
-	if p == pe { goto _test_eof68 }
-	fallthrough
-case 68:
-	if data[p] == 108 { goto st69 }
-	goto st0
-st69:
-	p++
-	if p == pe { goto _test_eof69 }
-	fallthrough
-case 69:
-	if data[p] == 115 { goto st70 }
-	goto st0
-st70:
-	p++
-	if p == pe { goto _test_eof70 }
-	fallthrough
-case 70:
-	if data[p] == 101 { goto st66 }
-	goto st0
-tr95:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st71
-st71:
-	p++
-	if p == pe { goto _test_eof71 }
-	fallthrough
-case 71:
-// line 1079 "parser.go"
-	if data[p] == 111 { goto st66 }
-	goto st0
-tr96:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st72
-st72:
-	p++
-	if p == pe { goto _test_eof72 }
-	fallthrough
-case 72:
-// line 1091 "parser.go"
-	switch data[p] {
-		case 102: goto st73
-		case 110: goto st66
-	}
-	goto st0
-st73:
-	p++
-	if p == pe { goto _test_eof73 }
-	fallthrough
-case 73:
-	if data[p] == 102 { goto st66 }
-	goto st0
-tr97:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st74
-st74:
-	p++
-	if p == pe { goto _test_eof74 }
-	fallthrough
-case 74:
-// line 1113 "parser.go"
-	if data[p] == 114 { goto st75 }
-	goto st0
-st75:
-	p++
-	if p == pe { goto _test_eof75 }
-	fallthrough
-case 75:
-	if data[p] == 117 { goto st70 }
-	goto st0
-tr98:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st76
-st76:
-	p++
-	if p == pe { goto _test_eof76 }
-	fallthrough
-case 76:
-// line 1132 "parser.go"
-	if data[p] == 101 { goto st77 }
-	goto st0
-st77:
-	p++
-	if p == pe { goto _test_eof77 }
-	fallthrough
-case 77:
-	if data[p] == 115 { goto st66 }
-	goto st0
-st78:
-	p++
-	if p == pe { goto _test_eof78 }
-	fallthrough
-case 78:
-	if data[p] == 105 { goto st79 }
-	goto st0
-st79:
-	p++
-	if p == pe { goto _test_eof79 }
-	fallthrough
-case 79:
-	if data[p] == 110 { goto st80 }
-	goto st0
-st80:
-	p++
-	if p == pe { goto _test_eof80 }
-	fallthrough
-case 80:
-	if data[p] == 107 { goto st81 }
-	goto st0
-st81:
-	p++
-	if p == pe { goto _test_eof81 }
-	fallthrough
-case 81:
-	if data[p] == 32 { goto st82 }
-	goto st0
-st82:
-	p++
-	if p == pe { goto _test_eof82 }
-	fallthrough
-case 82:
-	switch data[p] {
-		case 32: goto st82
-		case 61: goto st83
-	}
-	goto st0
-st83:
-	p++
-	if p == pe { goto _test_eof83 }
-	fallthrough
-case 83:
-	if data[p] == 32 { goto st84 }
-	goto st0
-st84:
-	p++
-	if p == pe { goto _test_eof84 }
-	fallthrough
-case 84:
-	switch data[p] {
-		case 32: goto st84
-		case 102: goto tr115
-		case 110: goto tr116
-		case 111: goto tr117
-		case 116: goto tr118
-		case 121: goto tr119
-	}
-	if 48 <= data[p] && data[p] <= 49 { goto tr114 }
-	goto st0
-tr114:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st85
-st85:
-	p++
-	if p == pe { goto _test_eof85 }
-	fallthrough
-case 85:
-// line 1211 "parser.go"
-	switch data[p] {
-		case 10: goto tr120
-		case 32: goto tr121
-	}
-	goto st0
-tr115:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st86
-st86:
-	p++
-	if p == pe { goto _test_eof86 }
-	fallthrough
-case 86:
-// line 1226 "parser.go"
-	if data[p] == 97 { goto st87 }
-	goto st0
-st87:
-	p++
-	if p == pe { goto _test_eof87 }
-	fallthrough
-case 87:
-	if data[p] == 108 { goto st88 }
-	goto st0
-st88:
-	p++
-	if p == pe { goto _test_eof88 }
-	fallthrough
-case 88:
-	if data[p] == 115 { goto st89 }
-	goto st0
-st89:
-	p++
-	if p == pe { goto _test_eof89 }
-	fallthrough
-case 89:
-	if data[p] == 101 { goto st85 }
-	goto st0
-tr116:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st90
-st90:
-	p++
-	if p == pe { goto _test_eof90 }
-	fallthrough
-case 90:
-// line 1259 "parser.go"
-	if data[p] == 111 { goto st85 }
-	goto st0
-tr117:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st91
-st91:
-	p++
-	if p == pe { goto _test_eof91 }
-	fallthrough
-case 91:
-// line 1271 "parser.go"
-	switch data[p] {
-		case 102: goto st92
-		case 110: goto st85
-	}
-	goto st0
-st92:
-	p++
-	if p == pe { goto _test_eof92 }
-	fallthrough
-case 92:
-	if data[p] == 102 { goto st85 }
-	goto st0
-tr118:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st93
-st93:
-	p++
-	if p == pe { goto _test_eof93 }
-	fallthrough
-case 93:
-// line 1293 "parser.go"
-	if data[p] == 114 { goto st94 }
-	goto st0
-st94:
-	p++
-	if p == pe { goto _test_eof94 }
-	fallthrough
-case 94:
-	if data[p] == 117 { goto st89 }
-	goto st0
-tr119:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st95
-st95:
-	p++
-	if p == pe { goto _test_eof95 }
-	fallthrough
-case 95:
-// line 1312 "parser.go"
-	if data[p] == 101 { goto st96 }
-	goto st0
-st96:
-	p++
-	if p == pe { goto _test_eof96 }
-	fallthrough
-case 96:
-	if data[p] == 115 { goto st85 }
-	goto st0
-st97:
-	p++
-	if p == pe { goto _test_eof97 }
-	fallthrough
-case 97:
-	if data[p] == 97 { goto st98 }
-	goto st0
-st98:
-	p++
-	if p == pe { goto _test_eof98 }
-	fallthrough
-case 98:
-	if data[p] == 115 { goto st99 }
-	goto st0
-st99:
-	p++
-	if p == pe { goto _test_eof99 }
-	fallthrough
-case 99:
-	if data[p] == 115 { goto st100 }
-	goto st0
-st100:
-	p++
-	if p == pe { goto _test_eof100 }
-	fallthrough
-case 100:
-	if data[p] == 119 { goto st101 }
-	goto st0
-st101:
-	p++
-	if p == pe { goto _test_eof101 }
-	fallthrough
-case 101:
-	if data[p] == 111 { goto st102 }
-	goto st0
-st102:
-	p++
-	if p == pe { goto _test_eof102 }
-	fallthrough
-case 102:
-	if data[p] == 114 { goto st103 }
-	goto st0
-st103:
-	p++
-	if p == pe { goto _test_eof103 }
-	fallthrough
-case 103:
-	if data[p] == 100 { goto st104 }
-	goto st0
-st104:
-	p++
-	if p == pe { goto _test_eof104 }
-	fallthrough
-case 104:
-	if data[p] == 32 { goto st105 }
-	goto st0
-st105:
-	p++
-	if p == pe { goto _test_eof105 }
-	fallthrough
-case 105:
-	switch data[p] {
-		case 32: goto st105
-		case 61: goto st106
-	}
-	goto st0
-st106:
-	p++
-	if p == pe { goto _test_eof106 }
-	fallthrough
-case 106:
-	if data[p] == 32 { goto st107 }
-	goto st0
-st107:
-	p++
-	if p == pe { goto _test_eof107 }
-	fallthrough
-case 107:
-	if data[p] == 32 { goto st107 }
-	if 33 <= data[p] && data[p] <= 126 { goto tr139 }
-	goto st0
-tr139:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st108
-st108:
-	p++
-	if p == pe { goto _test_eof108 }
-	fallthrough
-case 108:
-// line 1412 "parser.go"
-	switch data[p] {
-		case 10: goto tr140
-		case 32: goto tr141
-	}
-	if 33 <= data[p] && data[p] <= 126 { goto st108 }
-	goto st0
-st109:
-	p++
-	if p == pe { goto _test_eof109 }
-	fallthrough
-case 109:
-	if data[p] == 101 { goto st110 }
-	goto st0
-st110:
-	p++
-	if p == pe { goto _test_eof110 }
-	fallthrough
-case 110:
-	if data[p] == 110 { goto st111 }
-	goto st0
-st111:
-	p++
-	if p == pe { goto _test_eof111 }
-	fallthrough
-case 111:
-	if data[p] == 105 { goto st112 }
-	goto st0
-st112:
-	p++
-	if p == pe { goto _test_eof112 }
-	fallthrough
-case 112:
-	if data[p] == 99 { goto st113 }
-	goto st0
-st113:
-	p++
-	if p == pe { goto _test_eof113 }
-	fallthrough
-case 113:
-	if data[p] == 107 { goto st114 }
-	goto st0
-st114:
-	p++
-	if p == pe { goto _test_eof114 }
-	fallthrough
-case 114:
-	if data[p] == 32 { goto st115 }
-	goto st0
-st115:
-	p++
-	if p == pe { goto _test_eof115 }
-	fallthrough
-case 115:
-	switch data[p] {
-		case 32: goto st115
-		case 61: goto st116
-	}
-	goto st0
-st116:
-	p++
-	if p == pe { goto _test_eof116 }
-	fallthrough
-case 116:
-	if data[p] == 32 { goto st117 }
-	goto st0
-st117:
-	p++
-	if p == pe { goto _test_eof117 }
-	fallthrough
-case 117:
-	switch data[p] {
-		case 32: goto st117
-		case 102: goto tr152
-		case 110: goto tr153
-		case 111: goto tr154
-		case 116: goto tr155
-		case 121: goto tr156
-	}
-	if 48 <= data[p] && data[p] <= 49 { goto tr151 }
-	goto st0
-tr151:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st118
-st118:
-	p++
-	if p == pe { goto _test_eof118 }
-	fallthrough
-case 118:
-// line 1502 "parser.go"
-	switch data[p] {
-		case 10: goto tr157
-		case 32: goto tr158
-	}
-	goto st0
-tr152:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st119
-st119:
-	p++
-	if p == pe { goto _test_eof119 }
-	fallthrough
-case 119:
-// line 1517 "parser.go"
-	if data[p] == 97 { goto st120 }
-	goto st0
-st120:
-	p++
-	if p == pe { goto _test_eof120 }
-	fallthrough
-case 120:
-	if data[p] == 108 { goto st121 }
-	goto st0
-st121:
-	p++
-	if p == pe { goto _test_eof121 }
-	fallthrough
-case 121:
-	if data[p] == 115 { goto st122 }
-	goto st0
-st122:
-	p++
-	if p == pe { goto _test_eof122 }
-	fallthrough
-case 122:
-	if data[p] == 101 { goto st118 }
-	goto st0
-tr153:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st123
-st123:
-	p++
-	if p == pe { goto _test_eof123 }
-	fallthrough
-case 123:
-// line 1550 "parser.go"
-	if data[p] == 111 { goto st118 }
-	goto st0
-tr154:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st124
-st124:
-	p++
-	if p == pe { goto _test_eof124 }
-	fallthrough
-case 124:
-// line 1562 "parser.go"
-	switch data[p] {
-		case 102: goto st125
-		case 110: goto st118
-	}
-	goto st0
-st125:
-	p++
-	if p == pe { goto _test_eof125 }
-	fallthrough
-case 125:
-	if data[p] == 102 { goto st118 }
-	goto st0
-tr155:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st126
-st126:
-	p++
-	if p == pe { goto _test_eof126 }
-	fallthrough
-case 126:
-// line 1584 "parser.go"
-	if data[p] == 114 { goto st127 }
-	goto st0
-st127:
-	p++
-	if p == pe { goto _test_eof127 }
-	fallthrough
-case 127:
-	if data[p] == 117 { goto st122 }
-	goto st0
-tr156:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st128
-st128:
-	p++
-	if p == pe { goto _test_eof128 }
-	fallthrough
-case 128:
-// line 1603 "parser.go"
-	if data[p] == 101 { goto st129 }
-	goto st0
-st129:
-	p++
-	if p == pe { goto _test_eof129 }
-	fallthrough
-case 129:
-	if data[p] == 115 { goto st118 }
-	goto st0
-tr40:
-// line 168 "parser.rl"
-	{
-		cur.(*cOper).CanBan = getbool(data[mark:p])
-	}
-	goto st130
-tr189:
-// line 154 "parser.rl"
-	{
-		cur.(*cOper).HostMask = append(
-			cur.(*cOper).HostMask, string(data[mark:p]))
-	}
-	goto st130
-tr204:
-// line 162 "parser.rl"
-	{
-		cur.(*cOper).CanKill = getbool(data[mark:p])
-	}
-	goto st130
-tr226:
-// line 180 "parser.rl"
-	{
-		cur.(*cOper).CanLink = getbool(data[mark:p])
-	}
-	goto st130
-tr247:
-// line 147 "parser.rl"
-	{
-		cur.(*cOper).Password = string(data[mark:p])
-	}
-	goto st130
-tr275:
-// line 174 "parser.rl"
-	{
-		cur.(*cOper).CanRenick = getbool(data[mark:p])
-	}
-	goto st130
-st130:
-	p++
-	if p == pe { goto _test_eof130 }
-	fallthrough
-case 130:
-// line 1655 "parser.go"
-	switch data[p] {
-		case 10: goto st25
-		case 32: goto st130
-		case 125: goto st562
-	}
-	if 9 <= data[p] && data[p] <= 13 { goto st24 }
-	goto st0
-tr33:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st131
-st131:
-	p++
-	if p == pe { goto _test_eof131 }
-	fallthrough
-case 131:
-// line 1672 "parser.go"
-	if data[p] == 97 { goto st132 }
-	goto st0
-st132:
-	p++
-	if p == pe { goto _test_eof132 }
-	fallthrough
-case 132:
-	if data[p] == 108 { goto st133 }
-	goto st0
-st133:
-	p++
-	if p == pe { goto _test_eof133 }
-	fallthrough
-case 133:
-	if data[p] == 115 { goto st134 }
-	goto st0
-st134:
-	p++
-	if p == pe { goto _test_eof134 }
-	fallthrough
-case 134:
-	if data[p] == 101 { goto st23 }
-	goto st0
-tr34:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st135
-st135:
-	p++
-	if p == pe { goto _test_eof135 }
-	fallthrough
-case 135:
-// line 1705 "parser.go"
-	if data[p] == 111 { goto st23 }
-	goto st0
-tr35:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st136
-st136:
-	p++
-	if p == pe { goto _test_eof136 }
-	fallthrough
-case 136:
-// line 1717 "parser.go"
-	switch data[p] {
-		case 102: goto st137
-		case 110: goto st23
-	}
-	goto st0
-st137:
-	p++
-	if p == pe { goto _test_eof137 }
-	fallthrough
-case 137:
-	if data[p] == 102 { goto st23 }
-	goto st0
-tr36:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st138
-st138:
-	p++
-	if p == pe { goto _test_eof138 }
-	fallthrough
-case 138:
-// line 1739 "parser.go"
-	if data[p] == 114 { goto st139 }
-	goto st0
-st139:
-	p++
-	if p == pe { goto _test_eof139 }
-	fallthrough
-case 139:
-	if data[p] == 117 { goto st134 }
-	goto st0
-tr37:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st140
-st140:
-	p++
-	if p == pe { goto _test_eof140 }
-	fallthrough
-case 140:
-// line 1758 "parser.go"
-	if data[p] == 101 { goto st141 }
-	goto st0
-st141:
-	p++
-	if p == pe { goto _test_eof141 }
-	fallthrough
-case 141:
-	if data[p] == 115 { goto st23 }
-	goto st0
-st142:
-	p++
-	if p == pe { goto _test_eof142 }
-	fallthrough
-case 142:
-	if data[p] == 111 { goto st143 }
-	goto st0
-st143:
-	p++
-	if p == pe { goto _test_eof143 }
-	fallthrough
-case 143:
-	if data[p] == 115 { goto st144 }
-	goto st0
-st144:
-	p++
-	if p == pe { goto _test_eof144 }
-	fallthrough
-case 144:
-	if data[p] == 116 { goto st145 }
-	goto st0
-st145:
-	p++
-	if p == pe { goto _test_eof145 }
-	fallthrough
-case 145:
-	if data[p] == 109 { goto st146 }
-	goto st0
-st146:
-	p++
-	if p == pe { goto _test_eof146 }
-	fallthrough
-case 146:
-	if data[p] == 97 { goto st147 }
-	goto st0
-st147:
-	p++
-	if p == pe { goto _test_eof147 }
-	fallthrough
-case 147:
-	if data[p] == 115 { goto st148 }
-	goto st0
-st148:
-	p++
-	if p == pe { goto _test_eof148 }
-	fallthrough
-case 148:
-	if data[p] == 107 { goto st149 }
-	goto st0
-st149:
-	p++
-	if p == pe { goto _test_eof149 }
-	fallthrough
-case 149:
-	if data[p] == 32 { goto st150 }
-	goto st0
-st150:
-	p++
-	if p == pe { goto _test_eof150 }
-	fallthrough
-case 150:
-	switch data[p] {
-		case 32: goto st150
-		case 61: goto st151
-	}
-	goto st0
-st151:
-	p++
-	if p == pe { goto _test_eof151 }
-	fallthrough
-case 151:
-	if data[p] == 32 { goto st152 }
-	goto st0
-st152:
-	p++
-	if p == pe { goto _test_eof152 }
-	fallthrough
-case 152:
-	switch data[p] {
-		case 32: goto st152
-		case 42: goto tr184
-		case 46: goto tr184
-		case 63: goto tr184
-	}
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto tr184 }
-	} else if data[p] > 90 {
-		if 97 <= data[p] && data[p] <= 122 { goto tr184 }
-	} else {
-		goto tr184
-	}
-	goto st0
-tr184:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st153
-st153:
-	p++
-	if p == pe { goto _test_eof153 }
-	fallthrough
-case 153:
-// line 1869 "parser.go"
-	switch data[p] {
-		case 42: goto st153
-		case 46: goto st153
-		case 64: goto st154
-	}
-	if data[p] < 63 {
-		if 48 <= data[p] && data[p] <= 57 { goto st153 }
-	} else if data[p] > 90 {
-		if 97 <= data[p] && data[p] <= 122 { goto st153 }
-	} else {
-		goto st153
-	}
-	goto st0
-st154:
-	p++
-	if p == pe { goto _test_eof154 }
-	fallthrough
-case 154:
-	switch data[p] {
-		case 42: goto st155
-		case 46: goto st155
-		case 63: goto st155
-	}
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st155 }
-	} else if data[p] > 90 {
-		if 97 <= data[p] && data[p] <= 122 { goto st155 }
-	} else {
-		goto st155
-	}
-	goto st0
-st155:
-	p++
-	if p == pe { goto _test_eof155 }
-	fallthrough
-case 155:
-	switch data[p] {
-		case 10: goto tr85
-		case 32: goto tr189
-		case 42: goto st155
-		case 46: goto st155
-		case 63: goto st155
-		case 125: goto tr190
-	}
-	if data[p] < 48 {
-		if 9 <= data[p] && data[p] <= 13 { goto tr188 }
-	} else if data[p] > 57 {
-		if data[p] > 90 {
-			if 97 <= data[p] && data[p] <= 122 { goto st155 }
-		} else if data[p] >= 65 {
-			goto st155
-		}
-	} else {
-		goto st155
-	}
-	goto st0
-st156:
-	p++
-	if p == pe { goto _test_eof156 }
-	fallthrough
-case 156:
-	if data[p] == 105 { goto st157 }
-	goto st0
-st157:
-	p++
-	if p == pe { goto _test_eof157 }
-	fallthrough
-case 157:
-	if data[p] == 108 { goto st158 }
-	goto st0
-st158:
-	p++
-	if p == pe { goto _test_eof158 }
-	fallthrough
-case 158:
-	if data[p] == 108 { goto st159 }
-	goto st0
-st159:
-	p++
-	if p == pe { goto _test_eof159 }
-	fallthrough
-case 159:
-	if data[p] == 32 { goto st160 }
-	goto st0
-st160:
-	p++
-	if p == pe { goto _test_eof160 }
-	fallthrough
-case 160:
-	switch data[p] {
-		case 32: goto st160
-		case 61: goto st161
-	}
-	goto st0
-st161:
-	p++
-	if p == pe { goto _test_eof161 }
-	fallthrough
-case 161:
-	if data[p] == 32 { goto st162 }
-	goto st0
-st162:
-	p++
-	if p == pe { goto _test_eof162 }
-	fallthrough
-case 162:
-	switch data[p] {
-		case 32: goto st162
-		case 102: goto tr198
-		case 110: goto tr199
-		case 111: goto tr200
-		case 116: goto tr201
-		case 121: goto tr202
-	}
-	if 48 <= data[p] && data[p] <= 49 { goto tr197 }
-	goto st0
-tr197:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st163
-st163:
-	p++
-	if p == pe { goto _test_eof163 }
-	fallthrough
-case 163:
-// line 1995 "parser.go"
-	switch data[p] {
-		case 10: goto tr99
-		case 32: goto tr204
-		case 125: goto tr205
-	}
-	if 9 <= data[p] && data[p] <= 13 { goto tr203 }
-	goto st0
-tr198:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st164
-st164:
-	p++
-	if p == pe { goto _test_eof164 }
-	fallthrough
-case 164:
-// line 2012 "parser.go"
-	if data[p] == 97 { goto st165 }
-	goto st0
-st165:
-	p++
-	if p == pe { goto _test_eof165 }
-	fallthrough
-case 165:
-	if data[p] == 108 { goto st166 }
-	goto st0
-st166:
-	p++
-	if p == pe { goto _test_eof166 }
-	fallthrough
-case 166:
-	if data[p] == 115 { goto st167 }
-	goto st0
-st167:
-	p++
-	if p == pe { goto _test_eof167 }
-	fallthrough
-case 167:
-	if data[p] == 101 { goto st163 }
-	goto st0
-tr199:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st168
-st168:
-	p++
-	if p == pe { goto _test_eof168 }
-	fallthrough
-case 168:
-// line 2045 "parser.go"
-	if data[p] == 111 { goto st163 }
-	goto st0
-tr200:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st169
-st169:
-	p++
-	if p == pe { goto _test_eof169 }
-	fallthrough
-case 169:
-// line 2057 "parser.go"
-	switch data[p] {
-		case 102: goto st170
-		case 110: goto st163
-	}
-	goto st0
-st170:
-	p++
-	if p == pe { goto _test_eof170 }
-	fallthrough
-case 170:
-	if data[p] == 102 { goto st163 }
-	goto st0
-tr201:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st171
-st171:
-	p++
-	if p == pe { goto _test_eof171 }
-	fallthrough
-case 171:
-// line 2079 "parser.go"
-	if data[p] == 114 { goto st172 }
-	goto st0
-st172:
-	p++
-	if p == pe { goto _test_eof172 }
-	fallthrough
-case 172:
-	if data[p] == 117 { goto st167 }
-	goto st0
-tr202:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st173
-st173:
-	p++
-	if p == pe { goto _test_eof173 }
-	fallthrough
-case 173:
-// line 2098 "parser.go"
-	if data[p] == 101 { goto st174 }
-	goto st0
-st174:
-	p++
-	if p == pe { goto _test_eof174 }
-	fallthrough
-case 174:
-	if data[p] == 115 { goto st163 }
-	goto st0
-st175:
-	p++
-	if p == pe { goto _test_eof175 }
-	fallthrough
-case 175:
-	if data[p] == 105 { goto st176 }
-	goto st0
-st176:
-	p++
-	if p == pe { goto _test_eof176 }
-	fallthrough
-case 176:
-	if data[p] == 110 { goto st177 }
-	goto st0
-st177:
-	p++
-	if p == pe { goto _test_eof177 }
-	fallthrough
-case 177:
-	if data[p] == 107 { goto st178 }
-	goto st0
-st178:
-	p++
-	if p == pe { goto _test_eof178 }
-	fallthrough
-case 178:
-	if data[p] == 32 { goto st179 }
-	goto st0
-st179:
-	p++
-	if p == pe { goto _test_eof179 }
-	fallthrough
-case 179:
-	switch data[p] {
-		case 32: goto st179
-		case 61: goto st180
-	}
-	goto st0
-st180:
-	p++
-	if p == pe { goto _test_eof180 }
-	fallthrough
-case 180:
-	if data[p] == 32 { goto st181 }
-	goto st0
-st181:
-	p++
-	if p == pe { goto _test_eof181 }
-	fallthrough
-case 181:
-	switch data[p] {
-		case 32: goto st181
-		case 102: goto tr220
-		case 110: goto tr221
-		case 111: goto tr222
-		case 116: goto tr223
-		case 121: goto tr224
-	}
-	if 48 <= data[p] && data[p] <= 49 { goto tr219 }
-	goto st0
-tr219:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st182
-st182:
-	p++
-	if p == pe { goto _test_eof182 }
-	fallthrough
-case 182:
-// line 2177 "parser.go"
-	switch data[p] {
-		case 10: goto tr120
-		case 32: goto tr226
-		case 125: goto tr227
-	}
-	if 9 <= data[p] && data[p] <= 13 { goto tr225 }
-	goto st0
-tr220:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st183
-st183:
-	p++
-	if p == pe { goto _test_eof183 }
-	fallthrough
-case 183:
-// line 2194 "parser.go"
-	if data[p] == 97 { goto st184 }
-	goto st0
-st184:
-	p++
-	if p == pe { goto _test_eof184 }
-	fallthrough
-case 184:
-	if data[p] == 108 { goto st185 }
-	goto st0
-st185:
-	p++
-	if p == pe { goto _test_eof185 }
-	fallthrough
-case 185:
-	if data[p] == 115 { goto st186 }
-	goto st0
-st186:
-	p++
-	if p == pe { goto _test_eof186 }
-	fallthrough
-case 186:
-	if data[p] == 101 { goto st182 }
-	goto st0
-tr221:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st187
-st187:
-	p++
-	if p == pe { goto _test_eof187 }
-	fallthrough
-case 187:
-// line 2227 "parser.go"
-	if data[p] == 111 { goto st182 }
-	goto st0
-tr222:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st188
-st188:
-	p++
-	if p == pe { goto _test_eof188 }
-	fallthrough
-case 188:
-// line 2239 "parser.go"
-	switch data[p] {
-		case 102: goto st189
-		case 110: goto st182
-	}
-	goto st0
-st189:
-	p++
-	if p == pe { goto _test_eof189 }
-	fallthrough
-case 189:
-	if data[p] == 102 { goto st182 }
-	goto st0
-tr223:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st190
-st190:
-	p++
-	if p == pe { goto _test_eof190 }
-	fallthrough
-case 190:
-// line 2261 "parser.go"
-	if data[p] == 114 { goto st191 }
-	goto st0
-st191:
-	p++
-	if p == pe { goto _test_eof191 }
-	fallthrough
-case 191:
-	if data[p] == 117 { goto st186 }
-	goto st0
-tr224:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st192
-st192:
-	p++
-	if p == pe { goto _test_eof192 }
-	fallthrough
-case 192:
-// line 2280 "parser.go"
-	if data[p] == 101 { goto st193 }
-	goto st0
-st193:
-	p++
-	if p == pe { goto _test_eof193 }
-	fallthrough
-case 193:
-	if data[p] == 115 { goto st182 }
-	goto st0
-st194:
-	p++
-	if p == pe { goto _test_eof194 }
-	fallthrough
-case 194:
-	if data[p] == 97 { goto st195 }
-	goto st0
-st195:
-	p++
-	if p == pe { goto _test_eof195 }
-	fallthrough
-case 195:
-	if data[p] == 115 { goto st196 }
-	goto st0
-st196:
-	p++
-	if p == pe { goto _test_eof196 }
-	fallthrough
-case 196:
-	if data[p] == 115 { goto st197 }
-	goto st0
-st197:
-	p++
-	if p == pe { goto _test_eof197 }
-	fallthrough
-case 197:
-	if data[p] == 119 { goto st198 }
-	goto st0
-st198:
-	p++
-	if p == pe { goto _test_eof198 }
-	fallthrough
-case 198:
-	if data[p] == 111 { goto st199 }
-	goto st0
-st199:
-	p++
-	if p == pe { goto _test_eof199 }
-	fallthrough
-case 199:
-	if data[p] == 114 { goto st200 }
-	goto st0
-st200:
-	p++
-	if p == pe { goto _test_eof200 }
-	fallthrough
-case 200:
-	if data[p] == 100 { goto st201 }
-	goto st0
-st201:
-	p++
-	if p == pe { goto _test_eof201 }
-	fallthrough
-case 201:
-	if data[p] == 32 { goto st202 }
-	goto st0
-st202:
-	p++
-	if p == pe { goto _test_eof202 }
-	fallthrough
-case 202:
-	switch data[p] {
-		case 32: goto st202
-		case 61: goto st203
-	}
-	goto st0
-st203:
-	p++
-	if p == pe { goto _test_eof203 }
-	fallthrough
-case 203:
-	if data[p] == 32 { goto st204 }
-	goto st0
-st204:
-	p++
-	if p == pe { goto _test_eof204 }
-	fallthrough
-case 204:
-	if data[p] == 32 { goto st204 }
-	if 33 <= data[p] && data[p] <= 126 { goto tr245 }
-	goto st0
-tr245:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st205
-st205:
-	p++
-	if p == pe { goto _test_eof205 }
-	fallthrough
-case 205:
-// line 2380 "parser.go"
-	switch data[p] {
-		case 10: goto tr140
-		case 32: goto tr247
-		case 125: goto tr249
-	}
-	if data[p] > 13 {
-		if 33 <= data[p] && data[p] <= 126 { goto st205 }
-	} else if data[p] >= 9 {
-		goto tr246
-	}
-	goto st0
-tr249:
-// line 147 "parser.rl"
-	{
-		cur.(*cOper).Password = string(data[mark:p])
-	}
-	goto st563
-st563:
-	p++
-	if p == pe { goto _test_eof563 }
-	fallthrough
-case 563:
-// line 2403 "parser.go"
-	switch data[p] {
-		case 10: goto tr639
-		case 32: goto tr640
-		case 111: goto tr641
-		case 112: goto tr642
-		case 125: goto tr249
-	}
-	if data[p] > 13 {
-		if 33 <= data[p] && data[p] <= 126 { goto st205 }
-	} else if data[p] >= 9 {
-		goto tr638
-	}
-	goto st0
-tr638:
-// line 147 "parser.rl"
-	{
-		cur.(*cOper).Password = string(data[mark:p])
-	}
-// line 134 "parser.rl"
-	{
-		oper := cur.(*cOper)
-		conf.Opers[oper.Username] = oper
-		cur = nil
-	}
-	goto st564
-st564:
-	p++
-	if p == pe { goto _test_eof564 }
-	fallthrough
-case 564:
-// line 2434 "parser.go"
-	switch data[p] {
-		case 32: goto st564
-		case 111: goto tr2
-		case 112: goto tr3
-		case 125: goto st562
-	}
-	if 9 <= data[p] && data[p] <= 13 { goto st564 }
-	goto st0
-tr639:
-// line 147 "parser.rl"
-	{
-		cur.(*cOper).Password = string(data[mark:p])
-	}
-// line 134 "parser.rl"
-	{
-		oper := cur.(*cOper)
-		conf.Opers[oper.Username] = oper
-		cur = nil
-	}
-	goto st565
-st565:
-	p++
-	if p == pe { goto _test_eof565 }
-	fallthrough
-case 565:
-// line 2460 "parser.go"
-	switch data[p] {
-		case 32: goto st565
-		case 98: goto st26
-		case 104: goto st45
-		case 107: goto st59
-		case 108: goto st78
-		case 111: goto tr2
-		case 112: goto tr645
-		case 114: goto st109
-		case 125: goto st562
-	}
-	if 9 <= data[p] && data[p] <= 13 { goto st565 }
-	goto st0
-tr645:
-// line 77 "parser.rl"
-	{ cur = defaultPort() }
-	goto st206
-st206:
-	p++
-	if p == pe { goto _test_eof206 }
-	fallthrough
-case 206:
-// line 2483 "parser.go"
-	switch data[p] {
-		case 97: goto st98
-		case 111: goto st4
-	}
-	goto st0
-tr640:
-// line 147 "parser.rl"
-	{
-		cur.(*cOper).Password = string(data[mark:p])
-	}
-// line 134 "parser.rl"
-	{
-		oper := cur.(*cOper)
-		conf.Opers[oper.Username] = oper
-		cur = nil
-	}
-	goto st566
-st566:
-	p++
-	if p == pe { goto _test_eof566 }
-	fallthrough
-case 566:
-// line 2506 "parser.go"
-	switch data[p] {
-		case 10: goto st565
-		case 32: goto st566
-		case 111: goto tr2
-		case 112: goto tr3
-		case 125: goto st562
-	}
-	if 9 <= data[p] && data[p] <= 13 { goto st564 }
-	goto st0
-tr641:
-// line 134 "parser.rl"
-	{
-		oper := cur.(*cOper)
-		conf.Opers[oper.Username] = oper
-		cur = nil
-	}
-// line 133 "parser.rl"
-	{ cur = defaultOper() }
-	goto st207
-st207:
-	p++
-	if p == pe { goto _test_eof207 }
-	fallthrough
-case 207:
-// line 2531 "parser.go"
-	switch data[p] {
-		case 10: goto tr140
-		case 32: goto tr247
-		case 112: goto st208
-		case 125: goto tr249
-	}
-	if data[p] > 13 {
-		if 33 <= data[p] && data[p] <= 126 { goto st205 }
-	} else if data[p] >= 9 {
-		goto tr246
-	}
-	goto st0
-st208:
-	p++
-	if p == pe { goto _test_eof208 }
-	fallthrough
-case 208:
-	switch data[p] {
-		case 10: goto tr140
-		case 32: goto tr247
-		case 101: goto st209
-		case 125: goto tr249
-	}
-	if data[p] > 13 {
-		if 33 <= data[p] && data[p] <= 126 { goto st205 }
-	} else if data[p] >= 9 {
-		goto tr246
-	}
-	goto st0
-st209:
-	p++
-	if p == pe { goto _test_eof209 }
-	fallthrough
-case 209:
-	switch data[p] {
-		case 10: goto tr140
-		case 32: goto tr247
-		case 114: goto st210
-		case 125: goto tr249
-	}
-	if data[p] > 13 {
-		if 33 <= data[p] && data[p] <= 126 { goto st205 }
-	} else if data[p] >= 9 {
-		goto tr246
-	}
-	goto st0
-st210:
-	p++
-	if p == pe { goto _test_eof210 }
-	fallthrough
-case 210:
-	switch data[p] {
-		case 10: goto tr140
-		case 32: goto tr253
-		case 125: goto tr249
-	}
-	if data[p] > 13 {
-		if 33 <= data[p] && data[p] <= 126 { goto st205 }
-	} else if data[p] >= 9 {
-		goto tr246
-	}
-	goto st0
-tr253:
-// line 147 "parser.rl"
-	{
-		cur.(*cOper).Password = string(data[mark:p])
-	}
-	goto st211
-st211:
-	p++
-	if p == pe { goto _test_eof211 }
-	fallthrough
-case 211:
-// line 2605 "parser.go"
-	switch data[p] {
-		case 10: goto st25
-		case 32: goto st211
-		case 125: goto st562
-	}
-	if data[p] < 65 {
-		if 9 <= data[p] && data[p] <= 13 { goto st24 }
-	} else if data[p] > 90 {
-		if 97 <= data[p] && data[p] <= 122 { goto tr16 }
-	} else {
-		goto tr16
-	}
-	goto st0
-tr642:
-// line 134 "parser.rl"
-	{
-		oper := cur.(*cOper)
-		conf.Opers[oper.Username] = oper
-		cur = nil
-	}
-// line 77 "parser.rl"
-	{ cur = defaultPort() }
-	goto st212
-st212:
-	p++
-	if p == pe { goto _test_eof212 }
-	fallthrough
-case 212:
-// line 2634 "parser.go"
-	switch data[p] {
-		case 10: goto tr140
-		case 32: goto tr247
-		case 111: goto st213
-		case 125: goto tr249
-	}
-	if data[p] > 13 {
-		if 33 <= data[p] && data[p] <= 126 { goto st205 }
-	} else if data[p] >= 9 {
-		goto tr246
-	}
-	goto st0
-st213:
-	p++
-	if p == pe { goto _test_eof213 }
-	fallthrough
-case 213:
-	switch data[p] {
-		case 10: goto tr140
-		case 32: goto tr247
-		case 114: goto st214
-		case 125: goto tr249
-	}
-	if data[p] > 13 {
-		if 33 <= data[p] && data[p] <= 126 { goto st205 }
-	} else if data[p] >= 9 {
-		goto tr246
-	}
-	goto st0
-st214:
-	p++
-	if p == pe { goto _test_eof214 }
-	fallthrough
-case 214:
-	switch data[p] {
-		case 10: goto tr140
-		case 32: goto tr247
-		case 116: goto st215
-		case 125: goto tr249
-	}
-	if data[p] > 13 {
-		if 33 <= data[p] && data[p] <= 126 { goto st205 }
-	} else if data[p] >= 9 {
-		goto tr246
-	}
-	goto st0
-st215:
-	p++
-	if p == pe { goto _test_eof215 }
-	fallthrough
-case 215:
-	switch data[p] {
-		case 10: goto tr140
-		case 32: goto tr258
-		case 125: goto tr249
-	}
-	if data[p] > 13 {
-		if 33 <= data[p] && data[p] <= 126 { goto st205 }
-	} else if data[p] >= 9 {
-		goto tr246
-	}
-	goto st0
-tr258:
-// line 147 "parser.rl"
-	{
-		cur.(*cOper).Password = string(data[mark:p])
-	}
-	goto st216
-st216:
-	p++
-	if p == pe { goto _test_eof216 }
-	fallthrough
-case 216:
-// line 2708 "parser.go"
-	switch data[p] {
-		case 10: goto st25
-		case 32: goto st216
-		case 125: goto st562
-	}
-	if data[p] > 13 {
-		if 48 <= data[p] && data[p] <= 57 { goto tr8 }
-	} else if data[p] >= 9 {
-		goto st24
-	}
-	goto st0
-st217:
-	p++
-	if p == pe { goto _test_eof217 }
-	fallthrough
-case 217:
-	if data[p] == 101 { goto st218 }
-	goto st0
-st218:
-	p++
-	if p == pe { goto _test_eof218 }
-	fallthrough
-case 218:
-	if data[p] == 110 { goto st219 }
-	goto st0
-st219:
-	p++
-	if p == pe { goto _test_eof219 }
-	fallthrough
-case 219:
-	if data[p] == 105 { goto st220 }
-	goto st0
-st220:
-	p++
-	if p == pe { goto _test_eof220 }
-	fallthrough
-case 220:
-	if data[p] == 99 { goto st221 }
-	goto st0
-st221:
-	p++
-	if p == pe { goto _test_eof221 }
-	fallthrough
-case 221:
-	if data[p] == 107 { goto st222 }
-	goto st0
-st222:
-	p++
-	if p == pe { goto _test_eof222 }
-	fallthrough
-case 222:
-	if data[p] == 32 { goto st223 }
-	goto st0
-st223:
-	p++
-	if p == pe { goto _test_eof223 }
-	fallthrough
-case 223:
-	switch data[p] {
-		case 32: goto st223
-		case 61: goto st224
-	}
-	goto st0
-st224:
-	p++
-	if p == pe { goto _test_eof224 }
-	fallthrough
-case 224:
-	if data[p] == 32 { goto st225 }
-	goto st0
-st225:
-	p++
-	if p == pe { goto _test_eof225 }
-	fallthrough
-case 225:
-	switch data[p] {
-		case 32: goto st225
-		case 102: goto tr269
-		case 110: goto tr270
-		case 111: goto tr271
-		case 116: goto tr272
-		case 121: goto tr273
-	}
-	if 48 <= data[p] && data[p] <= 49 { goto tr268 }
-	goto st0
-tr268:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st226
-st226:
-	p++
-	if p == pe { goto _test_eof226 }
-	fallthrough
-case 226:
-// line 2803 "parser.go"
-	switch data[p] {
-		case 10: goto tr157
-		case 32: goto tr275
-		case 125: goto tr276
-	}
-	if 9 <= data[p] && data[p] <= 13 { goto tr274 }
-	goto st0
-tr269:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st227
-st227:
-	p++
-	if p == pe { goto _test_eof227 }
-	fallthrough
-case 227:
-// line 2820 "parser.go"
-	if data[p] == 97 { goto st228 }
-	goto st0
-st228:
-	p++
-	if p == pe { goto _test_eof228 }
-	fallthrough
-case 228:
-	if data[p] == 108 { goto st229 }
-	goto st0
-st229:
-	p++
-	if p == pe { goto _test_eof229 }
-	fallthrough
-case 229:
-	if data[p] == 115 { goto st230 }
-	goto st0
-st230:
-	p++
-	if p == pe { goto _test_eof230 }
-	fallthrough
-case 230:
-	if data[p] == 101 { goto st226 }
-	goto st0
-tr270:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st231
-st231:
-	p++
-	if p == pe { goto _test_eof231 }
-	fallthrough
-case 231:
-// line 2853 "parser.go"
-	if data[p] == 111 { goto st226 }
-	goto st0
-tr271:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st232
-st232:
-	p++
-	if p == pe { goto _test_eof232 }
-	fallthrough
-case 232:
-// line 2865 "parser.go"
-	switch data[p] {
-		case 102: goto st233
-		case 110: goto st226
-	}
-	goto st0
-st233:
-	p++
-	if p == pe { goto _test_eof233 }
-	fallthrough
-case 233:
-	if data[p] == 102 { goto st226 }
-	goto st0
-tr272:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st234
-st234:
-	p++
-	if p == pe { goto _test_eof234 }
-	fallthrough
-case 234:
-// line 2887 "parser.go"
-	if data[p] == 114 { goto st235 }
-	goto st0
-st235:
-	p++
-	if p == pe { goto _test_eof235 }
-	fallthrough
-case 235:
-	if data[p] == 117 { goto st230 }
-	goto st0
-tr273:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st236
-st236:
-	p++
-	if p == pe { goto _test_eof236 }
-	fallthrough
-case 236:
-// line 2906 "parser.go"
-	if data[p] == 101 { goto st237 }
-	goto st0
-st237:
-	p++
-	if p == pe { goto _test_eof237 }
-	fallthrough
-case 237:
-	if data[p] == 115 { goto st226 }
-	goto st0
-tr10:
-// line 85 "parser.rl"
-	{
-		cur.(*cPort).Port = getint(data[mark:p])
-	}
-	goto st238
-st238:
-	p++
-	if p == pe { goto _test_eof238 }
-	fallthrough
-case 238:
-// line 2927 "parser.go"
-	switch data[p] {
-		case 10: goto st560
-		case 32: goto st238
-		case 123: goto st239
-	}
-	goto st0
-st239:
-	p++
-	if p == pe { goto _test_eof239 }
-	fallthrough
-case 239:
-	switch data[p] {
-		case 32: goto st239
-		case 98: goto st240
-		case 99: goto st505
-		case 115: goto st524
-		case 122: goto st542
-	}
-	if 9 <= data[p] && data[p] <= 13 { goto st239 }
-	goto st0
-st240:
-	p++
-	if p == pe { goto _test_eof240 }
-	fallthrough
-case 240:
-	if data[p] == 105 { goto st241 }
-	goto st0
-st241:
-	p++
-	if p == pe { goto _test_eof241 }
-	fallthrough
-case 241:
-	if data[p] == 110 { goto st242 }
-	goto st0
-st242:
-	p++
-	if p == pe { goto _test_eof242 }
-	fallthrough
-case 242:
-	if data[p] == 100 { goto st243 }
-	goto st0
-st243:
-	p++
-	if p == pe { goto _test_eof243 }
-	fallthrough
-case 243:
-	if data[p] == 95 { goto st244 }
-	goto st0
-st244:
-	p++
-	if p == pe { goto _test_eof244 }
-	fallthrough
-case 244:
-	if data[p] == 105 { goto st245 }
-	goto st0
-st245:
-	p++
-	if p == pe { goto _test_eof245 }
-	fallthrough
-case 245:
-	if data[p] == 112 { goto st246 }
-	goto st0
-st246:
-	p++
-	if p == pe { goto _test_eof246 }
-	fallthrough
-case 246:
-	if data[p] == 32 { goto st247 }
-	goto st0
-st247:
-	p++
-	if p == pe { goto _test_eof247 }
-	fallthrough
-case 247:
-	switch data[p] {
-		case 32: goto st247
-		case 61: goto st248
-	}
-	goto st0
-st248:
-	p++
-	if p == pe { goto _test_eof248 }
-	fallthrough
-case 248:
-	if data[p] == 32 { goto st249 }
-	goto st0
-st249:
-	p++
-	if p == pe { goto _test_eof249 }
-	fallthrough
-case 249:
-	switch data[p] {
-		case 32: goto st249
-		case 50: goto tr301
-		case 58: goto tr303
-	}
-	if data[p] < 51 {
-		if 48 <= data[p] && data[p] <= 49 { goto tr300 }
-	} else if data[p] > 57 {
-		if data[p] > 70 {
-			if 97 <= data[p] && data[p] <= 102 { goto tr304 }
-		} else if data[p] >= 65 {
-			goto tr304
-		}
-	} else {
-		goto tr302
-	}
-	goto st0
-tr300:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st250
-st250:
-	p++
-	if p == pe { goto _test_eof250 }
-	fallthrough
-case 250:
-// line 3045 "parser.go"
-	switch data[p] {
-		case 46: goto st251
-		case 58: goto st434
-	}
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st431 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st498 }
-	} else {
-		goto st498
-	}
-	goto st0
-st251:
-	p++
-	if p == pe { goto _test_eof251 }
-	fallthrough
-case 251:
-	if data[p] == 50 { goto st429 }
-	if data[p] > 49 {
-		if 51 <= data[p] && data[p] <= 57 { goto st427 }
-	} else if data[p] >= 48 {
-		goto st252
-	}
-	goto st0
-st252:
-	p++
-	if p == pe { goto _test_eof252 }
-	fallthrough
-case 252:
-	if data[p] == 46 { goto st253 }
-	if 48 <= data[p] && data[p] <= 57 { goto st427 }
-	goto st0
-st253:
-	p++
-	if p == pe { goto _test_eof253 }
-	fallthrough
-case 253:
-	if data[p] == 50 { goto st425 }
-	if data[p] > 49 {
-		if 51 <= data[p] && data[p] <= 57 { goto st423 }
-	} else if data[p] >= 48 {
-		goto st254
-	}
-	goto st0
-st254:
-	p++
-	if p == pe { goto _test_eof254 }
-	fallthrough
-case 254:
-	if data[p] == 46 { goto st255 }
-	if 48 <= data[p] && data[p] <= 57 { goto st423 }
-	goto st0
-st255:
-	p++
-	if p == pe { goto _test_eof255 }
-	fallthrough
-case 255:
-	if data[p] == 50 { goto st421 }
-	if data[p] > 49 {
-		if 51 <= data[p] && data[p] <= 57 { goto st419 }
-	} else if data[p] >= 48 {
-		goto st256
-	}
-	goto st0
-st256:
-	p++
-	if p == pe { goto _test_eof256 }
-	fallthrough
-case 256:
-	switch data[p] {
-		case 10: goto tr321
-		case 32: goto tr322
-		case 125: goto tr323
-	}
-	if data[p] > 13 {
-		if 48 <= data[p] && data[p] <= 57 { goto st419 }
-	} else if data[p] >= 9 {
-		goto tr320
-	}
-	goto st0
-tr320:
-// line 91 "parser.rl"
-	{
-		cur.(*cPort).BindIP = net.ParseIP(string(data[mark:p]))
-	}
-	goto st257
-tr582:
-// line 98 "parser.rl"
-	{
-		cur.(*cPort).Class = string(data[mark:p])
-	}
-	goto st257
-tr600:
-// line 105 "parser.rl"
-	{
-		cur.(*cPort).SSL = getbool(data[mark:p])
-	}
-	goto st257
-tr621:
-// line 111 "parser.rl"
-	{
-		cur.(*cPort).Zip = getbool(data[mark:p])
-	}
-	goto st257
-st257:
-	p++
-	if p == pe { goto _test_eof257 }
-	fallthrough
-case 257:
-// line 3155 "parser.go"
-	switch data[p] {
-		case 32: goto st257
-		case 125: goto st560
-	}
-	if 9 <= data[p] && data[p] <= 13 { goto st257 }
-	goto st0
-tr321:
-// line 91 "parser.rl"
-	{
-		cur.(*cPort).BindIP = net.ParseIP(string(data[mark:p]))
-	}
-	goto st258
-tr448:
-// line 98 "parser.rl"
-	{
-		cur.(*cPort).Class = string(data[mark:p])
-	}
-	goto st258
-tr465:
-// line 105 "parser.rl"
-	{
-		cur.(*cPort).SSL = getbool(data[mark:p])
-	}
-	goto st258
-tr485:
-// line 111 "parser.rl"
-	{
-		cur.(*cPort).Zip = getbool(data[mark:p])
-	}
-	goto st258
-st258:
-	p++
-	if p == pe { goto _test_eof258 }
-	fallthrough
-case 258:
-// line 3191 "parser.go"
-	switch data[p] {
-		case 32: goto st258
-		case 98: goto st259
-		case 99: goto st363
-		case 115: goto st382
-		case 122: goto st400
-		case 125: goto st560
-	}
-	if 9 <= data[p] && data[p] <= 13 { goto st258 }
-	goto st0
-st259:
-	p++
-	if p == pe { goto _test_eof259 }
-	fallthrough
-case 259:
-	if data[p] == 105 { goto st260 }
-	goto st0
-st260:
-	p++
-	if p == pe { goto _test_eof260 }
-	fallthrough
-case 260:
-	if data[p] == 110 { goto st261 }
-	goto st0
-st261:
-	p++
-	if p == pe { goto _test_eof261 }
-	fallthrough
-case 261:
-	if data[p] == 100 { goto st262 }
-	goto st0
-st262:
-	p++
-	if p == pe { goto _test_eof262 }
-	fallthrough
-case 262:
-	if data[p] == 95 { goto st263 }
-	goto st0
-st263:
-	p++
-	if p == pe { goto _test_eof263 }
-	fallthrough
-case 263:
-	if data[p] == 105 { goto st264 }
-	goto st0
-st264:
-	p++
-	if p == pe { goto _test_eof264 }
-	fallthrough
-case 264:
-	if data[p] == 112 { goto st265 }
-	goto st0
-st265:
-	p++
-	if p == pe { goto _test_eof265 }
-	fallthrough
-case 265:
-	if data[p] == 32 { goto st266 }
-	goto st0
-st266:
-	p++
-	if p == pe { goto _test_eof266 }
-	fallthrough
-case 266:
-	switch data[p] {
-		case 32: goto st266
-		case 61: goto st267
-	}
-	goto st0
-st267:
-	p++
-	if p == pe { goto _test_eof267 }
-	fallthrough
-case 267:
-	if data[p] == 32 { goto st268 }
-	goto st0
-st268:
-	p++
-	if p == pe { goto _test_eof268 }
-	fallthrough
-case 268:
-	switch data[p] {
-		case 32: goto st268
-		case 50: goto tr340
-		case 58: goto tr342
-	}
-	if data[p] < 51 {
-		if 48 <= data[p] && data[p] <= 49 { goto tr339 }
-	} else if data[p] > 57 {
-		if data[p] > 70 {
-			if 97 <= data[p] && data[p] <= 102 { goto tr343 }
-		} else if data[p] >= 65 {
-			goto tr343
-		}
-	} else {
-		goto tr341
-	}
-	goto st0
-tr339:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st269
-st269:
-	p++
-	if p == pe { goto _test_eof269 }
-	fallthrough
-case 269:
-// line 3299 "parser.go"
-	switch data[p] {
-		case 46: goto st270
-		case 58: goto st292
-	}
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st289 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st356 }
-	} else {
-		goto st356
-	}
-	goto st0
-st270:
-	p++
-	if p == pe { goto _test_eof270 }
-	fallthrough
-case 270:
-	if data[p] == 50 { goto st287 }
-	if data[p] > 49 {
-		if 51 <= data[p] && data[p] <= 57 { goto st285 }
-	} else if data[p] >= 48 {
-		goto st271
-	}
-	goto st0
-st271:
-	p++
-	if p == pe { goto _test_eof271 }
-	fallthrough
-case 271:
-	if data[p] == 46 { goto st272 }
-	if 48 <= data[p] && data[p] <= 57 { goto st285 }
-	goto st0
-st272:
-	p++
-	if p == pe { goto _test_eof272 }
-	fallthrough
-case 272:
-	if data[p] == 50 { goto st283 }
-	if data[p] > 49 {
-		if 51 <= data[p] && data[p] <= 57 { goto st281 }
-	} else if data[p] >= 48 {
-		goto st273
-	}
-	goto st0
-st273:
-	p++
-	if p == pe { goto _test_eof273 }
-	fallthrough
-case 273:
-	if data[p] == 46 { goto st274 }
-	if 48 <= data[p] && data[p] <= 57 { goto st281 }
-	goto st0
-st274:
-	p++
-	if p == pe { goto _test_eof274 }
-	fallthrough
-case 274:
-	if data[p] == 50 { goto st279 }
-	if data[p] > 49 {
-		if 51 <= data[p] && data[p] <= 57 { goto st277 }
-	} else if data[p] >= 48 {
-		goto st275
-	}
-	goto st0
-st275:
-	p++
-	if p == pe { goto _test_eof275 }
-	fallthrough
-case 275:
-	switch data[p] {
-		case 10: goto tr321
-		case 32: goto tr359
-	}
-	if 48 <= data[p] && data[p] <= 57 { goto st277 }
-	goto st0
-tr359:
-// line 91 "parser.rl"
-	{
-		cur.(*cPort).BindIP = net.ParseIP(string(data[mark:p]))
-	}
-	goto st276
-tr449:
-// line 98 "parser.rl"
-	{
-		cur.(*cPort).Class = string(data[mark:p])
-	}
-	goto st276
-tr466:
-// line 105 "parser.rl"
-	{
-		cur.(*cPort).SSL = getbool(data[mark:p])
-	}
-	goto st276
-tr486:
-// line 111 "parser.rl"
-	{
-		cur.(*cPort).Zip = getbool(data[mark:p])
-	}
-	goto st276
-st276:
-	p++
-	if p == pe { goto _test_eof276 }
-	fallthrough
-case 276:
-// line 3404 "parser.go"
-	switch data[p] {
-		case 10: goto st258
-		case 32: goto st276
-	}
-	goto st0
-st277:
-	p++
-	if p == pe { goto _test_eof277 }
-	fallthrough
-case 277:
-	switch data[p] {
-		case 10: goto tr321
-		case 32: goto tr359
-	}
-	if 48 <= data[p] && data[p] <= 57 { goto st278 }
-	goto st0
-st278:
-	p++
-	if p == pe { goto _test_eof278 }
-	fallthrough
-case 278:
-	switch data[p] {
-		case 10: goto tr321
-		case 32: goto tr359
-	}
-	goto st0
-st279:
-	p++
-	if p == pe { goto _test_eof279 }
-	fallthrough
-case 279:
-	switch data[p] {
-		case 10: goto tr321
-		case 32: goto tr359
-		case 53: goto st280
-	}
-	if data[p] > 52 {
-		if 54 <= data[p] && data[p] <= 57 { goto st278 }
-	} else if data[p] >= 48 {
-		goto st277
-	}
-	goto st0
-st280:
-	p++
-	if p == pe { goto _test_eof280 }
-	fallthrough
-case 280:
-	switch data[p] {
-		case 10: goto tr321
-		case 32: goto tr359
-	}
-	if 48 <= data[p] && data[p] <= 53 { goto st278 }
-	goto st0
-st281:
-	p++
-	if p == pe { goto _test_eof281 }
-	fallthrough
-case 281:
-	if data[p] == 46 { goto st274 }
-	if 48 <= data[p] && data[p] <= 57 { goto st282 }
-	goto st0
-st282:
-	p++
-	if p == pe { goto _test_eof282 }
-	fallthrough
-case 282:
-	if data[p] == 46 { goto st274 }
-	goto st0
-st283:
-	p++
-	if p == pe { goto _test_eof283 }
-	fallthrough
-case 283:
-	switch data[p] {
-		case 46: goto st274
-		case 53: goto st284
-	}
-	if data[p] > 52 {
-		if 54 <= data[p] && data[p] <= 57 { goto st282 }
-	} else if data[p] >= 48 {
-		goto st281
-	}
-	goto st0
-st284:
-	p++
-	if p == pe { goto _test_eof284 }
-	fallthrough
-case 284:
-	if data[p] == 46 { goto st274 }
-	if 48 <= data[p] && data[p] <= 53 { goto st282 }
-	goto st0
-st285:
-	p++
-	if p == pe { goto _test_eof285 }
-	fallthrough
-case 285:
-	if data[p] == 46 { goto st272 }
-	if 48 <= data[p] && data[p] <= 57 { goto st286 }
-	goto st0
-st286:
-	p++
-	if p == pe { goto _test_eof286 }
-	fallthrough
-case 286:
-	if data[p] == 46 { goto st272 }
-	goto st0
-st287:
-	p++
-	if p == pe { goto _test_eof287 }
-	fallthrough
-case 287:
-	switch data[p] {
-		case 46: goto st272
-		case 53: goto st288
-	}
-	if data[p] > 52 {
-		if 54 <= data[p] && data[p] <= 57 { goto st286 }
-	} else if data[p] >= 48 {
-		goto st285
-	}
-	goto st0
-st288:
-	p++
-	if p == pe { goto _test_eof288 }
-	fallthrough
-case 288:
-	if data[p] == 46 { goto st272 }
-	if 48 <= data[p] && data[p] <= 53 { goto st286 }
-	goto st0
-st289:
-	p++
-	if p == pe { goto _test_eof289 }
-	fallthrough
-case 289:
-	switch data[p] {
-		case 46: goto st270
-		case 58: goto st292
-	}
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st290 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st355 }
-	} else {
-		goto st355
-	}
-	goto st0
-st290:
-	p++
-	if p == pe { goto _test_eof290 }
-	fallthrough
-case 290:
-	switch data[p] {
-		case 46: goto st270
-		case 58: goto st292
-	}
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st291 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st291 }
-	} else {
-		goto st291
-	}
-	goto st0
-st291:
-	p++
-	if p == pe { goto _test_eof291 }
-	fallthrough
-case 291:
-	if data[p] == 58 { goto st292 }
-	goto st0
-st292:
-	p++
-	if p == pe { goto _test_eof292 }
-	fallthrough
-case 292:
-	if data[p] == 58 { goto st349 }
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st293 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st293 }
-	} else {
-		goto st293
-	}
-	goto st0
-st293:
-	p++
-	if p == pe { goto _test_eof293 }
-	fallthrough
-case 293:
-	if data[p] == 58 { goto st297 }
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st294 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st294 }
-	} else {
-		goto st294
-	}
-	goto st0
-st294:
-	p++
-	if p == pe { goto _test_eof294 }
-	fallthrough
-case 294:
-	if data[p] == 58 { goto st297 }
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st295 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st295 }
-	} else {
-		goto st295
-	}
-	goto st0
-st295:
-	p++
-	if p == pe { goto _test_eof295 }
-	fallthrough
-case 295:
-	if data[p] == 58 { goto st297 }
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st296 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st296 }
-	} else {
-		goto st296
-	}
-	goto st0
-st296:
-	p++
-	if p == pe { goto _test_eof296 }
-	fallthrough
-case 296:
-	if data[p] == 58 { goto st297 }
-	goto st0
-st297:
-	p++
-	if p == pe { goto _test_eof297 }
-	fallthrough
-case 297:
-	if data[p] == 58 { goto st332 }
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st298 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st298 }
-	} else {
-		goto st298
-	}
-	goto st0
-st298:
-	p++
-	if p == pe { goto _test_eof298 }
-	fallthrough
-case 298:
-	if data[p] == 58 { goto st302 }
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st299 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st299 }
-	} else {
-		goto st299
-	}
-	goto st0
-st299:
-	p++
-	if p == pe { goto _test_eof299 }
-	fallthrough
-case 299:
-	if data[p] == 58 { goto st302 }
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st300 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st300 }
-	} else {
-		goto st300
-	}
-	goto st0
-st300:
-	p++
-	if p == pe { goto _test_eof300 }
-	fallthrough
-case 300:
-	if data[p] == 58 { goto st302 }
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st301 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st301 }
-	} else {
-		goto st301
-	}
-	goto st0
-st301:
-	p++
-	if p == pe { goto _test_eof301 }
-	fallthrough
-case 301:
-	if data[p] == 58 { goto st302 }
-	goto st0
-st302:
-	p++
-	if p == pe { goto _test_eof302 }
-	fallthrough
-case 302:
-	if data[p] == 58 { goto st348 }
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st303 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st303 }
-	} else {
-		goto st303
-	}
-	goto st0
-st303:
-	p++
-	if p == pe { goto _test_eof303 }
-	fallthrough
-case 303:
-	if data[p] == 58 { goto st307 }
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st304 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st304 }
-	} else {
-		goto st304
-	}
-	goto st0
-st304:
-	p++
-	if p == pe { goto _test_eof304 }
-	fallthrough
-case 304:
-	if data[p] == 58 { goto st307 }
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st305 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st305 }
-	} else {
-		goto st305
-	}
-	goto st0
-st305:
-	p++
-	if p == pe { goto _test_eof305 }
-	fallthrough
-case 305:
-	if data[p] == 58 { goto st307 }
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st306 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st306 }
-	} else {
-		goto st306
-	}
-	goto st0
-st306:
-	p++
-	if p == pe { goto _test_eof306 }
-	fallthrough
-case 306:
-	if data[p] == 58 { goto st307 }
-	goto st0
-st307:
-	p++
-	if p == pe { goto _test_eof307 }
-	fallthrough
-case 307:
-	if data[p] == 58 { goto st332 }
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st308 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st308 }
-	} else {
-		goto st308
-	}
-	goto st0
-st308:
-	p++
-	if p == pe { goto _test_eof308 }
-	fallthrough
-case 308:
-	if data[p] == 58 { goto st312 }
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st309 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st309 }
-	} else {
-		goto st309
-	}
-	goto st0
-st309:
-	p++
-	if p == pe { goto _test_eof309 }
-	fallthrough
-case 309:
-	if data[p] == 58 { goto st312 }
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st310 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st310 }
-	} else {
-		goto st310
-	}
-	goto st0
-st310:
-	p++
-	if p == pe { goto _test_eof310 }
-	fallthrough
-case 310:
-	if data[p] == 58 { goto st312 }
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st311 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st311 }
-	} else {
-		goto st311
-	}
-	goto st0
-st311:
-	p++
-	if p == pe { goto _test_eof311 }
-	fallthrough
-case 311:
-	if data[p] == 58 { goto st312 }
-	goto st0
-st312:
-	p++
-	if p == pe { goto _test_eof312 }
-	fallthrough
-case 312:
-	if data[p] == 58 { goto st327 }
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st313 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st313 }
-	} else {
-		goto st313
-	}
-	goto st0
-st313:
-	p++
-	if p == pe { goto _test_eof313 }
-	fallthrough
-case 313:
-	if data[p] == 58 { goto st317 }
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st314 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st314 }
-	} else {
-		goto st314
-	}
-	goto st0
-st314:
-	p++
-	if p == pe { goto _test_eof314 }
-	fallthrough
-case 314:
-	if data[p] == 58 { goto st317 }
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st315 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st315 }
-	} else {
-		goto st315
-	}
-	goto st0
-st315:
-	p++
-	if p == pe { goto _test_eof315 }
-	fallthrough
-case 315:
-	if data[p] == 58 { goto st317 }
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st316 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st316 }
-	} else {
-		goto st316
-	}
-	goto st0
-st316:
-	p++
-	if p == pe { goto _test_eof316 }
-	fallthrough
-case 316:
-	if data[p] == 58 { goto st317 }
-	goto st0
-st317:
-	p++
-	if p == pe { goto _test_eof317 }
-	fallthrough
-case 317:
-	if data[p] == 58 { goto st326 }
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st318 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st318 }
-	} else {
-		goto st318
-	}
-	goto st0
-st318:
-	p++
-	if p == pe { goto _test_eof318 }
-	fallthrough
-case 318:
-	if data[p] == 58 { goto st322 }
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st319 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st319 }
-	} else {
-		goto st319
-	}
-	goto st0
-st319:
-	p++
-	if p == pe { goto _test_eof319 }
-	fallthrough
-case 319:
-	if data[p] == 58 { goto st322 }
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st320 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st320 }
-	} else {
-		goto st320
-	}
-	goto st0
-st320:
-	p++
-	if p == pe { goto _test_eof320 }
-	fallthrough
-case 320:
-	if data[p] == 58 { goto st322 }
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st321 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st321 }
-	} else {
-		goto st321
-	}
-	goto st0
-st321:
-	p++
-	if p == pe { goto _test_eof321 }
-	fallthrough
-case 321:
-	if data[p] == 58 { goto st322 }
-	goto st0
-st322:
-	p++
-	if p == pe { goto _test_eof322 }
-	fallthrough
-case 322:
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st323 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st323 }
-	} else {
-		goto st323
-	}
-	goto st0
-st323:
-	p++
-	if p == pe { goto _test_eof323 }
-	fallthrough
-case 323:
-	switch data[p] {
-		case 10: goto tr321
-		case 32: goto tr359
-	}
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st324 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st324 }
-	} else {
-		goto st324
-	}
-	goto st0
-st324:
-	p++
-	if p == pe { goto _test_eof324 }
-	fallthrough
-case 324:
-	switch data[p] {
-		case 10: goto tr321
-		case 32: goto tr359
-	}
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st325 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st325 }
-	} else {
-		goto st325
-	}
-	goto st0
-st325:
-	p++
-	if p == pe { goto _test_eof325 }
-	fallthrough
-case 325:
-	switch data[p] {
-		case 10: goto tr321
-		case 32: goto tr359
-	}
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st278 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st278 }
-	} else {
-		goto st278
-	}
-	goto st0
-st326:
-	p++
-	if p == pe { goto _test_eof326 }
-	fallthrough
-case 326:
-	switch data[p] {
-		case 10: goto tr321
-		case 32: goto tr359
-	}
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st323 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st323 }
-	} else {
-		goto st323
-	}
-	goto st0
-st327:
-	p++
-	if p == pe { goto _test_eof327 }
-	fallthrough
-case 327:
-	switch data[p] {
-		case 10: goto tr321
-		case 32: goto tr359
-	}
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st328 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st328 }
-	} else {
-		goto st328
-	}
-	goto st0
-st328:
-	p++
-	if p == pe { goto _test_eof328 }
-	fallthrough
-case 328:
-	switch data[p] {
-		case 10: goto tr321
-		case 32: goto tr359
-		case 58: goto st322
-	}
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st329 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st329 }
-	} else {
-		goto st329
-	}
-	goto st0
-st329:
-	p++
-	if p == pe { goto _test_eof329 }
-	fallthrough
-case 329:
-	switch data[p] {
-		case 10: goto tr321
-		case 32: goto tr359
-		case 58: goto st322
-	}
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st330 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st330 }
-	} else {
-		goto st330
-	}
-	goto st0
-st330:
-	p++
-	if p == pe { goto _test_eof330 }
-	fallthrough
-case 330:
-	switch data[p] {
-		case 10: goto tr321
-		case 32: goto tr359
-		case 58: goto st322
-	}
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st331 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st331 }
-	} else {
-		goto st331
-	}
-	goto st0
-st331:
-	p++
-	if p == pe { goto _test_eof331 }
-	fallthrough
-case 331:
-	switch data[p] {
-		case 10: goto tr321
-		case 32: goto tr359
-		case 58: goto st322
-	}
-	goto st0
-st332:
-	p++
-	if p == pe { goto _test_eof332 }
-	fallthrough
-case 332:
-	switch data[p] {
-		case 10: goto tr321
-		case 32: goto tr359
-	}
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st333 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st333 }
-	} else {
-		goto st333
-	}
-	goto st0
-st333:
-	p++
-	if p == pe { goto _test_eof333 }
-	fallthrough
-case 333:
-	switch data[p] {
-		case 10: goto tr321
-		case 32: goto tr359
-		case 58: goto st337
-	}
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st334 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st334 }
-	} else {
-		goto st334
-	}
-	goto st0
-st334:
-	p++
-	if p == pe { goto _test_eof334 }
-	fallthrough
-case 334:
-	switch data[p] {
-		case 10: goto tr321
-		case 32: goto tr359
-		case 58: goto st337
-	}
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st335 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st335 }
-	} else {
-		goto st335
-	}
-	goto st0
-st335:
-	p++
-	if p == pe { goto _test_eof335 }
-	fallthrough
-case 335:
-	switch data[p] {
-		case 10: goto tr321
-		case 32: goto tr359
-		case 58: goto st337
-	}
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st336 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st336 }
-	} else {
-		goto st336
-	}
-	goto st0
-st336:
-	p++
-	if p == pe { goto _test_eof336 }
-	fallthrough
-case 336:
-	switch data[p] {
-		case 10: goto tr321
-		case 32: goto tr359
-		case 58: goto st337
-	}
-	goto st0
-st337:
-	p++
-	if p == pe { goto _test_eof337 }
-	fallthrough
-case 337:
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st338 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st338 }
-	} else {
-		goto st338
-	}
-	goto st0
-st338:
-	p++
-	if p == pe { goto _test_eof338 }
-	fallthrough
-case 338:
-	switch data[p] {
-		case 10: goto tr321
-		case 32: goto tr359
-		case 58: goto st342
-	}
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st339 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st339 }
-	} else {
-		goto st339
-	}
-	goto st0
-st339:
-	p++
-	if p == pe { goto _test_eof339 }
-	fallthrough
-case 339:
-	switch data[p] {
-		case 10: goto tr321
-		case 32: goto tr359
-		case 58: goto st342
-	}
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st340 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st340 }
-	} else {
-		goto st340
-	}
-	goto st0
-st340:
-	p++
-	if p == pe { goto _test_eof340 }
-	fallthrough
-case 340:
-	switch data[p] {
-		case 10: goto tr321
-		case 32: goto tr359
-		case 58: goto st342
-	}
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st341 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st341 }
-	} else {
-		goto st341
-	}
-	goto st0
-st341:
-	p++
-	if p == pe { goto _test_eof341 }
-	fallthrough
-case 341:
-	switch data[p] {
-		case 10: goto tr321
-		case 32: goto tr359
-		case 58: goto st342
-	}
-	goto st0
-st342:
-	p++
-	if p == pe { goto _test_eof342 }
-	fallthrough
-case 342:
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st343 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st343 }
-	} else {
-		goto st343
-	}
-	goto st0
-st343:
-	p++
-	if p == pe { goto _test_eof343 }
-	fallthrough
-case 343:
-	switch data[p] {
-		case 10: goto tr321
-		case 32: goto tr359
-		case 58: goto st347
-	}
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st344 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st344 }
-	} else {
-		goto st344
-	}
-	goto st0
-st344:
-	p++
-	if p == pe { goto _test_eof344 }
-	fallthrough
-case 344:
-	switch data[p] {
-		case 10: goto tr321
-		case 32: goto tr359
-		case 58: goto st347
-	}
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st345 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st345 }
-	} else {
-		goto st345
-	}
-	goto st0
-st345:
-	p++
-	if p == pe { goto _test_eof345 }
-	fallthrough
-case 345:
-	switch data[p] {
-		case 10: goto tr321
-		case 32: goto tr359
-		case 58: goto st347
-	}
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st346 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st346 }
-	} else {
-		goto st346
-	}
-	goto st0
-st346:
-	p++
-	if p == pe { goto _test_eof346 }
-	fallthrough
-case 346:
-	switch data[p] {
-		case 10: goto tr321
-		case 32: goto tr359
-		case 58: goto st347
-	}
-	goto st0
-st347:
-	p++
-	if p == pe { goto _test_eof347 }
-	fallthrough
-case 347:
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st328 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st328 }
-	} else {
-		goto st328
-	}
-	goto st0
-st348:
-	p++
-	if p == pe { goto _test_eof348 }
-	fallthrough
-case 348:
-	switch data[p] {
-		case 10: goto tr321
-		case 32: goto tr359
-	}
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st338 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st338 }
-	} else {
-		goto st338
-	}
-	goto st0
-st349:
-	p++
-	if p == pe { goto _test_eof349 }
-	fallthrough
-case 349:
-	switch data[p] {
-		case 10: goto tr321
-		case 32: goto tr359
-	}
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st350 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st350 }
-	} else {
-		goto st350
-	}
-	goto st0
-st350:
-	p++
-	if p == pe { goto _test_eof350 }
-	fallthrough
-case 350:
-	switch data[p] {
-		case 10: goto tr321
-		case 32: goto tr359
-		case 58: goto st354
-	}
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st351 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st351 }
-	} else {
-		goto st351
-	}
-	goto st0
-st351:
-	p++
-	if p == pe { goto _test_eof351 }
-	fallthrough
-case 351:
-	switch data[p] {
-		case 10: goto tr321
-		case 32: goto tr359
-		case 58: goto st354
-	}
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st352 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st352 }
-	} else {
-		goto st352
-	}
-	goto st0
-st352:
-	p++
-	if p == pe { goto _test_eof352 }
-	fallthrough
-case 352:
-	switch data[p] {
-		case 10: goto tr321
-		case 32: goto tr359
-		case 58: goto st354
-	}
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st353 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st353 }
-	} else {
-		goto st353
-	}
-	goto st0
-st353:
-	p++
-	if p == pe { goto _test_eof353 }
-	fallthrough
-case 353:
-	switch data[p] {
-		case 10: goto tr321
-		case 32: goto tr359
-		case 58: goto st354
-	}
-	goto st0
-st354:
-	p++
-	if p == pe { goto _test_eof354 }
-	fallthrough
-case 354:
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st333 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st333 }
-	} else {
-		goto st333
-	}
-	goto st0
-st355:
-	p++
-	if p == pe { goto _test_eof355 }
-	fallthrough
-case 355:
-	if data[p] == 58 { goto st292 }
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st291 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st291 }
-	} else {
-		goto st291
-	}
-	goto st0
-st356:
-	p++
-	if p == pe { goto _test_eof356 }
-	fallthrough
-case 356:
-	if data[p] == 58 { goto st292 }
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st355 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st355 }
-	} else {
-		goto st355
-	}
-	goto st0
-tr340:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st357
-st357:
-	p++
-	if p == pe { goto _test_eof357 }
-	fallthrough
-case 357:
-// line 4516 "parser.go"
-	switch data[p] {
-		case 46: goto st270
-		case 53: goto st358
-		case 58: goto st292
-	}
-	if data[p] < 54 {
-		if 48 <= data[p] && data[p] <= 52 { goto st289 }
-	} else if data[p] > 57 {
-		if data[p] > 70 {
-			if 97 <= data[p] && data[p] <= 102 { goto st356 }
-		} else if data[p] >= 65 {
-			goto st356
-		}
-	} else {
-		goto st359
-	}
-	goto st0
-st358:
-	p++
-	if p == pe { goto _test_eof358 }
-	fallthrough
-case 358:
-	switch data[p] {
-		case 46: goto st270
-		case 58: goto st292
-	}
-	if data[p] < 54 {
-		if 48 <= data[p] && data[p] <= 53 { goto st290 }
-	} else if data[p] > 57 {
-		if data[p] > 70 {
-			if 97 <= data[p] && data[p] <= 102 { goto st355 }
-		} else if data[p] >= 65 {
-			goto st355
-		}
-	} else {
-		goto st355
-	}
-	goto st0
-st359:
-	p++
-	if p == pe { goto _test_eof359 }
-	fallthrough
-case 359:
-	switch data[p] {
-		case 46: goto st270
-		case 58: goto st292
-	}
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st355 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st355 }
-	} else {
-		goto st355
-	}
-	goto st0
-tr341:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st360
-st360:
-	p++
-	if p == pe { goto _test_eof360 }
-	fallthrough
-case 360:
-// line 4581 "parser.go"
-	switch data[p] {
-		case 46: goto st270
-		case 58: goto st292
-	}
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st359 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st356 }
-	} else {
-		goto st356
-	}
-	goto st0
-tr342:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st361
-st361:
-	p++
-	if p == pe { goto _test_eof361 }
-	fallthrough
-case 361:
-// line 4603 "parser.go"
-	if data[p] == 58 { goto st349 }
-	goto st0
-tr343:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st362
-st362:
-	p++
-	if p == pe { goto _test_eof362 }
-	fallthrough
-case 362:
-// line 4615 "parser.go"
-	if data[p] == 58 { goto st292 }
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st356 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st356 }
-	} else {
-		goto st356
-	}
-	goto st0
-st363:
-	p++
-	if p == pe { goto _test_eof363 }
-	fallthrough
-case 363:
-	if data[p] == 108 { goto st364 }
-	goto st0
-st364:
-	p++
-	if p == pe { goto _test_eof364 }
-	fallthrough
-case 364:
-	if data[p] == 97 { goto st365 }
-	goto st0
-st365:
-	p++
-	if p == pe { goto _test_eof365 }
-	fallthrough
-case 365:
-	if data[p] == 115 { goto st366 }
-	goto st0
-st366:
-	p++
-	if p == pe { goto _test_eof366 }
-	fallthrough
-case 366:
-	if data[p] == 115 { goto st367 }
-	goto st0
-st367:
-	p++
-	if p == pe { goto _test_eof367 }
-	fallthrough
-case 367:
-	if data[p] == 32 { goto st368 }
-	goto st0
-st368:
-	p++
-	if p == pe { goto _test_eof368 }
-	fallthrough
-case 368:
-	switch data[p] {
-		case 32: goto st368
-		case 61: goto st369
-	}
-	goto st0
-st369:
-	p++
-	if p == pe { goto _test_eof369 }
-	fallthrough
-case 369:
-	if data[p] == 32 { goto st370 }
-	goto st0
-st370:
-	p++
-	if p == pe { goto _test_eof370 }
-	fallthrough
-case 370:
-	switch data[p] {
-		case 32: goto st370
-		case 99: goto tr441
-		case 115: goto tr442
-	}
-	goto st0
-tr441:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st371
-st371:
-	p++
-	if p == pe { goto _test_eof371 }
-	fallthrough
-case 371:
-// line 4697 "parser.go"
-	if data[p] == 108 { goto st372 }
-	goto st0
-st372:
-	p++
-	if p == pe { goto _test_eof372 }
-	fallthrough
-case 372:
-	if data[p] == 105 { goto st373 }
-	goto st0
-st373:
-	p++
-	if p == pe { goto _test_eof373 }
-	fallthrough
-case 373:
-	if data[p] == 101 { goto st374 }
-	goto st0
-st374:
-	p++
-	if p == pe { goto _test_eof374 }
-	fallthrough
-case 374:
-	if data[p] == 110 { goto st375 }
-	goto st0
-st375:
-	p++
-	if p == pe { goto _test_eof375 }
-	fallthrough
-case 375:
-	if data[p] == 116 { goto st376 }
-	goto st0
-st376:
-	p++
-	if p == pe { goto _test_eof376 }
-	fallthrough
-case 376:
-	switch data[p] {
-		case 10: goto tr448
-		case 32: goto tr449
-	}
-	goto st0
-tr442:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st377
-st377:
-	p++
-	if p == pe { goto _test_eof377 }
-	fallthrough
-case 377:
-// line 4747 "parser.go"
-	if data[p] == 101 { goto st378 }
-	goto st0
-st378:
-	p++
-	if p == pe { goto _test_eof378 }
-	fallthrough
-case 378:
-	if data[p] == 114 { goto st379 }
-	goto st0
-st379:
-	p++
-	if p == pe { goto _test_eof379 }
-	fallthrough
-case 379:
-	if data[p] == 118 { goto st380 }
-	goto st0
-st380:
-	p++
-	if p == pe { goto _test_eof380 }
-	fallthrough
-case 380:
-	if data[p] == 101 { goto st381 }
-	goto st0
-st381:
-	p++
-	if p == pe { goto _test_eof381 }
-	fallthrough
-case 381:
-	if data[p] == 114 { goto st376 }
-	goto st0
-st382:
-	p++
-	if p == pe { goto _test_eof382 }
-	fallthrough
-case 382:
-	if data[p] == 115 { goto st383 }
-	goto st0
-st383:
-	p++
-	if p == pe { goto _test_eof383 }
-	fallthrough
-case 383:
-	if data[p] == 108 { goto st384 }
-	goto st0
-st384:
-	p++
-	if p == pe { goto _test_eof384 }
-	fallthrough
-case 384:
-	if data[p] == 32 { goto st385 }
-	goto st0
-st385:
-	p++
-	if p == pe { goto _test_eof385 }
-	fallthrough
-case 385:
-	switch data[p] {
-		case 32: goto st385
-		case 61: goto st386
-	}
-	goto st0
-st386:
-	p++
-	if p == pe { goto _test_eof386 }
-	fallthrough
-case 386:
-	if data[p] == 32 { goto st387 }
-	goto st0
-st387:
-	p++
-	if p == pe { goto _test_eof387 }
-	fallthrough
-case 387:
-	switch data[p] {
-		case 32: goto st387
-		case 102: goto tr460
-		case 110: goto tr461
-		case 111: goto tr462
-		case 116: goto tr463
-		case 121: goto tr464
-	}
-	if 48 <= data[p] && data[p] <= 49 { goto tr459 }
-	goto st0
-tr459:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st388
-st388:
-	p++
-	if p == pe { goto _test_eof388 }
-	fallthrough
-case 388:
-// line 4840 "parser.go"
-	switch data[p] {
-		case 10: goto tr465
-		case 32: goto tr466
-	}
-	goto st0
-tr460:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st389
-st389:
-	p++
-	if p == pe { goto _test_eof389 }
-	fallthrough
-case 389:
-// line 4855 "parser.go"
-	if data[p] == 97 { goto st390 }
-	goto st0
-st390:
-	p++
-	if p == pe { goto _test_eof390 }
-	fallthrough
-case 390:
-	if data[p] == 108 { goto st391 }
-	goto st0
-st391:
-	p++
-	if p == pe { goto _test_eof391 }
-	fallthrough
-case 391:
-	if data[p] == 115 { goto st392 }
-	goto st0
-st392:
-	p++
-	if p == pe { goto _test_eof392 }
-	fallthrough
-case 392:
-	if data[p] == 101 { goto st388 }
-	goto st0
-tr461:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st393
-st393:
-	p++
-	if p == pe { goto _test_eof393 }
-	fallthrough
-case 393:
-// line 4888 "parser.go"
-	if data[p] == 111 { goto st388 }
-	goto st0
-tr462:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st394
-st394:
-	p++
-	if p == pe { goto _test_eof394 }
-	fallthrough
-case 394:
-// line 4900 "parser.go"
-	switch data[p] {
-		case 102: goto st395
-		case 110: goto st388
-	}
-	goto st0
-st395:
-	p++
-	if p == pe { goto _test_eof395 }
-	fallthrough
-case 395:
-	if data[p] == 102 { goto st388 }
-	goto st0
-tr463:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st396
-st396:
-	p++
-	if p == pe { goto _test_eof396 }
-	fallthrough
-case 396:
-// line 4922 "parser.go"
-	if data[p] == 114 { goto st397 }
-	goto st0
-st397:
-	p++
-	if p == pe { goto _test_eof397 }
-	fallthrough
-case 397:
-	if data[p] == 117 { goto st392 }
-	goto st0
-tr464:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st398
-st398:
-	p++
-	if p == pe { goto _test_eof398 }
-	fallthrough
-case 398:
-// line 4941 "parser.go"
-	if data[p] == 101 { goto st399 }
-	goto st0
-st399:
-	p++
-	if p == pe { goto _test_eof399 }
-	fallthrough
-case 399:
-	if data[p] == 115 { goto st388 }
-	goto st0
-st400:
-	p++
-	if p == pe { goto _test_eof400 }
-	fallthrough
-case 400:
-	if data[p] == 105 { goto st401 }
-	goto st0
-st401:
-	p++
-	if p == pe { goto _test_eof401 }
-	fallthrough
-case 401:
-	if data[p] == 112 { goto st402 }
-	goto st0
-st402:
-	p++
-	if p == pe { goto _test_eof402 }
-	fallthrough
-case 402:
-	if data[p] == 32 { goto st403 }
-	goto st0
-st403:
-	p++
-	if p == pe { goto _test_eof403 }
-	fallthrough
-case 403:
-	switch data[p] {
-		case 32: goto st403
-		case 61: goto st404
-	}
-	goto st0
-st404:
-	p++
-	if p == pe { goto _test_eof404 }
-	fallthrough
-case 404:
-	if data[p] == 32 { goto st405 }
-	goto st0
-st405:
-	p++
-	if p == pe { goto _test_eof405 }
-	fallthrough
-case 405:
-	switch data[p] {
-		case 32: goto st405
-		case 102: goto tr480
-		case 110: goto tr481
-		case 111: goto tr482
-		case 116: goto tr483
-		case 121: goto tr484
-	}
-	if 48 <= data[p] && data[p] <= 49 { goto tr479 }
-	goto st0
-tr479:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st406
-st406:
-	p++
-	if p == pe { goto _test_eof406 }
-	fallthrough
-case 406:
-// line 5013 "parser.go"
-	switch data[p] {
-		case 10: goto tr485
-		case 32: goto tr486
-	}
-	goto st0
-tr480:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st407
-st407:
-	p++
-	if p == pe { goto _test_eof407 }
-	fallthrough
-case 407:
-// line 5028 "parser.go"
-	if data[p] == 97 { goto st408 }
-	goto st0
-st408:
-	p++
-	if p == pe { goto _test_eof408 }
-	fallthrough
-case 408:
-	if data[p] == 108 { goto st409 }
-	goto st0
-st409:
-	p++
-	if p == pe { goto _test_eof409 }
-	fallthrough
-case 409:
-	if data[p] == 115 { goto st410 }
-	goto st0
-st410:
-	p++
-	if p == pe { goto _test_eof410 }
-	fallthrough
-case 410:
-	if data[p] == 101 { goto st406 }
-	goto st0
-tr481:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st411
-st411:
-	p++
-	if p == pe { goto _test_eof411 }
-	fallthrough
-case 411:
-// line 5061 "parser.go"
-	if data[p] == 111 { goto st406 }
-	goto st0
-tr482:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st412
-st412:
-	p++
-	if p == pe { goto _test_eof412 }
-	fallthrough
-case 412:
-// line 5073 "parser.go"
-	switch data[p] {
-		case 102: goto st413
-		case 110: goto st406
-	}
-	goto st0
-st413:
-	p++
-	if p == pe { goto _test_eof413 }
-	fallthrough
-case 413:
-	if data[p] == 102 { goto st406 }
-	goto st0
-tr483:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st414
-st414:
-	p++
-	if p == pe { goto _test_eof414 }
-	fallthrough
-case 414:
-// line 5095 "parser.go"
-	if data[p] == 114 { goto st415 }
-	goto st0
-st415:
-	p++
-	if p == pe { goto _test_eof415 }
-	fallthrough
-case 415:
-	if data[p] == 117 { goto st410 }
-	goto st0
-tr484:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st416
-st416:
-	p++
-	if p == pe { goto _test_eof416 }
-	fallthrough
-case 416:
-// line 5114 "parser.go"
-	if data[p] == 101 { goto st417 }
-	goto st0
-st417:
-	p++
-	if p == pe { goto _test_eof417 }
-	fallthrough
-case 417:
-	if data[p] == 115 { goto st406 }
-	goto st0
-tr322:
-// line 91 "parser.rl"
-	{
-		cur.(*cPort).BindIP = net.ParseIP(string(data[mark:p]))
-	}
-	goto st418
-tr583:
-// line 98 "parser.rl"
-	{
-		cur.(*cPort).Class = string(data[mark:p])
-	}
-	goto st418
-tr601:
-// line 105 "parser.rl"
-	{
-		cur.(*cPort).SSL = getbool(data[mark:p])
-	}
-	goto st418
-tr622:
-// line 111 "parser.rl"
-	{
-		cur.(*cPort).Zip = getbool(data[mark:p])
-	}
-	goto st418
-st418:
-	p++
-	if p == pe { goto _test_eof418 }
-	fallthrough
-case 418:
-// line 5153 "parser.go"
-	switch data[p] {
-		case 10: goto st258
-		case 32: goto st418
-		case 125: goto st560
-	}
-	if 9 <= data[p] && data[p] <= 13 { goto st257 }
-	goto st0
-st419:
-	p++
-	if p == pe { goto _test_eof419 }
-	fallthrough
-case 419:
-	switch data[p] {
-		case 10: goto tr321
-		case 32: goto tr322
-		case 125: goto tr323
-	}
-	if data[p] > 13 {
-		if 48 <= data[p] && data[p] <= 57 { goto st420 }
-	} else if data[p] >= 9 {
-		goto tr320
-	}
-	goto st0
-st420:
-	p++
-	if p == pe { goto _test_eof420 }
-	fallthrough
-case 420:
-	switch data[p] {
-		case 10: goto tr321
-		case 32: goto tr322
-		case 125: goto tr323
-	}
-	if 9 <= data[p] && data[p] <= 13 { goto tr320 }
-	goto st0
-st421:
-	p++
-	if p == pe { goto _test_eof421 }
-	fallthrough
-case 421:
-	switch data[p] {
-		case 10: goto tr321
-		case 32: goto tr322
-		case 53: goto st422
-		case 125: goto tr323
-	}
-	if data[p] < 48 {
-		if 9 <= data[p] && data[p] <= 13 { goto tr320 }
-	} else if data[p] > 52 {
-		if 54 <= data[p] && data[p] <= 57 { goto st420 }
-	} else {
-		goto st419
-	}
-	goto st0
-st422:
-	p++
-	if p == pe { goto _test_eof422 }
-	fallthrough
-case 422:
-	switch data[p] {
-		case 10: goto tr321
-		case 32: goto tr322
-		case 125: goto tr323
-	}
-	if data[p] > 13 {
-		if 48 <= data[p] && data[p] <= 53 { goto st420 }
-	} else if data[p] >= 9 {
-		goto tr320
-	}
-	goto st0
-st423:
-	p++
-	if p == pe { goto _test_eof423 }
-	fallthrough
-case 423:
-	if data[p] == 46 { goto st255 }
-	if 48 <= data[p] && data[p] <= 57 { goto st424 }
-	goto st0
-st424:
-	p++
-	if p == pe { goto _test_eof424 }
-	fallthrough
-case 424:
-	if data[p] == 46 { goto st255 }
-	goto st0
-st425:
-	p++
-	if p == pe { goto _test_eof425 }
-	fallthrough
-case 425:
-	switch data[p] {
-		case 46: goto st255
-		case 53: goto st426
-	}
-	if data[p] > 52 {
-		if 54 <= data[p] && data[p] <= 57 { goto st424 }
-	} else if data[p] >= 48 {
-		goto st423
-	}
-	goto st0
-st426:
-	p++
-	if p == pe { goto _test_eof426 }
-	fallthrough
-case 426:
-	if data[p] == 46 { goto st255 }
-	if 48 <= data[p] && data[p] <= 53 { goto st424 }
-	goto st0
-st427:
-	p++
-	if p == pe { goto _test_eof427 }
-	fallthrough
-case 427:
-	if data[p] == 46 { goto st253 }
-	if 48 <= data[p] && data[p] <= 57 { goto st428 }
-	goto st0
-st428:
-	p++
-	if p == pe { goto _test_eof428 }
-	fallthrough
-case 428:
-	if data[p] == 46 { goto st253 }
-	goto st0
-st429:
-	p++
-	if p == pe { goto _test_eof429 }
-	fallthrough
-case 429:
-	switch data[p] {
-		case 46: goto st253
-		case 53: goto st430
-	}
-	if data[p] > 52 {
-		if 54 <= data[p] && data[p] <= 57 { goto st428 }
-	} else if data[p] >= 48 {
-		goto st427
-	}
-	goto st0
-st430:
-	p++
-	if p == pe { goto _test_eof430 }
-	fallthrough
-case 430:
-	if data[p] == 46 { goto st253 }
-	if 48 <= data[p] && data[p] <= 53 { goto st428 }
-	goto st0
-st431:
-	p++
-	if p == pe { goto _test_eof431 }
-	fallthrough
-case 431:
-	switch data[p] {
-		case 46: goto st251
-		case 58: goto st434
-	}
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st432 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st497 }
-	} else {
-		goto st497
-	}
-	goto st0
-st432:
-	p++
-	if p == pe { goto _test_eof432 }
-	fallthrough
-case 432:
-	switch data[p] {
-		case 46: goto st251
-		case 58: goto st434
-	}
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st433 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st433 }
-	} else {
-		goto st433
-	}
-	goto st0
-st433:
-	p++
-	if p == pe { goto _test_eof433 }
-	fallthrough
-case 433:
-	if data[p] == 58 { goto st434 }
-	goto st0
-st434:
-	p++
-	if p == pe { goto _test_eof434 }
-	fallthrough
-case 434:
-	if data[p] == 58 { goto st491 }
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st435 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st435 }
-	} else {
-		goto st435
-	}
-	goto st0
-st435:
-	p++
-	if p == pe { goto _test_eof435 }
-	fallthrough
-case 435:
-	if data[p] == 58 { goto st439 }
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st436 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st436 }
-	} else {
-		goto st436
-	}
-	goto st0
-st436:
-	p++
-	if p == pe { goto _test_eof436 }
-	fallthrough
-case 436:
-	if data[p] == 58 { goto st439 }
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st437 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st437 }
-	} else {
-		goto st437
-	}
-	goto st0
-st437:
-	p++
-	if p == pe { goto _test_eof437 }
-	fallthrough
-case 437:
-	if data[p] == 58 { goto st439 }
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st438 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st438 }
-	} else {
-		goto st438
-	}
-	goto st0
-st438:
-	p++
-	if p == pe { goto _test_eof438 }
-	fallthrough
-case 438:
-	if data[p] == 58 { goto st439 }
-	goto st0
-st439:
-	p++
-	if p == pe { goto _test_eof439 }
-	fallthrough
-case 439:
-	if data[p] == 58 { goto st474 }
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st440 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st440 }
-	} else {
-		goto st440
-	}
-	goto st0
-st440:
-	p++
-	if p == pe { goto _test_eof440 }
-	fallthrough
-case 440:
-	if data[p] == 58 { goto st444 }
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st441 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st441 }
-	} else {
-		goto st441
-	}
-	goto st0
-st441:
-	p++
-	if p == pe { goto _test_eof441 }
-	fallthrough
-case 441:
-	if data[p] == 58 { goto st444 }
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st442 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st442 }
-	} else {
-		goto st442
-	}
-	goto st0
-st442:
-	p++
-	if p == pe { goto _test_eof442 }
-	fallthrough
-case 442:
-	if data[p] == 58 { goto st444 }
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st443 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st443 }
-	} else {
-		goto st443
-	}
-	goto st0
-st443:
-	p++
-	if p == pe { goto _test_eof443 }
-	fallthrough
-case 443:
-	if data[p] == 58 { goto st444 }
-	goto st0
-st444:
-	p++
-	if p == pe { goto _test_eof444 }
-	fallthrough
-case 444:
-	if data[p] == 58 { goto st490 }
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st445 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st445 }
-	} else {
-		goto st445
-	}
-	goto st0
-st445:
-	p++
-	if p == pe { goto _test_eof445 }
-	fallthrough
-case 445:
-	if data[p] == 58 { goto st449 }
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st446 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st446 }
-	} else {
-		goto st446
-	}
-	goto st0
-st446:
-	p++
-	if p == pe { goto _test_eof446 }
-	fallthrough
-case 446:
-	if data[p] == 58 { goto st449 }
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st447 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st447 }
-	} else {
-		goto st447
-	}
-	goto st0
-st447:
-	p++
-	if p == pe { goto _test_eof447 }
-	fallthrough
-case 447:
-	if data[p] == 58 { goto st449 }
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st448 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st448 }
-	} else {
-		goto st448
-	}
-	goto st0
-st448:
-	p++
-	if p == pe { goto _test_eof448 }
-	fallthrough
-case 448:
-	if data[p] == 58 { goto st449 }
-	goto st0
-st449:
-	p++
-	if p == pe { goto _test_eof449 }
-	fallthrough
-case 449:
-	if data[p] == 58 { goto st474 }
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st450 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st450 }
-	} else {
-		goto st450
-	}
-	goto st0
-st450:
-	p++
-	if p == pe { goto _test_eof450 }
-	fallthrough
-case 450:
-	if data[p] == 58 { goto st454 }
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st451 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st451 }
-	} else {
-		goto st451
-	}
-	goto st0
-st451:
-	p++
-	if p == pe { goto _test_eof451 }
-	fallthrough
-case 451:
-	if data[p] == 58 { goto st454 }
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st452 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st452 }
-	} else {
-		goto st452
-	}
-	goto st0
-st452:
-	p++
-	if p == pe { goto _test_eof452 }
-	fallthrough
-case 452:
-	if data[p] == 58 { goto st454 }
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st453 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st453 }
-	} else {
-		goto st453
-	}
-	goto st0
-st453:
-	p++
-	if p == pe { goto _test_eof453 }
-	fallthrough
-case 453:
-	if data[p] == 58 { goto st454 }
-	goto st0
-st454:
-	p++
-	if p == pe { goto _test_eof454 }
-	fallthrough
-case 454:
-	if data[p] == 58 { goto st469 }
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st455 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st455 }
-	} else {
-		goto st455
-	}
-	goto st0
-st455:
-	p++
-	if p == pe { goto _test_eof455 }
-	fallthrough
-case 455:
-	if data[p] == 58 { goto st459 }
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st456 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st456 }
-	} else {
-		goto st456
-	}
-	goto st0
-st456:
-	p++
-	if p == pe { goto _test_eof456 }
-	fallthrough
-case 456:
-	if data[p] == 58 { goto st459 }
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st457 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st457 }
-	} else {
-		goto st457
-	}
-	goto st0
-st457:
-	p++
-	if p == pe { goto _test_eof457 }
-	fallthrough
-case 457:
-	if data[p] == 58 { goto st459 }
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st458 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st458 }
-	} else {
-		goto st458
-	}
-	goto st0
-st458:
-	p++
-	if p == pe { goto _test_eof458 }
-	fallthrough
-case 458:
-	if data[p] == 58 { goto st459 }
-	goto st0
-st459:
-	p++
-	if p == pe { goto _test_eof459 }
-	fallthrough
-case 459:
-	if data[p] == 58 { goto st468 }
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st460 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st460 }
-	} else {
-		goto st460
-	}
-	goto st0
-st460:
-	p++
-	if p == pe { goto _test_eof460 }
-	fallthrough
-case 460:
-	if data[p] == 58 { goto st464 }
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st461 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st461 }
-	} else {
-		goto st461
-	}
-	goto st0
-st461:
-	p++
-	if p == pe { goto _test_eof461 }
-	fallthrough
-case 461:
-	if data[p] == 58 { goto st464 }
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st462 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st462 }
-	} else {
-		goto st462
-	}
-	goto st0
-st462:
-	p++
-	if p == pe { goto _test_eof462 }
-	fallthrough
-case 462:
-	if data[p] == 58 { goto st464 }
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st463 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st463 }
-	} else {
-		goto st463
-	}
-	goto st0
-st463:
-	p++
-	if p == pe { goto _test_eof463 }
-	fallthrough
-case 463:
-	if data[p] == 58 { goto st464 }
-	goto st0
-st464:
-	p++
-	if p == pe { goto _test_eof464 }
-	fallthrough
-case 464:
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st465 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st465 }
-	} else {
-		goto st465
-	}
-	goto st0
-st465:
-	p++
-	if p == pe { goto _test_eof465 }
-	fallthrough
-case 465:
-	switch data[p] {
-		case 10: goto tr321
-		case 32: goto tr322
-		case 125: goto tr323
-	}
-	if data[p] < 48 {
-		if 9 <= data[p] && data[p] <= 13 { goto tr320 }
-	} else if data[p] > 57 {
-		if data[p] > 70 {
-			if 97 <= data[p] && data[p] <= 102 { goto st466 }
-		} else if data[p] >= 65 {
-			goto st466
-		}
-	} else {
-		goto st466
-	}
-	goto st0
-st466:
-	p++
-	if p == pe { goto _test_eof466 }
-	fallthrough
-case 466:
-	switch data[p] {
-		case 10: goto tr321
-		case 32: goto tr322
-		case 125: goto tr323
-	}
-	if data[p] < 48 {
-		if 9 <= data[p] && data[p] <= 13 { goto tr320 }
-	} else if data[p] > 57 {
-		if data[p] > 70 {
-			if 97 <= data[p] && data[p] <= 102 { goto st467 }
-		} else if data[p] >= 65 {
-			goto st467
-		}
-	} else {
-		goto st467
-	}
-	goto st0
-st467:
-	p++
-	if p == pe { goto _test_eof467 }
-	fallthrough
-case 467:
-	switch data[p] {
-		case 10: goto tr321
-		case 32: goto tr322
-		case 125: goto tr323
-	}
-	if data[p] < 48 {
-		if 9 <= data[p] && data[p] <= 13 { goto tr320 }
-	} else if data[p] > 57 {
-		if data[p] > 70 {
-			if 97 <= data[p] && data[p] <= 102 { goto st420 }
-		} else if data[p] >= 65 {
-			goto st420
-		}
-	} else {
-		goto st420
-	}
-	goto st0
-st468:
-	p++
-	if p == pe { goto _test_eof468 }
-	fallthrough
-case 468:
-	switch data[p] {
-		case 10: goto tr321
-		case 32: goto tr322
-		case 125: goto tr323
-	}
-	if data[p] < 48 {
-		if 9 <= data[p] && data[p] <= 13 { goto tr320 }
-	} else if data[p] > 57 {
-		if data[p] > 70 {
-			if 97 <= data[p] && data[p] <= 102 { goto st465 }
-		} else if data[p] >= 65 {
-			goto st465
-		}
-	} else {
-		goto st465
-	}
-	goto st0
-st469:
-	p++
-	if p == pe { goto _test_eof469 }
-	fallthrough
-case 469:
-	switch data[p] {
-		case 10: goto tr321
-		case 32: goto tr322
-		case 125: goto tr323
-	}
-	if data[p] < 48 {
-		if 9 <= data[p] && data[p] <= 13 { goto tr320 }
-	} else if data[p] > 57 {
-		if data[p] > 70 {
-			if 97 <= data[p] && data[p] <= 102 { goto st470 }
-		} else if data[p] >= 65 {
-			goto st470
-		}
-	} else {
-		goto st470
-	}
-	goto st0
-st470:
-	p++
-	if p == pe { goto _test_eof470 }
-	fallthrough
-case 470:
-	switch data[p] {
-		case 10: goto tr321
-		case 32: goto tr322
-		case 58: goto st464
-		case 125: goto tr323
-	}
-	if data[p] < 48 {
-		if 9 <= data[p] && data[p] <= 13 { goto tr320 }
-	} else if data[p] > 57 {
-		if data[p] > 70 {
-			if 97 <= data[p] && data[p] <= 102 { goto st471 }
-		} else if data[p] >= 65 {
-			goto st471
-		}
-	} else {
-		goto st471
-	}
-	goto st0
-st471:
-	p++
-	if p == pe { goto _test_eof471 }
-	fallthrough
-case 471:
-	switch data[p] {
-		case 10: goto tr321
-		case 32: goto tr322
-		case 58: goto st464
-		case 125: goto tr323
-	}
-	if data[p] < 48 {
-		if 9 <= data[p] && data[p] <= 13 { goto tr320 }
-	} else if data[p] > 57 {
-		if data[p] > 70 {
-			if 97 <= data[p] && data[p] <= 102 { goto st472 }
-		} else if data[p] >= 65 {
-			goto st472
-		}
-	} else {
-		goto st472
-	}
-	goto st0
-st472:
-	p++
-	if p == pe { goto _test_eof472 }
-	fallthrough
-case 472:
-	switch data[p] {
-		case 10: goto tr321
-		case 32: goto tr322
-		case 58: goto st464
-		case 125: goto tr323
-	}
-	if data[p] < 48 {
-		if 9 <= data[p] && data[p] <= 13 { goto tr320 }
-	} else if data[p] > 57 {
-		if data[p] > 70 {
-			if 97 <= data[p] && data[p] <= 102 { goto st473 }
-		} else if data[p] >= 65 {
-			goto st473
-		}
-	} else {
-		goto st473
-	}
-	goto st0
-st473:
-	p++
-	if p == pe { goto _test_eof473 }
-	fallthrough
-case 473:
-	switch data[p] {
-		case 10: goto tr321
-		case 32: goto tr322
-		case 58: goto st464
-		case 125: goto tr323
-	}
-	if 9 <= data[p] && data[p] <= 13 { goto tr320 }
-	goto st0
-st474:
-	p++
-	if p == pe { goto _test_eof474 }
-	fallthrough
-case 474:
-	switch data[p] {
-		case 10: goto tr321
-		case 32: goto tr322
-		case 125: goto tr323
-	}
-	if data[p] < 48 {
-		if 9 <= data[p] && data[p] <= 13 { goto tr320 }
-	} else if data[p] > 57 {
-		if data[p] > 70 {
-			if 97 <= data[p] && data[p] <= 102 { goto st475 }
-		} else if data[p] >= 65 {
-			goto st475
-		}
-	} else {
-		goto st475
-	}
-	goto st0
-st475:
-	p++
-	if p == pe { goto _test_eof475 }
-	fallthrough
-case 475:
-	switch data[p] {
-		case 10: goto tr321
-		case 32: goto tr322
-		case 58: goto st479
-		case 125: goto tr323
-	}
-	if data[p] < 48 {
-		if 9 <= data[p] && data[p] <= 13 { goto tr320 }
-	} else if data[p] > 57 {
-		if data[p] > 70 {
-			if 97 <= data[p] && data[p] <= 102 { goto st476 }
-		} else if data[p] >= 65 {
-			goto st476
-		}
-	} else {
-		goto st476
-	}
-	goto st0
-st476:
-	p++
-	if p == pe { goto _test_eof476 }
-	fallthrough
-case 476:
-	switch data[p] {
-		case 10: goto tr321
-		case 32: goto tr322
-		case 58: goto st479
-		case 125: goto tr323
-	}
-	if data[p] < 48 {
-		if 9 <= data[p] && data[p] <= 13 { goto tr320 }
-	} else if data[p] > 57 {
-		if data[p] > 70 {
-			if 97 <= data[p] && data[p] <= 102 { goto st477 }
-		} else if data[p] >= 65 {
-			goto st477
-		}
-	} else {
-		goto st477
-	}
-	goto st0
-st477:
-	p++
-	if p == pe { goto _test_eof477 }
-	fallthrough
-case 477:
-	switch data[p] {
-		case 10: goto tr321
-		case 32: goto tr322
-		case 58: goto st479
-		case 125: goto tr323
-	}
-	if data[p] < 48 {
-		if 9 <= data[p] && data[p] <= 13 { goto tr320 }
-	} else if data[p] > 57 {
-		if data[p] > 70 {
-			if 97 <= data[p] && data[p] <= 102 { goto st478 }
-		} else if data[p] >= 65 {
-			goto st478
-		}
-	} else {
-		goto st478
-	}
-	goto st0
-st478:
-	p++
-	if p == pe { goto _test_eof478 }
-	fallthrough
-case 478:
-	switch data[p] {
-		case 10: goto tr321
-		case 32: goto tr322
-		case 58: goto st479
-		case 125: goto tr323
-	}
-	if 9 <= data[p] && data[p] <= 13 { goto tr320 }
-	goto st0
-st479:
-	p++
-	if p == pe { goto _test_eof479 }
-	fallthrough
-case 479:
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st480 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st480 }
-	} else {
-		goto st480
-	}
-	goto st0
-st480:
-	p++
-	if p == pe { goto _test_eof480 }
-	fallthrough
-case 480:
-	switch data[p] {
-		case 10: goto tr321
-		case 32: goto tr322
-		case 58: goto st484
-		case 125: goto tr323
-	}
-	if data[p] < 48 {
-		if 9 <= data[p] && data[p] <= 13 { goto tr320 }
-	} else if data[p] > 57 {
-		if data[p] > 70 {
-			if 97 <= data[p] && data[p] <= 102 { goto st481 }
-		} else if data[p] >= 65 {
-			goto st481
-		}
-	} else {
-		goto st481
-	}
-	goto st0
-st481:
-	p++
-	if p == pe { goto _test_eof481 }
-	fallthrough
-case 481:
-	switch data[p] {
-		case 10: goto tr321
-		case 32: goto tr322
-		case 58: goto st484
-		case 125: goto tr323
-	}
-	if data[p] < 48 {
-		if 9 <= data[p] && data[p] <= 13 { goto tr320 }
-	} else if data[p] > 57 {
-		if data[p] > 70 {
-			if 97 <= data[p] && data[p] <= 102 { goto st482 }
-		} else if data[p] >= 65 {
-			goto st482
-		}
-	} else {
-		goto st482
-	}
-	goto st0
-st482:
-	p++
-	if p == pe { goto _test_eof482 }
-	fallthrough
-case 482:
-	switch data[p] {
-		case 10: goto tr321
-		case 32: goto tr322
-		case 58: goto st484
-		case 125: goto tr323
-	}
-	if data[p] < 48 {
-		if 9 <= data[p] && data[p] <= 13 { goto tr320 }
-	} else if data[p] > 57 {
-		if data[p] > 70 {
-			if 97 <= data[p] && data[p] <= 102 { goto st483 }
-		} else if data[p] >= 65 {
-			goto st483
-		}
-	} else {
-		goto st483
-	}
-	goto st0
-st483:
-	p++
-	if p == pe { goto _test_eof483 }
-	fallthrough
-case 483:
-	switch data[p] {
-		case 10: goto tr321
-		case 32: goto tr322
-		case 58: goto st484
-		case 125: goto tr323
-	}
-	if 9 <= data[p] && data[p] <= 13 { goto tr320 }
-	goto st0
-st484:
-	p++
-	if p == pe { goto _test_eof484 }
-	fallthrough
-case 484:
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st485 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st485 }
-	} else {
-		goto st485
-	}
-	goto st0
-st485:
-	p++
-	if p == pe { goto _test_eof485 }
-	fallthrough
-case 485:
-	switch data[p] {
-		case 10: goto tr321
-		case 32: goto tr322
-		case 58: goto st489
-		case 125: goto tr323
-	}
-	if data[p] < 48 {
-		if 9 <= data[p] && data[p] <= 13 { goto tr320 }
-	} else if data[p] > 57 {
-		if data[p] > 70 {
-			if 97 <= data[p] && data[p] <= 102 { goto st486 }
-		} else if data[p] >= 65 {
-			goto st486
-		}
-	} else {
-		goto st486
-	}
-	goto st0
-st486:
-	p++
-	if p == pe { goto _test_eof486 }
-	fallthrough
-case 486:
-	switch data[p] {
-		case 10: goto tr321
-		case 32: goto tr322
-		case 58: goto st489
-		case 125: goto tr323
-	}
-	if data[p] < 48 {
-		if 9 <= data[p] && data[p] <= 13 { goto tr320 }
-	} else if data[p] > 57 {
-		if data[p] > 70 {
-			if 97 <= data[p] && data[p] <= 102 { goto st487 }
-		} else if data[p] >= 65 {
-			goto st487
-		}
-	} else {
-		goto st487
-	}
-	goto st0
-st487:
-	p++
-	if p == pe { goto _test_eof487 }
-	fallthrough
-case 487:
-	switch data[p] {
-		case 10: goto tr321
-		case 32: goto tr322
-		case 58: goto st489
-		case 125: goto tr323
-	}
-	if data[p] < 48 {
-		if 9 <= data[p] && data[p] <= 13 { goto tr320 }
-	} else if data[p] > 57 {
-		if data[p] > 70 {
-			if 97 <= data[p] && data[p] <= 102 { goto st488 }
-		} else if data[p] >= 65 {
-			goto st488
-		}
-	} else {
-		goto st488
-	}
-	goto st0
-st488:
-	p++
-	if p == pe { goto _test_eof488 }
-	fallthrough
-case 488:
-	switch data[p] {
-		case 10: goto tr321
-		case 32: goto tr322
-		case 58: goto st489
-		case 125: goto tr323
-	}
-	if 9 <= data[p] && data[p] <= 13 { goto tr320 }
-	goto st0
-st489:
-	p++
-	if p == pe { goto _test_eof489 }
-	fallthrough
-case 489:
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st470 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st470 }
-	} else {
-		goto st470
-	}
-	goto st0
-st490:
-	p++
-	if p == pe { goto _test_eof490 }
-	fallthrough
-case 490:
-	switch data[p] {
-		case 10: goto tr321
-		case 32: goto tr322
-		case 125: goto tr323
-	}
-	if data[p] < 48 {
-		if 9 <= data[p] && data[p] <= 13 { goto tr320 }
-	} else if data[p] > 57 {
-		if data[p] > 70 {
-			if 97 <= data[p] && data[p] <= 102 { goto st480 }
-		} else if data[p] >= 65 {
-			goto st480
-		}
-	} else {
-		goto st480
-	}
-	goto st0
-st491:
-	p++
-	if p == pe { goto _test_eof491 }
-	fallthrough
-case 491:
-	switch data[p] {
-		case 10: goto tr321
-		case 32: goto tr322
-		case 125: goto tr323
-	}
-	if data[p] < 48 {
-		if 9 <= data[p] && data[p] <= 13 { goto tr320 }
-	} else if data[p] > 57 {
-		if data[p] > 70 {
-			if 97 <= data[p] && data[p] <= 102 { goto st492 }
-		} else if data[p] >= 65 {
-			goto st492
-		}
-	} else {
-		goto st492
-	}
-	goto st0
-st492:
-	p++
-	if p == pe { goto _test_eof492 }
-	fallthrough
-case 492:
-	switch data[p] {
-		case 10: goto tr321
-		case 32: goto tr322
-		case 58: goto st496
-		case 125: goto tr323
-	}
-	if data[p] < 48 {
-		if 9 <= data[p] && data[p] <= 13 { goto tr320 }
-	} else if data[p] > 57 {
-		if data[p] > 70 {
-			if 97 <= data[p] && data[p] <= 102 { goto st493 }
-		} else if data[p] >= 65 {
-			goto st493
-		}
-	} else {
-		goto st493
-	}
-	goto st0
-st493:
-	p++
-	if p == pe { goto _test_eof493 }
-	fallthrough
-case 493:
-	switch data[p] {
-		case 10: goto tr321
-		case 32: goto tr322
-		case 58: goto st496
-		case 125: goto tr323
-	}
-	if data[p] < 48 {
-		if 9 <= data[p] && data[p] <= 13 { goto tr320 }
-	} else if data[p] > 57 {
-		if data[p] > 70 {
-			if 97 <= data[p] && data[p] <= 102 { goto st494 }
-		} else if data[p] >= 65 {
-			goto st494
-		}
-	} else {
-		goto st494
-	}
-	goto st0
-st494:
-	p++
-	if p == pe { goto _test_eof494 }
-	fallthrough
-case 494:
-	switch data[p] {
-		case 10: goto tr321
-		case 32: goto tr322
-		case 58: goto st496
-		case 125: goto tr323
-	}
-	if data[p] < 48 {
-		if 9 <= data[p] && data[p] <= 13 { goto tr320 }
-	} else if data[p] > 57 {
-		if data[p] > 70 {
-			if 97 <= data[p] && data[p] <= 102 { goto st495 }
-		} else if data[p] >= 65 {
-			goto st495
-		}
-	} else {
-		goto st495
-	}
-	goto st0
-st495:
-	p++
-	if p == pe { goto _test_eof495 }
-	fallthrough
-case 495:
-	switch data[p] {
-		case 10: goto tr321
-		case 32: goto tr322
-		case 58: goto st496
-		case 125: goto tr323
-	}
-	if 9 <= data[p] && data[p] <= 13 { goto tr320 }
-	goto st0
-st496:
-	p++
-	if p == pe { goto _test_eof496 }
-	fallthrough
-case 496:
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st475 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st475 }
-	} else {
-		goto st475
-	}
-	goto st0
-st497:
-	p++
-	if p == pe { goto _test_eof497 }
-	fallthrough
-case 497:
-	if data[p] == 58 { goto st434 }
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st433 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st433 }
-	} else {
-		goto st433
-	}
-	goto st0
-st498:
-	p++
-	if p == pe { goto _test_eof498 }
-	fallthrough
-case 498:
-	if data[p] == 58 { goto st434 }
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st497 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st497 }
-	} else {
-		goto st497
-	}
-	goto st0
-tr301:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st499
-st499:
-	p++
-	if p == pe { goto _test_eof499 }
-	fallthrough
-case 499:
-// line 6407 "parser.go"
-	switch data[p] {
-		case 46: goto st251
-		case 53: goto st500
-		case 58: goto st434
-	}
-	if data[p] < 54 {
-		if 48 <= data[p] && data[p] <= 52 { goto st431 }
-	} else if data[p] > 57 {
-		if data[p] > 70 {
-			if 97 <= data[p] && data[p] <= 102 { goto st498 }
-		} else if data[p] >= 65 {
-			goto st498
-		}
-	} else {
-		goto st501
-	}
-	goto st0
-st500:
-	p++
-	if p == pe { goto _test_eof500 }
-	fallthrough
-case 500:
-	switch data[p] {
-		case 46: goto st251
-		case 58: goto st434
-	}
-	if data[p] < 54 {
-		if 48 <= data[p] && data[p] <= 53 { goto st432 }
-	} else if data[p] > 57 {
-		if data[p] > 70 {
-			if 97 <= data[p] && data[p] <= 102 { goto st497 }
-		} else if data[p] >= 65 {
-			goto st497
-		}
-	} else {
-		goto st497
-	}
-	goto st0
-st501:
-	p++
-	if p == pe { goto _test_eof501 }
-	fallthrough
-case 501:
-	switch data[p] {
-		case 46: goto st251
-		case 58: goto st434
-	}
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st497 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st497 }
-	} else {
-		goto st497
-	}
-	goto st0
-tr302:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st502
-st502:
-	p++
-	if p == pe { goto _test_eof502 }
-	fallthrough
-case 502:
-// line 6472 "parser.go"
-	switch data[p] {
-		case 46: goto st251
-		case 58: goto st434
-	}
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st501 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st498 }
-	} else {
-		goto st498
-	}
-	goto st0
-tr303:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st503
-st503:
-	p++
-	if p == pe { goto _test_eof503 }
-	fallthrough
-case 503:
-// line 6494 "parser.go"
-	if data[p] == 58 { goto st491 }
-	goto st0
-tr304:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st504
-st504:
-	p++
-	if p == pe { goto _test_eof504 }
-	fallthrough
-case 504:
-// line 6506 "parser.go"
-	if data[p] == 58 { goto st434 }
-	if data[p] < 65 {
-		if 48 <= data[p] && data[p] <= 57 { goto st498 }
-	} else if data[p] > 70 {
-		if 97 <= data[p] && data[p] <= 102 { goto st498 }
-	} else {
-		goto st498
-	}
-	goto st0
-st505:
-	p++
-	if p == pe { goto _test_eof505 }
-	fallthrough
-case 505:
-	if data[p] == 108 { goto st506 }
-	goto st0
-st506:
-	p++
-	if p == pe { goto _test_eof506 }
-	fallthrough
-case 506:
-	if data[p] == 97 { goto st507 }
-	goto st0
-st507:
-	p++
-	if p == pe { goto _test_eof507 }
-	fallthrough
-case 507:
-	if data[p] == 115 { goto st508 }
-	goto st0
-st508:
-	p++
-	if p == pe { goto _test_eof508 }
-	fallthrough
-case 508:
-	if data[p] == 115 { goto st509 }
-	goto st0
-st509:
-	p++
-	if p == pe { goto _test_eof509 }
-	fallthrough
-case 509:
-	if data[p] == 32 { goto st510 }
-	goto st0
-st510:
-	p++
-	if p == pe { goto _test_eof510 }
-	fallthrough
-case 510:
-	switch data[p] {
-		case 32: goto st510
-		case 61: goto st511
-	}
-	goto st0
-st511:
-	p++
-	if p == pe { goto _test_eof511 }
-	fallthrough
-case 511:
-	if data[p] == 32 { goto st512 }
-	goto st0
-st512:
-	p++
-	if p == pe { goto _test_eof512 }
-	fallthrough
-case 512:
-	switch data[p] {
-		case 32: goto st512
-		case 99: goto tr575
-		case 115: goto tr576
-	}
-	goto st0
-tr575:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st513
-st513:
-	p++
-	if p == pe { goto _test_eof513 }
-	fallthrough
-case 513:
-// line 6588 "parser.go"
-	if data[p] == 108 { goto st514 }
-	goto st0
-st514:
-	p++
-	if p == pe { goto _test_eof514 }
-	fallthrough
-case 514:
-	if data[p] == 105 { goto st515 }
-	goto st0
-st515:
-	p++
-	if p == pe { goto _test_eof515 }
-	fallthrough
-case 515:
-	if data[p] == 101 { goto st516 }
-	goto st0
-st516:
-	p++
-	if p == pe { goto _test_eof516 }
-	fallthrough
-case 516:
-	if data[p] == 110 { goto st517 }
-	goto st0
-st517:
-	p++
-	if p == pe { goto _test_eof517 }
-	fallthrough
-case 517:
-	if data[p] == 116 { goto st518 }
-	goto st0
-st518:
-	p++
-	if p == pe { goto _test_eof518 }
-	fallthrough
-case 518:
-	switch data[p] {
-		case 10: goto tr448
-		case 32: goto tr583
-		case 125: goto tr584
-	}
-	if 9 <= data[p] && data[p] <= 13 { goto tr582 }
-	goto st0
-tr576:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st519
-st519:
-	p++
-	if p == pe { goto _test_eof519 }
-	fallthrough
-case 519:
-// line 6640 "parser.go"
-	if data[p] == 101 { goto st520 }
-	goto st0
-st520:
-	p++
-	if p == pe { goto _test_eof520 }
-	fallthrough
-case 520:
-	if data[p] == 114 { goto st521 }
-	goto st0
-st521:
-	p++
-	if p == pe { goto _test_eof521 }
-	fallthrough
-case 521:
-	if data[p] == 118 { goto st522 }
-	goto st0
-st522:
-	p++
-	if p == pe { goto _test_eof522 }
-	fallthrough
-case 522:
-	if data[p] == 101 { goto st523 }
-	goto st0
-st523:
-	p++
-	if p == pe { goto _test_eof523 }
-	fallthrough
-case 523:
-	if data[p] == 114 { goto st518 }
-	goto st0
-st524:
-	p++
-	if p == pe { goto _test_eof524 }
-	fallthrough
-case 524:
-	if data[p] == 115 { goto st525 }
-	goto st0
-st525:
-	p++
-	if p == pe { goto _test_eof525 }
-	fallthrough
-case 525:
-	if data[p] == 108 { goto st526 }
-	goto st0
-st526:
-	p++
-	if p == pe { goto _test_eof526 }
-	fallthrough
-case 526:
-	if data[p] == 32 { goto st527 }
-	goto st0
-st527:
-	p++
-	if p == pe { goto _test_eof527 }
-	fallthrough
-case 527:
-	switch data[p] {
-		case 32: goto st527
-		case 61: goto st528
-	}
-	goto st0
-st528:
-	p++
-	if p == pe { goto _test_eof528 }
-	fallthrough
-case 528:
-	if data[p] == 32 { goto st529 }
-	goto st0
-st529:
-	p++
-	if p == pe { goto _test_eof529 }
-	fallthrough
-case 529:
-	switch data[p] {
-		case 32: goto st529
-		case 102: goto tr595
-		case 110: goto tr596
-		case 111: goto tr597
-		case 116: goto tr598
-		case 121: goto tr599
-	}
-	if 48 <= data[p] && data[p] <= 49 { goto tr594 }
-	goto st0
-tr594:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st530
-st530:
-	p++
-	if p == pe { goto _test_eof530 }
-	fallthrough
-case 530:
-// line 6733 "parser.go"
-	switch data[p] {
-		case 10: goto tr465
-		case 32: goto tr601
-		case 125: goto tr602
-	}
-	if 9 <= data[p] && data[p] <= 13 { goto tr600 }
-	goto st0
-tr595:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st531
-st531:
-	p++
-	if p == pe { goto _test_eof531 }
-	fallthrough
-case 531:
-// line 6750 "parser.go"
-	if data[p] == 97 { goto st532 }
-	goto st0
-st532:
-	p++
-	if p == pe { goto _test_eof532 }
-	fallthrough
-case 532:
-	if data[p] == 108 { goto st533 }
-	goto st0
-st533:
-	p++
-	if p == pe { goto _test_eof533 }
-	fallthrough
-case 533:
-	if data[p] == 115 { goto st534 }
-	goto st0
-st534:
-	p++
-	if p == pe { goto _test_eof534 }
-	fallthrough
-case 534:
-	if data[p] == 101 { goto st530 }
-	goto st0
-tr596:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st535
-st535:
-	p++
-	if p == pe { goto _test_eof535 }
-	fallthrough
-case 535:
-// line 6783 "parser.go"
-	if data[p] == 111 { goto st530 }
-	goto st0
-tr597:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st536
-st536:
-	p++
-	if p == pe { goto _test_eof536 }
-	fallthrough
-case 536:
-// line 6795 "parser.go"
-	switch data[p] {
-		case 102: goto st537
-		case 110: goto st530
-	}
-	goto st0
-st537:
-	p++
-	if p == pe { goto _test_eof537 }
-	fallthrough
-case 537:
-	if data[p] == 102 { goto st530 }
-	goto st0
-tr598:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st538
-st538:
-	p++
-	if p == pe { goto _test_eof538 }
-	fallthrough
-case 538:
-// line 6817 "parser.go"
-	if data[p] == 114 { goto st539 }
-	goto st0
-st539:
-	p++
-	if p == pe { goto _test_eof539 }
-	fallthrough
-case 539:
-	if data[p] == 117 { goto st534 }
-	goto st0
-tr599:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st540
-st540:
-	p++
-	if p == pe { goto _test_eof540 }
-	fallthrough
-case 540:
-// line 6836 "parser.go"
-	if data[p] == 101 { goto st541 }
-	goto st0
-st541:
-	p++
-	if p == pe { goto _test_eof541 }
-	fallthrough
-case 541:
-	if data[p] == 115 { goto st530 }
-	goto st0
-st542:
-	p++
-	if p == pe { goto _test_eof542 }
-	fallthrough
-case 542:
-	if data[p] == 105 { goto st543 }
-	goto st0
-st543:
-	p++
-	if p == pe { goto _test_eof543 }
-	fallthrough
-case 543:
-	if data[p] == 112 { goto st544 }
-	goto st0
-st544:
-	p++
-	if p == pe { goto _test_eof544 }
-	fallthrough
-case 544:
-	if data[p] == 32 { goto st545 }
-	goto st0
-st545:
-	p++
-	if p == pe { goto _test_eof545 }
-	fallthrough
-case 545:
-	switch data[p] {
-		case 32: goto st545
-		case 61: goto st546
-	}
-	goto st0
-st546:
-	p++
-	if p == pe { goto _test_eof546 }
-	fallthrough
-case 546:
-	if data[p] == 32 { goto st547 }
-	goto st0
-st547:
-	p++
-	if p == pe { goto _test_eof547 }
-	fallthrough
-case 547:
-	switch data[p] {
-		case 32: goto st547
-		case 102: goto tr616
-		case 110: goto tr617
-		case 111: goto tr618
-		case 116: goto tr619
-		case 121: goto tr620
-	}
-	if 48 <= data[p] && data[p] <= 49 { goto tr615 }
-	goto st0
-tr615:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st548
-st548:
-	p++
-	if p == pe { goto _test_eof548 }
-	fallthrough
-case 548:
-// line 6908 "parser.go"
-	switch data[p] {
-		case 10: goto tr485
-		case 32: goto tr622
-		case 125: goto tr623
-	}
-	if 9 <= data[p] && data[p] <= 13 { goto tr621 }
-	goto st0
-tr616:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st549
-st549:
-	p++
-	if p == pe { goto _test_eof549 }
-	fallthrough
-case 549:
-// line 6925 "parser.go"
-	if data[p] == 97 { goto st550 }
-	goto st0
-st550:
-	p++
-	if p == pe { goto _test_eof550 }
-	fallthrough
-case 550:
-	if data[p] == 108 { goto st551 }
-	goto st0
-st551:
-	p++
-	if p == pe { goto _test_eof551 }
-	fallthrough
-case 551:
-	if data[p] == 115 { goto st552 }
-	goto st0
-st552:
-	p++
-	if p == pe { goto _test_eof552 }
-	fallthrough
-case 552:
-	if data[p] == 101 { goto st548 }
-	goto st0
-tr617:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st553
-st553:
-	p++
-	if p == pe { goto _test_eof553 }
-	fallthrough
-case 553:
-// line 6958 "parser.go"
-	if data[p] == 111 { goto st548 }
-	goto st0
-tr618:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st554
-st554:
-	p++
-	if p == pe { goto _test_eof554 }
-	fallthrough
-case 554:
-// line 6970 "parser.go"
-	switch data[p] {
-		case 102: goto st555
-		case 110: goto st548
-	}
-	goto st0
-st555:
-	p++
-	if p == pe { goto _test_eof555 }
-	fallthrough
-case 555:
-	if data[p] == 102 { goto st548 }
-	goto st0
-tr619:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st556
-st556:
-	p++
-	if p == pe { goto _test_eof556 }
-	fallthrough
-case 556:
-// line 6992 "parser.go"
-	if data[p] == 114 { goto st557 }
-	goto st0
-st557:
-	p++
-	if p == pe { goto _test_eof557 }
-	fallthrough
-case 557:
-	if data[p] == 117 { goto st552 }
-	goto st0
-tr620:
-// line 41 "parser.rl"
-	{ mark = p }
-	goto st558
-st558:
-	p++
-	if p == pe { goto _test_eof558 }
-	fallthrough
-case 558:
-// line 7011 "parser.go"
-	if data[p] == 101 { goto st559 }
-	goto st0
-st559:
-	p++
-	if p == pe { goto _test_eof559 }
-	fallthrough
-case 559:
-	if data[p] == 115 { goto st548 }
-	goto st0
-	}
-	_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_eof560: cs = 560; goto _test_eof; 
-	_test_eof561: cs = 561; 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_eof562: cs = 562; goto _test_eof; 
-	_test_eof25: cs = 25; goto _test_eof; 
-	_test_eof26: cs = 26; goto _test_eof; 
-	_test_eof27: cs = 27; goto _test_eof; 
-	_test_eof28: cs = 28; goto _test_eof; 
-	_test_eof29: cs = 29; goto _test_eof; 
-	_test_eof30: cs = 30; goto _test_eof; 
-	_test_eof31: cs = 31; goto _test_eof; 
-	_test_eof32: cs = 32; goto _test_eof; 
-	_test_eof33: cs = 33; goto _test_eof; 
-	_test_eof34: cs = 34; goto _test_eof; 
-	_test_eof35: cs = 35; goto _test_eof; 
-	_test_eof36: cs = 36; goto _test_eof; 
-	_test_eof37: cs = 37; goto _test_eof; 
-	_test_eof38: cs = 38; goto _test_eof; 
-	_test_eof39: cs = 39; goto _test_eof; 
-	_test_eof40: cs = 40; goto _test_eof; 
-	_test_eof41: cs = 41; goto _test_eof; 
-	_test_eof42: cs = 42; goto _test_eof; 
-	_test_eof43: cs = 43; goto _test_eof; 
-	_test_eof44: cs = 44; goto _test_eof; 
-	_test_eof45: cs = 45; goto _test_eof; 
-	_test_eof46: cs = 46; goto _test_eof; 
-	_test_eof47: cs = 47; goto _test_eof; 
-	_test_eof48: cs = 48; goto _test_eof; 
-	_test_eof49: cs = 49; goto _test_eof; 
-	_test_eof50: cs = 50; goto _test_eof; 
-	_test_eof51: cs = 51; goto _test_eof; 
-	_test_eof52: cs = 52; goto _test_eof; 
-	_test_eof53: cs = 53; goto _test_eof; 
-	_test_eof54: cs = 54; goto _test_eof; 
-	_test_eof55: cs = 55; goto _test_eof; 
-	_test_eof56: cs = 56; goto _test_eof; 
-	_test_eof57: cs = 57; goto _test_eof; 
-	_test_eof58: cs = 58; goto _test_eof; 
-	_test_eof59: cs = 59; goto _test_eof; 
-	_test_eof60: cs = 60; goto _test_eof; 
-	_test_eof61: cs = 61; goto _test_eof; 
-	_test_eof62: cs = 62; goto _test_eof; 
-	_test_eof63: cs = 63; goto _test_eof; 
-	_test_eof64: cs = 64; goto _test_eof; 
-	_test_eof65: cs = 65; goto _test_eof; 
-	_test_eof66: cs = 66; goto _test_eof; 
-	_test_eof67: cs = 67; goto _test_eof; 
-	_test_eof68: cs = 68; goto _test_eof; 
-	_test_eof69: cs = 69; goto _test_eof; 
-	_test_eof70: cs = 70; goto _test_eof; 
-	_test_eof71: cs = 71; goto _test_eof; 
-	_test_eof72: cs = 72; goto _test_eof; 
-	_test_eof73: cs = 73; goto _test_eof; 
-	_test_eof74: cs = 74; goto _test_eof; 
-	_test_eof75: cs = 75; goto _test_eof; 
-	_test_eof76: cs = 76; goto _test_eof; 
-	_test_eof77: cs = 77; goto _test_eof; 
-	_test_eof78: cs = 78; goto _test_eof; 
-	_test_eof79: cs = 79; goto _test_eof; 
-	_test_eof80: cs = 80; goto _test_eof; 
-	_test_eof81: cs = 81; goto _test_eof; 
-	_test_eof82: cs = 82; goto _test_eof; 
-	_test_eof83: cs = 83; goto _test_eof; 
-	_test_eof84: cs = 84; goto _test_eof; 
-	_test_eof85: cs = 85; goto _test_eof; 
-	_test_eof86: cs = 86; goto _test_eof; 
-	_test_eof87: cs = 87; goto _test_eof; 
-	_test_eof88: cs = 88; goto _test_eof; 
-	_test_eof89: cs = 89; goto _test_eof; 
-	_test_eof90: cs = 90; goto _test_eof; 
-	_test_eof91: cs = 91; goto _test_eof; 
-	_test_eof92: cs = 92; goto _test_eof; 
-	_test_eof93: cs = 93; goto _test_eof; 
-	_test_eof94: cs = 94; goto _test_eof; 
-	_test_eof95: cs = 95; goto _test_eof; 
-	_test_eof96: cs = 96; goto _test_eof; 
-	_test_eof97: cs = 97; goto _test_eof; 
-	_test_eof98: cs = 98; goto _test_eof; 
-	_test_eof99: cs = 99; goto _test_eof; 
-	_test_eof100: cs = 100; goto _test_eof; 
-	_test_eof101: cs = 101; goto _test_eof; 
-	_test_eof102: cs = 102; goto _test_eof; 
-	_test_eof103: cs = 103; goto _test_eof; 
-	_test_eof104: cs = 104; goto _test_eof; 
-	_test_eof105: cs = 105; goto _test_eof; 
-	_test_eof106: cs = 106; goto _test_eof; 
-	_test_eof107: cs = 107; goto _test_eof; 
-	_test_eof108: cs = 108; goto _test_eof; 
-	_test_eof109: cs = 109; goto _test_eof; 
-	_test_eof110: cs = 110; goto _test_eof; 
-	_test_eof111: cs = 111; goto _test_eof; 
-	_test_eof112: cs = 112; goto _test_eof; 
-	_test_eof113: cs = 113; goto _test_eof; 
-	_test_eof114: cs = 114; goto _test_eof; 
-	_test_eof115: cs = 115; goto _test_eof; 
-	_test_eof116: cs = 116; goto _test_eof; 
-	_test_eof117: cs = 117; goto _test_eof; 
-	_test_eof118: cs = 118; goto _test_eof; 
-	_test_eof119: cs = 119; goto _test_eof; 
-	_test_eof120: cs = 120; goto _test_eof; 
-	_test_eof121: cs = 121; goto _test_eof; 
-	_test_eof122: cs = 122; goto _test_eof; 
-	_test_eof123: cs = 123; goto _test_eof; 
-	_test_eof124: cs = 124; goto _test_eof; 
-	_test_eof125: cs = 125; goto _test_eof; 
-	_test_eof126: cs = 126; goto _test_eof; 
-	_test_eof127: cs = 127; goto _test_eof; 
-	_test_eof128: cs = 128; goto _test_eof; 
-	_test_eof129: cs = 129; goto _test_eof; 
-	_test_eof130: cs = 130; goto _test_eof; 
-	_test_eof131: cs = 131; goto _test_eof; 
-	_test_eof132: cs = 132; goto _test_eof; 
-	_test_eof133: cs = 133; goto _test_eof; 
-	_test_eof134: cs = 134; goto _test_eof; 
-	_test_eof135: cs = 135; goto _test_eof; 
-	_test_eof136: cs = 136; goto _test_eof; 
-	_test_eof137: cs = 137; goto _test_eof; 
-	_test_eof138: cs = 138; goto _test_eof; 
-	_test_eof139: cs = 139; goto _test_eof; 
-	_test_eof140: cs = 140; goto _test_eof; 
-	_test_eof141: cs = 141; goto _test_eof; 
-	_test_eof142: cs = 142; goto _test_eof; 
-	_test_eof143: cs = 143; goto _test_eof; 
-	_test_eof144: cs = 144; goto _test_eof; 
-	_test_eof145: cs = 145; goto _test_eof; 
-	_test_eof146: cs = 146; goto _test_eof; 
-	_test_eof147: cs = 147; goto _test_eof; 
-	_test_eof148: cs = 148; goto _test_eof; 
-	_test_eof149: cs = 149; goto _test_eof; 
-	_test_eof150: cs = 150; goto _test_eof; 
-	_test_eof151: cs = 151; goto _test_eof; 
-	_test_eof152: cs = 152; goto _test_eof; 
-	_test_eof153: cs = 153; goto _test_eof; 
-	_test_eof154: cs = 154; goto _test_eof; 
-	_test_eof155: cs = 155; goto _test_eof; 
-	_test_eof156: cs = 156; goto _test_eof; 
-	_test_eof157: cs = 157; goto _test_eof; 
-	_test_eof158: cs = 158; goto _test_eof; 
-	_test_eof159: cs = 159; goto _test_eof; 
-	_test_eof160: cs = 160; goto _test_eof; 
-	_test_eof161: cs = 161; goto _test_eof; 
-	_test_eof162: cs = 162; goto _test_eof; 
-	_test_eof163: cs = 163; goto _test_eof; 
-	_test_eof164: cs = 164; goto _test_eof; 
-	_test_eof165: cs = 165; goto _test_eof; 
-	_test_eof166: cs = 166; goto _test_eof; 
-	_test_eof167: cs = 167; goto _test_eof; 
-	_test_eof168: cs = 168; goto _test_eof; 
-	_test_eof169: cs = 169; goto _test_eof; 
-	_test_eof170: cs = 170; goto _test_eof; 
-	_test_eof171: cs = 171; goto _test_eof; 
-	_test_eof172: cs = 172; goto _test_eof; 
-	_test_eof173: cs = 173; goto _test_eof; 
-	_test_eof174: cs = 174; goto _test_eof; 
-	_test_eof175: cs = 175; goto _test_eof; 
-	_test_eof176: cs = 176; goto _test_eof; 
-	_test_eof177: cs = 177; goto _test_eof; 
-	_test_eof178: cs = 178; goto _test_eof; 
-	_test_eof179: cs = 179; goto _test_eof; 
-	_test_eof180: cs = 180; goto _test_eof; 
-	_test_eof181: cs = 181; goto _test_eof; 
-	_test_eof182: cs = 182; goto _test_eof; 
-	_test_eof183: cs = 183; goto _test_eof; 
-	_test_eof184: cs = 184; goto _test_eof; 
-	_test_eof185: cs = 185; goto _test_eof; 
-	_test_eof186: cs = 186; goto _test_eof; 
-	_test_eof187: cs = 187; goto _test_eof; 
-	_test_eof188: cs = 188; goto _test_eof; 
-	_test_eof189: cs = 189; goto _test_eof; 
-	_test_eof190: cs = 190; goto _test_eof; 
-	_test_eof191: cs = 191; goto _test_eof; 
-	_test_eof192: cs = 192; goto _test_eof; 
-	_test_eof193: cs = 193; goto _test_eof; 
-	_test_eof194: cs = 194; goto _test_eof; 
-	_test_eof195: cs = 195; goto _test_eof; 
-	_test_eof196: cs = 196; goto _test_eof; 
-	_test_eof197: cs = 197; goto _test_eof; 
-	_test_eof198: cs = 198; goto _test_eof; 
-	_test_eof199: cs = 199; goto _test_eof; 
-	_test_eof200: cs = 200; goto _test_eof; 
-	_test_eof201: cs = 201; goto _test_eof; 
-	_test_eof202: cs = 202; goto _test_eof; 
-	_test_eof203: cs = 203; goto _test_eof; 
-	_test_eof204: cs = 204; goto _test_eof; 
-	_test_eof205: cs = 205; goto _test_eof; 
-	_test_eof563: cs = 563; goto _test_eof; 
-	_test_eof564: cs = 564; goto _test_eof; 
-	_test_eof565: cs = 565; goto _test_eof; 
-	_test_eof206: cs = 206; goto _test_eof; 
-	_test_eof566: cs = 566; goto _test_eof; 
-	_test_eof207: cs = 207; goto _test_eof; 
-	_test_eof208: cs = 208; goto _test_eof; 
-	_test_eof209: cs = 209; goto _test_eof; 
-	_test_eof210: cs = 210; goto _test_eof; 
-	_test_eof211: cs = 211; goto _test_eof; 
-	_test_eof212: cs = 212; goto _test_eof; 
-	_test_eof213: cs = 213; goto _test_eof; 
-	_test_eof214: cs = 214; goto _test_eof; 
-	_test_eof215: cs = 215; goto _test_eof; 
-	_test_eof216: cs = 216; goto _test_eof; 
-	_test_eof217: cs = 217; goto _test_eof; 
-	_test_eof218: cs = 218; goto _test_eof; 
-	_test_eof219: cs = 219; goto _test_eof; 
-	_test_eof220: cs = 220; goto _test_eof; 
-	_test_eof221: cs = 221; goto _test_eof; 
-	_test_eof222: cs = 222; goto _test_eof; 
-	_test_eof223: cs = 223; goto _test_eof; 
-	_test_eof224: cs = 224; goto _test_eof; 
-	_test_eof225: cs = 225; goto _test_eof; 
-	_test_eof226: cs = 226; goto _test_eof; 
-	_test_eof227: cs = 227; goto _test_eof; 
-	_test_eof228: cs = 228; goto _test_eof; 
-	_test_eof229: cs = 229; goto _test_eof; 
-	_test_eof230: cs = 230; goto _test_eof; 
-	_test_eof231: cs = 231; goto _test_eof; 
-	_test_eof232: cs = 232; goto _test_eof; 
-	_test_eof233: cs = 233; goto _test_eof; 
-	_test_eof234: cs = 234; goto _test_eof; 
-	_test_eof235: cs = 235; goto _test_eof; 
-	_test_eof236: cs = 236; goto _test_eof; 
-	_test_eof237: cs = 237; goto _test_eof; 
-	_test_eof238: cs = 238; goto _test_eof; 
-	_test_eof239: cs = 239; goto _test_eof; 
-	_test_eof240: cs = 240; goto _test_eof; 
-	_test_eof241: cs = 241; goto _test_eof; 
-	_test_eof242: cs = 242; goto _test_eof; 
-	_test_eof243: cs = 243; goto _test_eof; 
-	_test_eof244: cs = 244; goto _test_eof; 
-	_test_eof245: cs = 245; goto _test_eof; 
-	_test_eof246: cs = 246; goto _test_eof; 
-	_test_eof247: cs = 247; goto _test_eof; 
-	_test_eof248: cs = 248; goto _test_eof; 
-	_test_eof249: cs = 249; goto _test_eof; 
-	_test_eof250: cs = 250; goto _test_eof; 
-	_test_eof251: cs = 251; goto _test_eof; 
-	_test_eof252: cs = 252; goto _test_eof; 
-	_test_eof253: cs = 253; goto _test_eof; 
-	_test_eof254: cs = 254; goto _test_eof; 
-	_test_eof255: cs = 255; goto _test_eof; 
-	_test_eof256: cs = 256; goto _test_eof; 
-	_test_eof257: cs = 257; goto _test_eof; 
-	_test_eof258: cs = 258; goto _test_eof; 
-	_test_eof259: cs = 259; goto _test_eof; 
-	_test_eof260: cs = 260; goto _test_eof; 
-	_test_eof261: cs = 261; goto _test_eof; 
-	_test_eof262: cs = 262; goto _test_eof; 
-	_test_eof263: cs = 263; goto _test_eof; 
-	_test_eof264: cs = 264; goto _test_eof; 
-	_test_eof265: cs = 265; goto _test_eof; 
-	_test_eof266: cs = 266; goto _test_eof; 
-	_test_eof267: cs = 267; goto _test_eof; 
-	_test_eof268: cs = 268; goto _test_eof; 
-	_test_eof269: cs = 269; goto _test_eof; 
-	_test_eof270: cs = 270; goto _test_eof; 
-	_test_eof271: cs = 271; goto _test_eof; 
-	_test_eof272: cs = 272; goto _test_eof; 
-	_test_eof273: cs = 273; goto _test_eof; 
-	_test_eof274: cs = 274; goto _test_eof; 
-	_test_eof275: cs = 275; goto _test_eof; 
-	_test_eof276: cs = 276; goto _test_eof; 
-	_test_eof277: cs = 277; goto _test_eof; 
-	_test_eof278: cs = 278; goto _test_eof; 
-	_test_eof279: cs = 279; goto _test_eof; 
-	_test_eof280: cs = 280; goto _test_eof; 
-	_test_eof281: cs = 281; goto _test_eof; 
-	_test_eof282: cs = 282; goto _test_eof; 
-	_test_eof283: cs = 283; goto _test_eof; 
-	_test_eof284: cs = 284; goto _test_eof; 
-	_test_eof285: cs = 285; goto _test_eof; 
-	_test_eof286: cs = 286; goto _test_eof; 
-	_test_eof287: cs = 287; goto _test_eof; 
-	_test_eof288: cs = 288; goto _test_eof; 
-	_test_eof289: cs = 289; goto _test_eof; 
-	_test_eof290: cs = 290; goto _test_eof; 
-	_test_eof291: cs = 291; goto _test_eof; 
-	_test_eof292: cs = 292; goto _test_eof; 
-	_test_eof293: cs = 293; goto _test_eof; 
-	_test_eof294: cs = 294; goto _test_eof; 
-	_test_eof295: cs = 295; goto _test_eof; 
-	_test_eof296: cs = 296; goto _test_eof; 
-	_test_eof297: cs = 297; goto _test_eof; 
-	_test_eof298: cs = 298; goto _test_eof; 
-	_test_eof299: cs = 299; goto _test_eof; 
-	_test_eof300: cs = 300; goto _test_eof; 
-	_test_eof301: cs = 301; goto _test_eof; 
-	_test_eof302: cs = 302; goto _test_eof; 
-	_test_eof303: cs = 303; goto _test_eof; 
-	_test_eof304: cs = 304; goto _test_eof; 
-	_test_eof305: cs = 305; goto _test_eof; 
-	_test_eof306: cs = 306; goto _test_eof; 
-	_test_eof307: cs = 307; goto _test_eof; 
-	_test_eof308: cs = 308; goto _test_eof; 
-	_test_eof309: cs = 309; goto _test_eof; 
-	_test_eof310: cs = 310; goto _test_eof; 
-	_test_eof311: cs = 311; goto _test_eof; 
-	_test_eof312: cs = 312; goto _test_eof; 
-	_test_eof313: cs = 313; goto _test_eof; 
-	_test_eof314: cs = 314; goto _test_eof; 
-	_test_eof315: cs = 315; goto _test_eof; 
-	_test_eof316: cs = 316; goto _test_eof; 
-	_test_eof317: cs = 317; goto _test_eof; 
-	_test_eof318: cs = 318; goto _test_eof; 
-	_test_eof319: cs = 319; goto _test_eof; 
-	_test_eof320: cs = 320; goto _test_eof; 
-	_test_eof321: cs = 321; goto _test_eof; 
-	_test_eof322: cs = 322; goto _test_eof; 
-	_test_eof323: cs = 323; goto _test_eof; 
-	_test_eof324: cs = 324; goto _test_eof; 
-	_test_eof325: cs = 325; goto _test_eof; 
-	_test_eof326: cs = 326; goto _test_eof; 
-	_test_eof327: cs = 327; goto _test_eof; 
-	_test_eof328: cs = 328; goto _test_eof; 
-	_test_eof329: cs = 329; goto _test_eof; 
-	_test_eof330: cs = 330; goto _test_eof; 
-	_test_eof331: cs = 331; goto _test_eof; 
-	_test_eof332: cs = 332; goto _test_eof; 
-	_test_eof333: cs = 333; goto _test_eof; 
-	_test_eof334: cs = 334; goto _test_eof; 
-	_test_eof335: cs = 335; goto _test_eof; 
-	_test_eof336: cs = 336; goto _test_eof; 
-	_test_eof337: cs = 337; goto _test_eof; 
-	_test_eof338: cs = 338; goto _test_eof; 
-	_test_eof339: cs = 339; goto _test_eof; 
-	_test_eof340: cs = 340; goto _test_eof; 
-	_test_eof341: cs = 341; goto _test_eof; 
-	_test_eof342: cs = 342; goto _test_eof; 
-	_test_eof343: cs = 343; goto _test_eof; 
-	_test_eof344: cs = 344; goto _test_eof; 
-	_test_eof345: cs = 345; goto _test_eof; 
-	_test_eof346: cs = 346; goto _test_eof; 
-	_test_eof347: cs = 347; goto _test_eof; 
-	_test_eof348: cs = 348; goto _test_eof; 
-	_test_eof349: cs = 349; goto _test_eof; 
-	_test_eof350: cs = 350; goto _test_eof; 
-	_test_eof351: cs = 351; goto _test_eof; 
-	_test_eof352: cs = 352; goto _test_eof; 
-	_test_eof353: cs = 353; goto _test_eof; 
-	_test_eof354: cs = 354; goto _test_eof; 
-	_test_eof355: cs = 355; goto _test_eof; 
-	_test_eof356: cs = 356; goto _test_eof; 
-	_test_eof357: cs = 357; goto _test_eof; 
-	_test_eof358: cs = 358; goto _test_eof; 
-	_test_eof359: cs = 359; goto _test_eof; 
-	_test_eof360: cs = 360; goto _test_eof; 
-	_test_eof361: cs = 361; goto _test_eof; 
-	_test_eof362: cs = 362; goto _test_eof; 
-	_test_eof363: cs = 363; goto _test_eof; 
-	_test_eof364: cs = 364; goto _test_eof; 
-	_test_eof365: cs = 365; goto _test_eof; 
-	_test_eof366: cs = 366; goto _test_eof; 
-	_test_eof367: cs = 367; goto _test_eof; 
-	_test_eof368: cs = 368; goto _test_eof; 
-	_test_eof369: cs = 369; goto _test_eof; 
-	_test_eof370: cs = 370; goto _test_eof; 
-	_test_eof371: cs = 371; goto _test_eof; 
-	_test_eof372: cs = 372; goto _test_eof; 
-	_test_eof373: cs = 373; goto _test_eof; 
-	_test_eof374: cs = 374; goto _test_eof; 
-	_test_eof375: cs = 375; goto _test_eof; 
-	_test_eof376: cs = 376; goto _test_eof; 
-	_test_eof377: cs = 377; goto _test_eof; 
-	_test_eof378: cs = 378; goto _test_eof; 
-	_test_eof379: cs = 379; goto _test_eof; 
-	_test_eof380: cs = 380; goto _test_eof; 
-	_test_eof381: cs = 381; goto _test_eof; 
-	_test_eof382: cs = 382; goto _test_eof; 
-	_test_eof383: cs = 383; goto _test_eof; 
-	_test_eof384: cs = 384; goto _test_eof; 
-	_test_eof385: cs = 385; goto _test_eof; 
-	_test_eof386: cs = 386; goto _test_eof; 
-	_test_eof387: cs = 387; goto _test_eof; 
-	_test_eof388: cs = 388; goto _test_eof; 
-	_test_eof389: cs = 389; goto _test_eof; 
-	_test_eof390: cs = 390; goto _test_eof; 
-	_test_eof391: cs = 391; goto _test_eof; 
-	_test_eof392: cs = 392; goto _test_eof; 
-	_test_eof393: cs = 393; goto _test_eof; 
-	_test_eof394: cs = 394; goto _test_eof; 
-	_test_eof395: cs = 395; goto _test_eof; 
-	_test_eof396: cs = 396; goto _test_eof; 
-	_test_eof397: cs = 397; goto _test_eof; 
-	_test_eof398: cs = 398; goto _test_eof; 
-	_test_eof399: cs = 399; goto _test_eof; 
-	_test_eof400: cs = 400; goto _test_eof; 
-	_test_eof401: cs = 401; goto _test_eof; 
-	_test_eof402: cs = 402; goto _test_eof; 
-	_test_eof403: cs = 403; goto _test_eof; 
-	_test_eof404: cs = 404; goto _test_eof; 
-	_test_eof405: cs = 405; goto _test_eof; 
-	_test_eof406: cs = 406; goto _test_eof; 
-	_test_eof407: cs = 407; goto _test_eof; 
-	_test_eof408: cs = 408; goto _test_eof; 
-	_test_eof409: cs = 409; goto _test_eof; 
-	_test_eof410: cs = 410; goto _test_eof; 
-	_test_eof411: cs = 411; goto _test_eof; 
-	_test_eof412: cs = 412; goto _test_eof; 
-	_test_eof413: cs = 413; goto _test_eof; 
-	_test_eof414: cs = 414; goto _test_eof; 
-	_test_eof415: cs = 415; goto _test_eof; 
-	_test_eof416: cs = 416; goto _test_eof; 
-	_test_eof417: cs = 417; goto _test_eof; 
-	_test_eof418: cs = 418; goto _test_eof; 
-	_test_eof419: cs = 419; goto _test_eof; 
-	_test_eof420: cs = 420; goto _test_eof; 
-	_test_eof421: cs = 421; goto _test_eof; 
-	_test_eof422: cs = 422; goto _test_eof; 
-	_test_eof423: cs = 423; goto _test_eof; 
-	_test_eof424: cs = 424; goto _test_eof; 
-	_test_eof425: cs = 425; goto _test_eof; 
-	_test_eof426: cs = 426; goto _test_eof; 
-	_test_eof427: cs = 427; goto _test_eof; 
-	_test_eof428: cs = 428; goto _test_eof; 
-	_test_eof429: cs = 429; goto _test_eof; 
-	_test_eof430: cs = 430; goto _test_eof; 
-	_test_eof431: cs = 431; goto _test_eof; 
-	_test_eof432: cs = 432; goto _test_eof; 
-	_test_eof433: cs = 433; goto _test_eof; 
-	_test_eof434: cs = 434; goto _test_eof; 
-	_test_eof435: cs = 435; goto _test_eof; 
-	_test_eof436: cs = 436; goto _test_eof; 
-	_test_eof437: cs = 437; goto _test_eof; 
-	_test_eof438: cs = 438; goto _test_eof; 
-	_test_eof439: cs = 439; goto _test_eof; 
-	_test_eof440: cs = 440; goto _test_eof; 
-	_test_eof441: cs = 441; goto _test_eof; 
-	_test_eof442: cs = 442; goto _test_eof; 
-	_test_eof443: cs = 443; goto _test_eof; 
-	_test_eof444: cs = 444; goto _test_eof; 
-	_test_eof445: cs = 445; goto _test_eof; 
-	_test_eof446: cs = 446; goto _test_eof; 
-	_test_eof447: cs = 447; goto _test_eof; 
-	_test_eof448: cs = 448; goto _test_eof; 
-	_test_eof449: cs = 449; goto _test_eof; 
-	_test_eof450: cs = 450; goto _test_eof; 
-	_test_eof451: cs = 451; goto _test_eof; 
-	_test_eof452: cs = 452; goto _test_eof; 
-	_test_eof453: cs = 453; goto _test_eof; 
-	_test_eof454: cs = 454; goto _test_eof; 
-	_test_eof455: cs = 455; goto _test_eof; 
-	_test_eof456: cs = 456; goto _test_eof; 
-	_test_eof457: cs = 457; goto _test_eof; 
-	_test_eof458: cs = 458; goto _test_eof; 
-	_test_eof459: cs = 459; goto _test_eof; 
-	_test_eof460: cs = 460; goto _test_eof; 
-	_test_eof461: cs = 461; goto _test_eof; 
-	_test_eof462: cs = 462; goto _test_eof; 
-	_test_eof463: cs = 463; goto _test_eof; 
-	_test_eof464: cs = 464; goto _test_eof; 
-	_test_eof465: cs = 465; goto _test_eof; 
-	_test_eof466: cs = 466; goto _test_eof; 
-	_test_eof467: cs = 467; goto _test_eof; 
-	_test_eof468: cs = 468; goto _test_eof; 
-	_test_eof469: cs = 469; goto _test_eof; 
-	_test_eof470: cs = 470; goto _test_eof; 
-	_test_eof471: cs = 471; goto _test_eof; 
-	_test_eof472: cs = 472; goto _test_eof; 
-	_test_eof473: cs = 473; goto _test_eof; 
-	_test_eof474: cs = 474; goto _test_eof; 
-	_test_eof475: cs = 475; goto _test_eof; 
-	_test_eof476: cs = 476; goto _test_eof; 
-	_test_eof477: cs = 477; goto _test_eof; 
-	_test_eof478: cs = 478; goto _test_eof; 
-	_test_eof479: cs = 479; goto _test_eof; 
-	_test_eof480: cs = 480; goto _test_eof; 
-	_test_eof481: cs = 481; goto _test_eof; 
-	_test_eof482: cs = 482; goto _test_eof; 
-	_test_eof483: cs = 483; goto _test_eof; 
-	_test_eof484: cs = 484; goto _test_eof; 
-	_test_eof485: cs = 485; goto _test_eof; 
-	_test_eof486: cs = 486; goto _test_eof; 
-	_test_eof487: cs = 487; goto _test_eof; 
-	_test_eof488: cs = 488; goto _test_eof; 
-	_test_eof489: cs = 489; goto _test_eof; 
-	_test_eof490: cs = 490; goto _test_eof; 
-	_test_eof491: cs = 491; goto _test_eof; 
-	_test_eof492: cs = 492; goto _test_eof; 
-	_test_eof493: cs = 493; goto _test_eof; 
-	_test_eof494: cs = 494; goto _test_eof; 
-	_test_eof495: cs = 495; goto _test_eof; 
-	_test_eof496: cs = 496; goto _test_eof; 
-	_test_eof497: cs = 497; goto _test_eof; 
-	_test_eof498: cs = 498; goto _test_eof; 
-	_test_eof499: cs = 499; goto _test_eof; 
-	_test_eof500: cs = 500; goto _test_eof; 
-	_test_eof501: cs = 501; goto _test_eof; 
-	_test_eof502: cs = 502; goto _test_eof; 
-	_test_eof503: cs = 503; goto _test_eof; 
-	_test_eof504: cs = 504; goto _test_eof; 
-	_test_eof505: cs = 505; goto _test_eof; 
-	_test_eof506: cs = 506; goto _test_eof; 
-	_test_eof507: cs = 507; goto _test_eof; 
-	_test_eof508: cs = 508; goto _test_eof; 
-	_test_eof509: cs = 509; goto _test_eof; 
-	_test_eof510: cs = 510; goto _test_eof; 
-	_test_eof511: cs = 511; goto _test_eof; 
-	_test_eof512: cs = 512; goto _test_eof; 
-	_test_eof513: cs = 513; goto _test_eof; 
-	_test_eof514: cs = 514; goto _test_eof; 
-	_test_eof515: cs = 515; goto _test_eof; 
-	_test_eof516: cs = 516; goto _test_eof; 
-	_test_eof517: cs = 517; goto _test_eof; 
-	_test_eof518: cs = 518; goto _test_eof; 
-	_test_eof519: cs = 519; goto _test_eof; 
-	_test_eof520: cs = 520; goto _test_eof; 
-	_test_eof521: cs = 521; goto _test_eof; 
-	_test_eof522: cs = 522; goto _test_eof; 
-	_test_eof523: cs = 523; goto _test_eof; 
-	_test_eof524: cs = 524; goto _test_eof; 
-	_test_eof525: cs = 525; goto _test_eof; 
-	_test_eof526: cs = 526; goto _test_eof; 
-	_test_eof527: cs = 527; goto _test_eof; 
-	_test_eof528: cs = 528; goto _test_eof; 
-	_test_eof529: cs = 529; goto _test_eof; 
-	_test_eof530: cs = 530; goto _test_eof; 
-	_test_eof531: cs = 531; goto _test_eof; 
-	_test_eof532: cs = 532; goto _test_eof; 
-	_test_eof533: cs = 533; goto _test_eof; 
-	_test_eof534: cs = 534; goto _test_eof; 
-	_test_eof535: cs = 535; goto _test_eof; 
-	_test_eof536: cs = 536; goto _test_eof; 
-	_test_eof537: cs = 537; goto _test_eof; 
-	_test_eof538: cs = 538; goto _test_eof; 
-	_test_eof539: cs = 539; goto _test_eof; 
-	_test_eof540: cs = 540; goto _test_eof; 
-	_test_eof541: cs = 541; goto _test_eof; 
-	_test_eof542: cs = 542; goto _test_eof; 
-	_test_eof543: cs = 543; goto _test_eof; 
-	_test_eof544: cs = 544; goto _test_eof; 
-	_test_eof545: cs = 545; goto _test_eof; 
-	_test_eof546: cs = 546; goto _test_eof; 
-	_test_eof547: cs = 547; goto _test_eof; 
-	_test_eof548: cs = 548; goto _test_eof; 
-	_test_eof549: cs = 549; goto _test_eof; 
-	_test_eof550: cs = 550; goto _test_eof; 
-	_test_eof551: cs = 551; goto _test_eof; 
-	_test_eof552: cs = 552; goto _test_eof; 
-	_test_eof553: cs = 553; goto _test_eof; 
-	_test_eof554: cs = 554; goto _test_eof; 
-	_test_eof555: cs = 555; goto _test_eof; 
-	_test_eof556: cs = 556; goto _test_eof; 
-	_test_eof557: cs = 557; goto _test_eof; 
-	_test_eof558: cs = 558; goto _test_eof; 
-	_test_eof559: cs = 559; goto _test_eof; 
-
-	_test_eof: {}
-	if p == eof {
-	switch cs {
-	case 560:
-// line 78 "parser.rl"
-	{
-		port := cur.(*cPort)
-		conf.Ports[port.Port] = port
-		cur = nil
-	}
-	break
-	case 562, 563:
-// line 134 "parser.rl"
-	{
-		oper := cur.(*cOper)
-		conf.Opers[oper.Username] = oper
-		cur = nil
-	}
-	break
-// line 7607 "parser.go"
-	}
-	}
-
-	_out: {}
-	}
-
-// line 228 "parser.rl"
-
-	}
-
-	if cs < config_first_final {
-		fmt.Printf("Parse error at %d near '%s'\n", p, data[p:p+10])
-	}
-
-	for _, port := range conf.Ports {
-		fmt.Println(port.String())
-	}
-	for _, oper := range conf.Opers {
-		fmt.Println(oper.String())
-	}
-}
diff --git a/server/config/parser.rl b/server/config/parser.rl
deleted file mode 100644
index b929bbc..0000000
--- a/server/config/parser.rl
+++ /dev/null
@@ -1,241 +0,0 @@
-package config
-
-import (
-	"io"
-	"os"
-	"fmt"
-	"net"
-	"strconv"
-)
-
-%% machine config;
-%% write data;
-
-// some helpers
-var booleans = map[string]bool {
-	"true": true,
-	"yes": true,
-	"on": true,
-	"1": true,
-	"false": false,
-	"no": false,
-	"off": false,
-	"0": false,
-}
-
-func getbool(val []byte) bool {
-	return booleans[string(val)]
-}
-
-func getint(val []byte) int {
-	if v, err := strconv.Atoi(string(val)); err == nil {
-		return v
-	}
-	return 0
-}
-
-%%{
-###############################################################################
-# basic parser bits
-	# mark the current position for acquiring data
-	action mark { mark = p }
-
-	# acceptable boolean values
-	true = "yes" | "on" | "1" | "true" ;
-	false = "no" | "off" | "0" | "false" ;
-	boolean = true | false ;
-
-	# IP addresses, v4 and v6
-	octet = digit         # 0-9
-		| digit digit       # 00-99
-		| [01] digit digit  # 000-199
-		| "2" [0-4] digit   # 200-249
-		| "2" "5" [0-5] ;   # 250-255
-	ipv4addr = octet "." octet "." octet "." octet ;
-	ipv6addr = ( xdigit{1,4} ":" ){7} xdigit{1,4}      # all 8 blocks
-		| xdigit{0,4} "::"                               # special case
-		| ( xdigit{1,4} ":" ){1,6} ":"                   # first 1-6, ::
-		| ":" ( ":" xdigit{1,4} ){1,6}                   # ::, final 1-6
-		| xdigit{1,4} ":" ( ":" xdigit{1,4} ){1,6}       # 1::1-6
-		| ( xdigit{1,4} ":" ){2}( ":" xdigit{1,4} ){1,5} # 2::1-5
-		| ( xdigit{1,4} ":" ){3}( ":" xdigit{1,4} ){1,4} # 3::1-4
-		| ( xdigit{1,4} ":" ){4}( ":" xdigit{1,4} ){1,5} # 4::1-3
-		| ( xdigit{1,4} ":" ){5}( ":" xdigit{1,4} ){1,2} # 5::1-2
-		| ( xdigit{1,4} ":" ){6}( ":" xdigit{1,4} ) ;    # 6::1
-
-	# acceptable password chars:
-	# anything in the normal ascii set apart from spaces and control chars
-	passchar = ascii -- ( space | cntrl ) ;
-
-	# acceptable hostmask chars:
-	# alphanumeric, plus "*", "?" and "."
-	hostchar = ( alnum | "*" | "?" | "." ) ;
-
-###############################################################################
-# "port" configuration parser
-	# Actions to create a cPort and save it into the Config struct
-	action p_new { cur = defaultPort() }
-	action p_save {
-		port := cur.(*cPort)
-		conf.Ports[port.Port] = port
-		cur = nil
-	}
-
-	# parse and save the port number
-	action px_port {
-		cur.(*cPort).Port = getint(data[mark:p])
-	}
-	pv_port = digit+ >mark %px_port ;
-
-	# parse a bind_ip statement and save the IP
-	action px_bind_ip {
-		cur.(*cPort).BindIP = net.ParseIP(string(data[mark:p]))
-	}
-	pv_bind_ip = (ipv4addr | ipv6addr) >mark %px_bind_ip ;
-	ps_bind_ip = "bind_ip" " "+ "=" " "+ pv_bind_ip ;
-
-	# parse a class statement and save it
-	action px_class {
-		cur.(*cPort).Class = string(data[mark:p])
-	}
-	pv_class = ( "server" | "client" ) >mark %px_class ;
-	ps_class = "class" " "+ "=" " "+ pv_class ;
-
-	# parse SSL and Zip booleans
-	action px_ssl {
-		cur.(*cPort).SSL = getbool(data[mark:p])
-	}
-	pv_ssl = boolean >mark %px_ssl ;
-	ps_ssl = "ssl" " "+ "=" " "+ pv_ssl ;
-
-	action px_zip {
-		cur.(*cPort).Zip = getbool(data[mark:p])
-	}
-	pv_zip = boolean >mark %px_zip ;
-	ps_zip = "zip" " "+ "=" " "+ pv_zip ;
-
-	# a port statement can be any one of the above statements
-	p_stmt = ( ps_bind_ip | ps_class | ps_ssl | ps_zip ) ;
-	# and a port block combines one or more statements
-	p_block = "{" space* ( p_stmt | (p_stmt " "* "\n" space*)+ ) space* "}" ;
-
-	# a port configuration can either be:
-	# port <port>\n
-	# port <port> { <statement> ... }
-	p_line = "port" >p_new " "+ pv_port " "* "\n" %p_save ;
-	p_defn = "port" >p_new " "+ pv_port " "+ p_block %p_save ;
-	port_config = space* ( p_line | p_defn ) space* ;
-
-
-###############################################################################
-# "oper" configuration parser
-	# actions to create a new cOper and save it into the Config struct
-	action o_new { cur = defaultOper() }
-	action o_save {
-		oper := cur.(*cOper)
-		conf.Opers[oper.Username] = oper
-		cur = nil
-	}
-
-	# parse and save the username
-	action ox_username {
-		cur.(*cOper).Username = string(data[mark:p])
-	}
-	ov_username = alpha >mark alnum* %ox_username ;
-
-	# parse a password statement and save it
-	action ox_password {
-		cur.(*cOper).Password = string(data[mark:p])
-	}
-	ov_password = passchar+ >mark %ox_password ;
-	os_password = "password" " "+ "=" " "+ ov_password ;
-
-	# parse a hostmask statement and save it
-	action ox_hostmask {
-		cur.(*cOper).HostMask = append(
-			cur.(*cOper).HostMask, string(data[mark:p]))
-	}
-	ov_hostmask = hostchar+ >mark "@" hostchar+ %ox_hostmask ;
-	os_hostmask = "hostmask" " "+ "=" " "+ ov_hostmask ;
-
-	# parse and save the various oper permissions
-	action ox_kill {
-		cur.(*cOper).CanKill = getbool(data[mark:p])
-	}
-	ov_kill = boolean >mark %ox_kill ;
-	os_kill = "kill" " "+ "=" " "+ ov_kill ;
-
-	action ox_ban {
-		cur.(*cOper).CanBan = getbool(data[mark:p])
-	}
-	ov_ban = boolean >mark %ox_ban ;
-	os_ban = "ban" " "+ "=" " "+ ov_ban ;
-
-	action ox_renick {
-		cur.(*cOper).CanRenick = getbool(data[mark:p])
-	}
-	ov_renick = boolean >mark %ox_renick ;
-	os_renick = "renick" " "+ "=" " "+ ov_renick ;
-
-	action ox_link {
-		cur.(*cOper).CanLink = getbool(data[mark:p])
-	}
-	ov_link = boolean >mark %ox_link ;
-	os_link = "link" " "+ "=" " "+ ov_link ;
-
-	# an oper statement can be any of the above statements
-	o_stmt = ( os_password
-	  | os_hostmask
-	  | os_kill
-	  | os_ban
-	  | os_renick
-	  | os_link ) ;
-	# and an oper block combines one or more statements
-	o_block = "{" space* ( o_stmt | (o_stmt " "* "\n" space*)+ ) space* "}" ;
-
-	# an oper configuration looks like:
-	# oper <username> { <statement> ... }
-	oper_config =  "oper" >o_new " "+ ov_username
-					" "+ o_block %o_save space* ;
-
-#	config = portconfig+
-#	  | operconfig+
-#	  | linkconfig*
-#	  | infoconfig
-#	  | settings ;
-
-	main := ( port_config | oper_config )+ ;
-}%%
-
-func (conf *Config) Parse(r io.Reader) {
-	cs, p, mark, pe, eof, buflen := 0, 0, 0, 0, 0, 16384
-	done := false
-	var cur interface{}
-	data := make([]byte, buflen)
-
-	%% write init;
-
-	for !done {
-		n, err := r.Read(data)
-		pe = p + n
-		if err == os.EOF {
-			fmt.Println("yeahhhhh.")
-			done = true
-			eof = pe
-		}
-
-		%% write exec;
-
-	}
-
-	if cs < config_first_final {
-		fmt.Printf("Parse error at %d near '%s'\n", p, data[p:p+10])
-	}
-
-	for _, port := range conf.Ports {
-		fmt.Println(port.String())
-	}
-	for _, oper := range conf.Opers {
-		fmt.Println(oper.String())
-	}
-}