parser.go raw
1 // Package fasturl is a Go URL parser using a [Ragel](http://www.colm.net/open-source/ragel/) state-machine instead of regex, or the built in standard library `url.Parse`.
2 //
3 //line parser.rl:1
4 package fasturl
5
6 import "fmt"
7
8 //line parser.go:11
9 const url_parser_start int = 45
10 const url_parser_first_final int = 45
11 const url_parser_error int = 0
12
13 const url_parser_en_main int = 45
14
15 //line parser.rl:96
16
17 // URL represents the different parts of a parsed URL
18 type URL struct {
19 Protocol string
20 Host string
21 Port string
22 Path string
23 Query string
24 Fragment string
25 }
26
27 // ParseURL parses a given URL and returns a `URL` representing the different parts
28 func ParseURL(data string) (*URL, error) {
29 mark, host_mark, port_mark, cs, p, pe, eof := 0, 0, 0, url_parser_en_main, 0, len(data), len(data)
30
31 u := &URL{}
32
33 //line parser.go:39
34 {
35 cs = url_parser_start
36 }
37
38 //line parser.rl:115
39
40 //line parser.go:46
41 {
42 if p == pe {
43 goto _test_eof
44 }
45 switch cs {
46 case 45:
47 goto st_case_45
48 case 0:
49 goto st_case_0
50 case 46:
51 goto st_case_46
52 case 47:
53 goto st_case_47
54 case 48:
55 goto st_case_48
56 case 1:
57 goto st_case_1
58 case 2:
59 goto st_case_2
60 case 49:
61 goto st_case_49
62 case 50:
63 goto st_case_50
64 case 51:
65 goto st_case_51
66 case 52:
67 goto st_case_52
68 case 3:
69 goto st_case_3
70 case 53:
71 goto st_case_53
72 case 54:
73 goto st_case_54
74 case 55:
75 goto st_case_55
76 case 56:
77 goto st_case_56
78 case 57:
79 goto st_case_57
80 case 4:
81 goto st_case_4
82 case 5:
83 goto st_case_5
84 case 58:
85 goto st_case_58
86 case 6:
87 goto st_case_6
88 case 7:
89 goto st_case_7
90 case 59:
91 goto st_case_59
92 case 60:
93 goto st_case_60
94 case 61:
95 goto st_case_61
96 case 62:
97 goto st_case_62
98 case 63:
99 goto st_case_63
100 case 64:
101 goto st_case_64
102 case 65:
103 goto st_case_65
104 case 66:
105 goto st_case_66
106 case 67:
107 goto st_case_67
108 case 68:
109 goto st_case_68
110 case 69:
111 goto st_case_69
112 case 70:
113 goto st_case_70
114 case 71:
115 goto st_case_71
116 case 72:
117 goto st_case_72
118 case 73:
119 goto st_case_73
120 case 74:
121 goto st_case_74
122 case 75:
123 goto st_case_75
124 case 76:
125 goto st_case_76
126 case 77:
127 goto st_case_77
128 case 78:
129 goto st_case_78
130 case 79:
131 goto st_case_79
132 case 80:
133 goto st_case_80
134 case 81:
135 goto st_case_81
136 case 82:
137 goto st_case_82
138 case 83:
139 goto st_case_83
140 case 84:
141 goto st_case_84
142 case 8:
143 goto st_case_8
144 case 9:
145 goto st_case_9
146 case 10:
147 goto st_case_10
148 case 11:
149 goto st_case_11
150 case 12:
151 goto st_case_12
152 case 13:
153 goto st_case_13
154 case 14:
155 goto st_case_14
156 case 15:
157 goto st_case_15
158 case 16:
159 goto st_case_16
160 case 17:
161 goto st_case_17
162 case 18:
163 goto st_case_18
164 case 19:
165 goto st_case_19
166 case 20:
167 goto st_case_20
168 case 21:
169 goto st_case_21
170 case 22:
171 goto st_case_22
172 case 85:
173 goto st_case_85
174 case 23:
175 goto st_case_23
176 case 86:
177 goto st_case_86
178 case 87:
179 goto st_case_87
180 case 24:
181 goto st_case_24
182 case 25:
183 goto st_case_25
184 case 26:
185 goto st_case_26
186 case 27:
187 goto st_case_27
188 case 28:
189 goto st_case_28
190 case 29:
191 goto st_case_29
192 case 30:
193 goto st_case_30
194 case 31:
195 goto st_case_31
196 case 32:
197 goto st_case_32
198 case 33:
199 goto st_case_33
200 case 88:
201 goto st_case_88
202 case 34:
203 goto st_case_34
204 case 35:
205 goto st_case_35
206 case 89:
207 goto st_case_89
208 case 90:
209 goto st_case_90
210 case 36:
211 goto st_case_36
212 case 91:
213 goto st_case_91
214 case 92:
215 goto st_case_92
216 case 93:
217 goto st_case_93
218 case 94:
219 goto st_case_94
220 case 95:
221 goto st_case_95
222 case 96:
223 goto st_case_96
224 case 97:
225 goto st_case_97
226 case 98:
227 goto st_case_98
228 case 37:
229 goto st_case_37
230 case 38:
231 goto st_case_38
232 case 99:
233 goto st_case_99
234 case 100:
235 goto st_case_100
236 case 101:
237 goto st_case_101
238 case 102:
239 goto st_case_102
240 case 103:
241 goto st_case_103
242 case 104:
243 goto st_case_104
244 case 105:
245 goto st_case_105
246 case 106:
247 goto st_case_106
248 case 107:
249 goto st_case_107
250 case 108:
251 goto st_case_108
252 case 109:
253 goto st_case_109
254 case 39:
255 goto st_case_39
256 case 40:
257 goto st_case_40
258 case 41:
259 goto st_case_41
260 case 110:
261 goto st_case_110
262 case 111:
263 goto st_case_111
264 case 112:
265 goto st_case_112
266 case 113:
267 goto st_case_113
268 case 114:
269 goto st_case_114
270 case 115:
271 goto st_case_115
272 case 116:
273 goto st_case_116
274 case 42:
275 goto st_case_42
276 case 117:
277 goto st_case_117
278 case 118:
279 goto st_case_118
280 case 119:
281 goto st_case_119
282 case 120:
283 goto st_case_120
284 case 121:
285 goto st_case_121
286 case 122:
287 goto st_case_122
288 case 123:
289 goto st_case_123
290 case 124:
291 goto st_case_124
292 case 125:
293 goto st_case_125
294 case 126:
295 goto st_case_126
296 case 127:
297 goto st_case_127
298 case 128:
299 goto st_case_128
300 case 129:
301 goto st_case_129
302 case 130:
303 goto st_case_130
304 case 131:
305 goto st_case_131
306 case 132:
307 goto st_case_132
308 case 133:
309 goto st_case_133
310 case 134:
311 goto st_case_134
312 case 135:
313 goto st_case_135
314 case 43:
315 goto st_case_43
316 case 44:
317 goto st_case_44
318 case 136:
319 goto st_case_136
320 case 137:
321 goto st_case_137
322 case 138:
323 goto st_case_138
324 case 139:
325 goto st_case_139
326 case 140:
327 goto st_case_140
328 case 141:
329 goto st_case_141
330 case 142:
331 goto st_case_142
332 case 143:
333 goto st_case_143
334 case 144:
335 goto st_case_144
336 case 145:
337 goto st_case_145
338 case 146:
339 goto st_case_146
340 case 147:
341 goto st_case_147
342 case 148:
343 goto st_case_148
344 case 149:
345 goto st_case_149
346 case 150:
347 goto st_case_150
348 case 151:
349 goto st_case_151
350 case 152:
351 goto st_case_152
352 case 153:
353 goto st_case_153
354 case 154:
355 goto st_case_154
356 case 155:
357 goto st_case_155
358 case 156:
359 goto st_case_156
360 case 157:
361 goto st_case_157
362 case 158:
363 goto st_case_158
364 case 159:
365 goto st_case_159
366 case 160:
367 goto st_case_160
368 case 161:
369 goto st_case_161
370 }
371 goto st_out
372 st_case_45:
373 switch data[p] {
374 case 33:
375 goto tr14
376 case 35:
377 goto st47
378 case 37:
379 goto tr15
380 case 47:
381 goto tr44
382 case 58:
383 goto st8
384 case 61:
385 goto tr14
386 case 63:
387 goto st51
388 case 64:
389 goto st11
390 case 91:
391 goto tr16
392 case 92:
393 goto tr47
394 case 95:
395 goto tr14
396 case 126:
397 goto tr14
398 }
399 switch {
400 case data[p] < 65:
401 if 36 <= data[p] && data[p] <= 59 {
402 goto tr14
403 }
404 case data[p] > 90:
405 if 97 <= data[p] && data[p] <= 122 {
406 goto tr46
407 }
408 default:
409 goto tr46
410 }
411 goto st0
412 st_case_0:
413 st0:
414 cs = 0
415 goto _out
416 tr14:
417 //line parser.rl:23
418
419 host_mark = p
420
421 goto st46
422 st46:
423 if p++; p == pe {
424 goto _test_eof46
425 }
426 st_case_46:
427 //line parser.go:433
428 switch data[p] {
429 case 33:
430 goto st46
431 case 35:
432 goto tr48
433 case 37:
434 goto st1
435 case 47:
436 goto tr50
437 case 58:
438 goto tr51
439 case 61:
440 goto st46
441 case 63:
442 goto tr52
443 case 64:
444 goto st11
445 case 92:
446 goto tr50
447 case 95:
448 goto st46
449 case 126:
450 goto st46
451 }
452 switch {
453 case data[p] < 65:
454 if 36 <= data[p] && data[p] <= 59 {
455 goto st46
456 }
457 case data[p] > 90:
458 if 97 <= data[p] && data[p] <= 122 {
459 goto tr53
460 }
461 default:
462 goto tr53
463 }
464 goto st0
465 tr48:
466 //line parser.rl:27
467
468 u.Host = data[host_mark:p]
469
470 goto st47
471 tr57:
472 //line parser.rl:37
473
474 if u.Path == "" {
475 u.Path = data[mark:p]
476 }
477
478 goto st47
479 tr60:
480 //line parser.rl:10
481 mark = p
482 //line parser.rl:31
483
484 if u.Query == "" {
485 u.Query = data[mark:p]
486 }
487
488 goto st47
489 tr62:
490 //line parser.rl:31
491
492 if u.Query == "" {
493 u.Query = data[mark:p]
494 }
495
496 goto st47
497 tr64:
498 //line parser.rl:13
499
500 if port_mark > host_mark {
501 u.Port = data[port_mark:p]
502 }
503
504 goto st47
505 tr84:
506 //line parser.rl:13
507
508 if port_mark > host_mark {
509 u.Port = data[port_mark:p]
510 }
511
512 //line parser.rl:37
513
514 if u.Path == "" {
515 u.Path = data[mark:p]
516 }
517
518 goto st47
519 tr143:
520 //line parser.rl:27
521
522 u.Host = data[host_mark:p]
523
524 //line parser.rl:13
525
526 if port_mark > host_mark {
527 u.Port = data[port_mark:p]
528 }
529
530 goto st47
531 tr228:
532 //line parser.rl:19
533
534 u.Protocol = data[0 : p-1]
535
536 goto st47
537 st47:
538 if p++; p == pe {
539 goto _test_eof47
540 }
541 st_case_47:
542 //line parser.go:548
543 if 32 <= data[p] && data[p] <= 126 {
544 goto tr54
545 }
546 goto st0
547 tr54:
548 //line parser.rl:10
549 mark = p
550 goto st48
551 st48:
552 if p++; p == pe {
553 goto _test_eof48
554 }
555 st_case_48:
556 //line parser.go:562
557 if 32 <= data[p] && data[p] <= 126 {
558 goto st48
559 }
560 goto st0
561 tr15:
562 //line parser.rl:23
563
564 host_mark = p
565
566 goto st1
567 st1:
568 if p++; p == pe {
569 goto _test_eof1
570 }
571 st_case_1:
572 //line parser.go:578
573 switch {
574 case data[p] < 65:
575 if 48 <= data[p] && data[p] <= 57 {
576 goto st2
577 }
578 case data[p] > 70:
579 if 97 <= data[p] && data[p] <= 102 {
580 goto st2
581 }
582 default:
583 goto st2
584 }
585 goto st0
586 st2:
587 if p++; p == pe {
588 goto _test_eof2
589 }
590 st_case_2:
591 switch {
592 case data[p] < 65:
593 if 48 <= data[p] && data[p] <= 57 {
594 goto st46
595 }
596 case data[p] > 70:
597 if 97 <= data[p] && data[p] <= 102 {
598 goto st46
599 }
600 default:
601 goto st46
602 }
603 goto st0
604 tr47:
605 //line parser.rl:10
606 mark = p
607 goto st49
608 tr50:
609 //line parser.rl:27
610
611 u.Host = data[host_mark:p]
612
613 //line parser.rl:10
614 mark = p
615 goto st49
616 tr66:
617 //line parser.rl:13
618
619 if port_mark > host_mark {
620 u.Port = data[port_mark:p]
621 }
622
623 //line parser.rl:10
624 mark = p
625 goto st49
626 tr145:
627 //line parser.rl:27
628
629 u.Host = data[host_mark:p]
630
631 //line parser.rl:13
632
633 if port_mark > host_mark {
634 u.Port = data[port_mark:p]
635 }
636
637 //line parser.rl:10
638 mark = p
639 goto st49
640 st49:
641 if p++; p == pe {
642 goto _test_eof49
643 }
644 st_case_49:
645 //line parser.go:651
646 switch data[p] {
647 case 35:
648 goto tr57
649 case 63:
650 goto tr58
651 }
652 switch {
653 case data[p] > 46:
654 if 48 <= data[p] && data[p] <= 126 {
655 goto st50
656 }
657 case data[p] >= 32:
658 goto st50
659 }
660 goto st0
661 tr86:
662 //line parser.rl:13
663
664 if port_mark > host_mark {
665 u.Port = data[port_mark:p]
666 }
667
668 //line parser.rl:10
669 mark = p
670 goto st50
671 st50:
672 if p++; p == pe {
673 goto _test_eof50
674 }
675 st_case_50:
676 //line parser.go:682
677 switch data[p] {
678 case 35:
679 goto tr57
680 case 63:
681 goto tr58
682 }
683 if 32 <= data[p] && data[p] <= 126 {
684 goto st50
685 }
686 goto st0
687 tr52:
688 //line parser.rl:27
689
690 u.Host = data[host_mark:p]
691
692 goto st51
693 tr58:
694 //line parser.rl:37
695
696 if u.Path == "" {
697 u.Path = data[mark:p]
698 }
699
700 goto st51
701 tr67:
702 //line parser.rl:13
703
704 if port_mark > host_mark {
705 u.Port = data[port_mark:p]
706 }
707
708 goto st51
709 tr85:
710 //line parser.rl:13
711
712 if port_mark > host_mark {
713 u.Port = data[port_mark:p]
714 }
715
716 //line parser.rl:37
717
718 if u.Path == "" {
719 u.Path = data[mark:p]
720 }
721
722 goto st51
723 tr147:
724 //line parser.rl:27
725
726 u.Host = data[host_mark:p]
727
728 //line parser.rl:13
729
730 if port_mark > host_mark {
731 u.Port = data[port_mark:p]
732 }
733
734 goto st51
735 tr232:
736 //line parser.rl:19
737
738 u.Protocol = data[0 : p-1]
739
740 goto st51
741 st51:
742 if p++; p == pe {
743 goto _test_eof51
744 }
745 st_case_51:
746 //line parser.go:752
747 if data[p] == 35 {
748 goto tr60
749 }
750 switch {
751 case data[p] < 48:
752 if 32 <= data[p] && data[p] <= 46 {
753 goto tr59
754 }
755 case data[p] > 62:
756 if 64 <= data[p] && data[p] <= 126 {
757 goto tr59
758 }
759 default:
760 goto tr59
761 }
762 goto st0
763 tr59:
764 //line parser.rl:10
765 mark = p
766 goto st52
767 st52:
768 if p++; p == pe {
769 goto _test_eof52
770 }
771 st_case_52:
772 //line parser.go:778
773 if data[p] == 35 {
774 goto tr62
775 }
776 switch {
777 case data[p] < 48:
778 if 32 <= data[p] && data[p] <= 46 {
779 goto st52
780 }
781 case data[p] > 62:
782 if 64 <= data[p] && data[p] <= 126 {
783 goto st52
784 }
785 default:
786 goto st52
787 }
788 goto st0
789 tr51:
790 //line parser.rl:27
791
792 u.Host = data[host_mark:p]
793
794 goto st3
795 st3:
796 if p++; p == pe {
797 goto _test_eof3
798 }
799 st_case_3:
800 //line parser.go:806
801 switch data[p] {
802 case 33:
803 goto tr4
804 case 37:
805 goto tr5
806 case 60:
807 goto tr3
808 case 62:
809 goto tr3
810 case 64:
811 goto tr6
812 case 95:
813 goto tr4
814 case 126:
815 goto tr4
816 }
817 switch {
818 case data[p] < 65:
819 switch {
820 case data[p] < 36:
821 if 32 <= data[p] && data[p] <= 34 {
822 goto tr3
823 }
824 case data[p] > 46:
825 if 48 <= data[p] && data[p] <= 61 {
826 goto tr4
827 }
828 default:
829 goto tr4
830 }
831 case data[p] > 90:
832 switch {
833 case data[p] < 97:
834 if 91 <= data[p] && data[p] <= 96 {
835 goto tr3
836 }
837 case data[p] > 122:
838 if 123 <= data[p] && data[p] <= 125 {
839 goto tr3
840 }
841 default:
842 goto tr4
843 }
844 default:
845 goto tr4
846 }
847 goto st0
848 tr3:
849 //line parser.rl:11
850 port_mark = p
851 goto st53
852 tr129:
853 //line parser.rl:13
854
855 if port_mark > host_mark {
856 u.Port = data[port_mark:p]
857 }
858
859 //line parser.rl:10
860 mark = p
861 goto st53
862 tr211:
863 //line parser.rl:11
864 port_mark = p
865 //line parser.rl:13
866
867 if port_mark > host_mark {
868 u.Port = data[port_mark:p]
869 }
870
871 //line parser.rl:10
872 mark = p
873 goto st53
874 st53:
875 if p++; p == pe {
876 goto _test_eof53
877 }
878 st_case_53:
879 //line parser.go:885
880 switch data[p] {
881 case 35:
882 goto tr64
883 case 37:
884 goto st74
885 case 47:
886 goto tr66
887 case 63:
888 goto tr67
889 case 92:
890 goto tr69
891 }
892 switch {
893 case data[p] < 91:
894 switch {
895 case data[p] > 64:
896 if 65 <= data[p] && data[p] <= 90 {
897 goto tr68
898 }
899 case data[p] >= 32:
900 goto st54
901 }
902 case data[p] > 96:
903 switch {
904 case data[p] > 122:
905 if 123 <= data[p] && data[p] <= 126 {
906 goto st54
907 }
908 case data[p] >= 97:
909 goto tr68
910 }
911 default:
912 goto st54
913 }
914 goto st0
915 tr68:
916 //line parser.rl:13
917
918 if port_mark > host_mark {
919 u.Port = data[port_mark:p]
920 }
921
922 //line parser.rl:10
923 mark = p
924 goto st54
925 st54:
926 if p++; p == pe {
927 goto _test_eof54
928 }
929 st_case_54:
930 //line parser.go:936
931 switch data[p] {
932 case 35:
933 goto tr64
934 case 37:
935 goto st68
936 case 47:
937 goto tr66
938 case 63:
939 goto tr67
940 case 92:
941 goto tr73
942 }
943 switch {
944 case data[p] < 91:
945 switch {
946 case data[p] > 64:
947 if 65 <= data[p] && data[p] <= 90 {
948 goto tr72
949 }
950 case data[p] >= 32:
951 goto st55
952 }
953 case data[p] > 96:
954 switch {
955 case data[p] > 122:
956 if 123 <= data[p] && data[p] <= 126 {
957 goto st55
958 }
959 case data[p] >= 97:
960 goto tr72
961 }
962 default:
963 goto st55
964 }
965 goto st0
966 tr72:
967 //line parser.rl:13
968
969 if port_mark > host_mark {
970 u.Port = data[port_mark:p]
971 }
972
973 //line parser.rl:10
974 mark = p
975 goto st55
976 st55:
977 if p++; p == pe {
978 goto _test_eof55
979 }
980 st_case_55:
981 //line parser.go:987
982 switch data[p] {
983 case 35:
984 goto tr64
985 case 37:
986 goto st61
987 case 47:
988 goto tr66
989 case 63:
990 goto tr67
991 case 92:
992 goto tr77
993 }
994 switch {
995 case data[p] < 91:
996 switch {
997 case data[p] > 64:
998 if 65 <= data[p] && data[p] <= 90 {
999 goto tr76
1000 }
1001 case data[p] >= 32:
1002 goto st56
1003 }
1004 case data[p] > 96:
1005 switch {
1006 case data[p] > 122:
1007 if 123 <= data[p] && data[p] <= 126 {
1008 goto st56
1009 }
1010 case data[p] >= 97:
1011 goto tr76
1012 }
1013 default:
1014 goto st56
1015 }
1016 goto st0
1017 tr76:
1018 //line parser.rl:13
1019
1020 if port_mark > host_mark {
1021 u.Port = data[port_mark:p]
1022 }
1023
1024 //line parser.rl:10
1025 mark = p
1026 goto st56
1027 tr251:
1028 //line parser.rl:27
1029
1030 u.Host = data[host_mark:p]
1031
1032 //line parser.rl:13
1033
1034 if port_mark > host_mark {
1035 u.Port = data[port_mark:p]
1036 }
1037
1038 //line parser.rl:10
1039 mark = p
1040 goto st56
1041 st56:
1042 if p++; p == pe {
1043 goto _test_eof56
1044 }
1045 st_case_56:
1046 //line parser.go:1052
1047 switch data[p] {
1048 case 35:
1049 goto tr64
1050 case 37:
1051 goto st58
1052 case 47:
1053 goto tr66
1054 case 63:
1055 goto tr67
1056 case 92:
1057 goto tr80
1058 }
1059 switch {
1060 case data[p] < 91:
1061 switch {
1062 case data[p] > 64:
1063 if 65 <= data[p] && data[p] <= 90 {
1064 goto tr79
1065 }
1066 case data[p] >= 32:
1067 goto st57
1068 }
1069 case data[p] > 96:
1070 switch {
1071 case data[p] > 122:
1072 if 123 <= data[p] && data[p] <= 126 {
1073 goto st57
1074 }
1075 case data[p] >= 97:
1076 goto tr79
1077 }
1078 default:
1079 goto st57
1080 }
1081 goto st0
1082 st57:
1083 if p++; p == pe {
1084 goto _test_eof57
1085 }
1086 st_case_57:
1087 switch data[p] {
1088 case 35:
1089 goto tr64
1090 case 47:
1091 goto tr66
1092 case 63:
1093 goto tr67
1094 case 92:
1095 goto tr66
1096 }
1097 switch {
1098 case data[p] > 90:
1099 if 97 <= data[p] && data[p] <= 122 {
1100 goto tr81
1101 }
1102 case data[p] >= 65:
1103 goto tr81
1104 }
1105 goto st0
1106 tr125:
1107 //line parser.rl:27
1108
1109 u.Host = data[host_mark:p]
1110
1111 //line parser.rl:10
1112 mark = p
1113 goto st4
1114 tr81:
1115 //line parser.rl:13
1116
1117 if port_mark > host_mark {
1118 u.Port = data[port_mark:p]
1119 }
1120
1121 //line parser.rl:10
1122 mark = p
1123 goto st4
1124 tr200:
1125 //line parser.rl:27
1126
1127 u.Host = data[host_mark:p]
1128
1129 //line parser.rl:13
1130
1131 if port_mark > host_mark {
1132 u.Port = data[port_mark:p]
1133 }
1134
1135 //line parser.rl:10
1136 mark = p
1137 goto st4
1138 st4:
1139 if p++; p == pe {
1140 goto _test_eof4
1141 }
1142 st_case_4:
1143 //line parser.go:1149
1144 if data[p] == 58 {
1145 goto st5
1146 }
1147 goto st0
1148 st5:
1149 if p++; p == pe {
1150 goto _test_eof5
1151 }
1152 st_case_5:
1153 switch data[p] {
1154 case 47:
1155 goto st49
1156 case 92:
1157 goto st49
1158 }
1159 goto st0
1160 st58:
1161 if p++; p == pe {
1162 goto _test_eof58
1163 }
1164 st_case_58:
1165 switch data[p] {
1166 case 35:
1167 goto tr64
1168 case 47:
1169 goto tr66
1170 case 63:
1171 goto tr67
1172 case 92:
1173 goto tr66
1174 }
1175 switch {
1176 case data[p] < 71:
1177 switch {
1178 case data[p] > 57:
1179 if 65 <= data[p] && data[p] <= 70 {
1180 goto tr83
1181 }
1182 case data[p] >= 48:
1183 goto st6
1184 }
1185 case data[p] > 90:
1186 switch {
1187 case data[p] > 102:
1188 if 103 <= data[p] && data[p] <= 122 {
1189 goto tr81
1190 }
1191 case data[p] >= 97:
1192 goto tr83
1193 }
1194 default:
1195 goto tr81
1196 }
1197 goto st0
1198 st6:
1199 if p++; p == pe {
1200 goto _test_eof6
1201 }
1202 st_case_6:
1203 switch {
1204 case data[p] < 65:
1205 if 48 <= data[p] && data[p] <= 57 {
1206 goto st57
1207 }
1208 case data[p] > 70:
1209 if 97 <= data[p] && data[p] <= 102 {
1210 goto st57
1211 }
1212 default:
1213 goto st57
1214 }
1215 goto st0
1216 tr83:
1217 //line parser.rl:13
1218
1219 if port_mark > host_mark {
1220 u.Port = data[port_mark:p]
1221 }
1222
1223 //line parser.rl:10
1224 mark = p
1225 goto st7
1226 st7:
1227 if p++; p == pe {
1228 goto _test_eof7
1229 }
1230 st_case_7:
1231 //line parser.go:1237
1232 if data[p] == 58 {
1233 goto st5
1234 }
1235 switch {
1236 case data[p] < 65:
1237 if 48 <= data[p] && data[p] <= 57 {
1238 goto st57
1239 }
1240 case data[p] > 70:
1241 if 97 <= data[p] && data[p] <= 102 {
1242 goto st57
1243 }
1244 default:
1245 goto st57
1246 }
1247 goto st0
1248 tr79:
1249 //line parser.rl:13
1250
1251 if port_mark > host_mark {
1252 u.Port = data[port_mark:p]
1253 }
1254
1255 //line parser.rl:10
1256 mark = p
1257 goto st59
1258 tr210:
1259 //line parser.rl:27
1260
1261 u.Host = data[host_mark:p]
1262
1263 //line parser.rl:13
1264
1265 if port_mark > host_mark {
1266 u.Port = data[port_mark:p]
1267 }
1268
1269 //line parser.rl:10
1270 mark = p
1271 goto st59
1272 st59:
1273 if p++; p == pe {
1274 goto _test_eof59
1275 }
1276 st_case_59:
1277 //line parser.go:1283
1278 switch data[p] {
1279 case 35:
1280 goto tr64
1281 case 47:
1282 goto tr66
1283 case 58:
1284 goto st5
1285 case 63:
1286 goto tr67
1287 case 92:
1288 goto tr66
1289 }
1290 switch {
1291 case data[p] > 90:
1292 if 97 <= data[p] && data[p] <= 122 {
1293 goto tr81
1294 }
1295 case data[p] >= 65:
1296 goto tr81
1297 }
1298 goto st0
1299 tr80:
1300 //line parser.rl:13
1301
1302 if port_mark > host_mark {
1303 u.Port = data[port_mark:p]
1304 }
1305
1306 //line parser.rl:10
1307 mark = p
1308 goto st60
1309 tr156:
1310 //line parser.rl:27
1311
1312 u.Host = data[host_mark:p]
1313
1314 //line parser.rl:13
1315
1316 if port_mark > host_mark {
1317 u.Port = data[port_mark:p]
1318 }
1319
1320 //line parser.rl:10
1321 mark = p
1322 goto st60
1323 st60:
1324 if p++; p == pe {
1325 goto _test_eof60
1326 }
1327 st_case_60:
1328 //line parser.go:1334
1329 switch data[p] {
1330 case 35:
1331 goto tr84
1332 case 47:
1333 goto tr66
1334 case 63:
1335 goto tr85
1336 case 91:
1337 goto st50
1338 }
1339 switch {
1340 case data[p] < 93:
1341 switch {
1342 case data[p] > 64:
1343 if 65 <= data[p] && data[p] <= 92 {
1344 goto tr86
1345 }
1346 case data[p] >= 32:
1347 goto st50
1348 }
1349 case data[p] > 96:
1350 switch {
1351 case data[p] > 122:
1352 if 123 <= data[p] && data[p] <= 126 {
1353 goto st50
1354 }
1355 case data[p] >= 97:
1356 goto tr86
1357 }
1358 default:
1359 goto st50
1360 }
1361 goto st0
1362 st61:
1363 if p++; p == pe {
1364 goto _test_eof61
1365 }
1366 st_case_61:
1367 switch data[p] {
1368 case 35:
1369 goto tr64
1370 case 37:
1371 goto st58
1372 case 47:
1373 goto tr66
1374 case 63:
1375 goto tr67
1376 case 92:
1377 goto tr80
1378 }
1379 switch {
1380 case data[p] < 71:
1381 switch {
1382 case data[p] < 48:
1383 if 32 <= data[p] && data[p] <= 46 {
1384 goto st57
1385 }
1386 case data[p] > 57:
1387 switch {
1388 case data[p] > 64:
1389 if 65 <= data[p] && data[p] <= 70 {
1390 goto tr88
1391 }
1392 case data[p] >= 58:
1393 goto st57
1394 }
1395 default:
1396 goto st62
1397 }
1398 case data[p] > 90:
1399 switch {
1400 case data[p] < 97:
1401 if 91 <= data[p] && data[p] <= 96 {
1402 goto st57
1403 }
1404 case data[p] > 102:
1405 switch {
1406 case data[p] > 122:
1407 if 123 <= data[p] && data[p] <= 126 {
1408 goto st57
1409 }
1410 case data[p] >= 103:
1411 goto tr79
1412 }
1413 default:
1414 goto tr88
1415 }
1416 default:
1417 goto tr79
1418 }
1419 goto st0
1420 st62:
1421 if p++; p == pe {
1422 goto _test_eof62
1423 }
1424 st_case_62:
1425 switch data[p] {
1426 case 35:
1427 goto tr64
1428 case 47:
1429 goto tr66
1430 case 63:
1431 goto tr67
1432 case 92:
1433 goto tr66
1434 }
1435 switch {
1436 case data[p] < 71:
1437 switch {
1438 case data[p] > 57:
1439 if 65 <= data[p] && data[p] <= 70 {
1440 goto tr76
1441 }
1442 case data[p] >= 48:
1443 goto st56
1444 }
1445 case data[p] > 90:
1446 switch {
1447 case data[p] > 102:
1448 if 103 <= data[p] && data[p] <= 122 {
1449 goto tr81
1450 }
1451 case data[p] >= 97:
1452 goto tr76
1453 }
1454 default:
1455 goto tr81
1456 }
1457 goto st0
1458 tr88:
1459 //line parser.rl:13
1460
1461 if port_mark > host_mark {
1462 u.Port = data[port_mark:p]
1463 }
1464
1465 //line parser.rl:10
1466 mark = p
1467 goto st63
1468 st63:
1469 if p++; p == pe {
1470 goto _test_eof63
1471 }
1472 st_case_63:
1473 //line parser.go:1479
1474 switch data[p] {
1475 case 35:
1476 goto tr64
1477 case 47:
1478 goto tr66
1479 case 58:
1480 goto st5
1481 case 63:
1482 goto tr67
1483 case 92:
1484 goto tr66
1485 }
1486 switch {
1487 case data[p] < 71:
1488 switch {
1489 case data[p] > 57:
1490 if 65 <= data[p] && data[p] <= 70 {
1491 goto tr76
1492 }
1493 case data[p] >= 48:
1494 goto st56
1495 }
1496 case data[p] > 90:
1497 switch {
1498 case data[p] > 102:
1499 if 103 <= data[p] && data[p] <= 122 {
1500 goto tr81
1501 }
1502 case data[p] >= 97:
1503 goto tr76
1504 }
1505 default:
1506 goto tr81
1507 }
1508 goto st0
1509 tr77:
1510 //line parser.rl:13
1511
1512 if port_mark > host_mark {
1513 u.Port = data[port_mark:p]
1514 }
1515
1516 //line parser.rl:10
1517 mark = p
1518 goto st64
1519 tr153:
1520 //line parser.rl:27
1521
1522 u.Host = data[host_mark:p]
1523
1524 //line parser.rl:13
1525
1526 if port_mark > host_mark {
1527 u.Port = data[port_mark:p]
1528 }
1529
1530 //line parser.rl:10
1531 mark = p
1532 goto st64
1533 st64:
1534 if p++; p == pe {
1535 goto _test_eof64
1536 }
1537 st_case_64:
1538 //line parser.go:1544
1539 switch data[p] {
1540 case 35:
1541 goto tr84
1542 case 37:
1543 goto st66
1544 case 47:
1545 goto tr66
1546 case 63:
1547 goto tr85
1548 case 91:
1549 goto st65
1550 }
1551 switch {
1552 case data[p] < 93:
1553 switch {
1554 case data[p] > 64:
1555 if 65 <= data[p] && data[p] <= 92 {
1556 goto tr91
1557 }
1558 case data[p] >= 32:
1559 goto st65
1560 }
1561 case data[p] > 96:
1562 switch {
1563 case data[p] > 122:
1564 if 123 <= data[p] && data[p] <= 126 {
1565 goto st65
1566 }
1567 case data[p] >= 97:
1568 goto tr91
1569 }
1570 default:
1571 goto st65
1572 }
1573 goto st0
1574 tr91:
1575 //line parser.rl:13
1576
1577 if port_mark > host_mark {
1578 u.Port = data[port_mark:p]
1579 }
1580
1581 //line parser.rl:10
1582 mark = p
1583 goto st65
1584 st65:
1585 if p++; p == pe {
1586 goto _test_eof65
1587 }
1588 st_case_65:
1589 //line parser.go:1595
1590 switch data[p] {
1591 case 35:
1592 goto tr84
1593 case 47:
1594 goto tr86
1595 case 63:
1596 goto tr85
1597 case 91:
1598 goto st50
1599 }
1600 switch {
1601 case data[p] < 93:
1602 switch {
1603 case data[p] > 64:
1604 if 65 <= data[p] && data[p] <= 92 {
1605 goto tr86
1606 }
1607 case data[p] >= 32:
1608 goto st50
1609 }
1610 case data[p] > 96:
1611 switch {
1612 case data[p] > 122:
1613 if 123 <= data[p] && data[p] <= 126 {
1614 goto st50
1615 }
1616 case data[p] >= 97:
1617 goto tr86
1618 }
1619 default:
1620 goto st50
1621 }
1622 goto st0
1623 st66:
1624 if p++; p == pe {
1625 goto _test_eof66
1626 }
1627 st_case_66:
1628 switch data[p] {
1629 case 35:
1630 goto tr84
1631 case 47:
1632 goto tr86
1633 case 63:
1634 goto tr85
1635 case 91:
1636 goto st50
1637 }
1638 switch {
1639 case data[p] < 71:
1640 switch {
1641 case data[p] < 48:
1642 if 32 <= data[p] && data[p] <= 46 {
1643 goto st50
1644 }
1645 case data[p] > 57:
1646 switch {
1647 case data[p] > 64:
1648 if 65 <= data[p] && data[p] <= 70 {
1649 goto tr93
1650 }
1651 case data[p] >= 58:
1652 goto st50
1653 }
1654 default:
1655 goto st67
1656 }
1657 case data[p] > 92:
1658 switch {
1659 case data[p] < 97:
1660 if 93 <= data[p] && data[p] <= 96 {
1661 goto st50
1662 }
1663 case data[p] > 102:
1664 switch {
1665 case data[p] > 122:
1666 if 123 <= data[p] && data[p] <= 126 {
1667 goto st50
1668 }
1669 case data[p] >= 103:
1670 goto tr86
1671 }
1672 default:
1673 goto tr93
1674 }
1675 default:
1676 goto tr86
1677 }
1678 goto st0
1679 tr93:
1680 //line parser.rl:13
1681
1682 if port_mark > host_mark {
1683 u.Port = data[port_mark:p]
1684 }
1685
1686 //line parser.rl:10
1687 mark = p
1688 goto st67
1689 st67:
1690 if p++; p == pe {
1691 goto _test_eof67
1692 }
1693 st_case_67:
1694 //line parser.go:1700
1695 switch data[p] {
1696 case 35:
1697 goto tr57
1698 case 63:
1699 goto tr58
1700 }
1701 switch {
1702 case data[p] < 65:
1703 switch {
1704 case data[p] < 48:
1705 if 32 <= data[p] && data[p] <= 47 {
1706 goto st50
1707 }
1708 case data[p] > 57:
1709 if 58 <= data[p] && data[p] <= 64 {
1710 goto st50
1711 }
1712 default:
1713 goto st65
1714 }
1715 case data[p] > 70:
1716 switch {
1717 case data[p] < 97:
1718 if 71 <= data[p] && data[p] <= 96 {
1719 goto st50
1720 }
1721 case data[p] > 102:
1722 if 103 <= data[p] && data[p] <= 126 {
1723 goto st50
1724 }
1725 default:
1726 goto st65
1727 }
1728 default:
1729 goto st65
1730 }
1731 goto st0
1732 st68:
1733 if p++; p == pe {
1734 goto _test_eof68
1735 }
1736 st_case_68:
1737 switch data[p] {
1738 case 35:
1739 goto tr64
1740 case 37:
1741 goto st61
1742 case 47:
1743 goto tr66
1744 case 63:
1745 goto tr67
1746 case 92:
1747 goto tr77
1748 }
1749 switch {
1750 case data[p] < 71:
1751 switch {
1752 case data[p] < 48:
1753 if 32 <= data[p] && data[p] <= 46 {
1754 goto st56
1755 }
1756 case data[p] > 57:
1757 switch {
1758 case data[p] > 64:
1759 if 65 <= data[p] && data[p] <= 70 {
1760 goto tr95
1761 }
1762 case data[p] >= 58:
1763 goto st56
1764 }
1765 default:
1766 goto st69
1767 }
1768 case data[p] > 90:
1769 switch {
1770 case data[p] < 97:
1771 if 91 <= data[p] && data[p] <= 96 {
1772 goto st56
1773 }
1774 case data[p] > 102:
1775 switch {
1776 case data[p] > 122:
1777 if 123 <= data[p] && data[p] <= 126 {
1778 goto st56
1779 }
1780 case data[p] >= 103:
1781 goto tr76
1782 }
1783 default:
1784 goto tr95
1785 }
1786 default:
1787 goto tr76
1788 }
1789 goto st0
1790 tr95:
1791 //line parser.rl:13
1792
1793 if port_mark > host_mark {
1794 u.Port = data[port_mark:p]
1795 }
1796
1797 //line parser.rl:10
1798 mark = p
1799 goto st69
1800 st69:
1801 if p++; p == pe {
1802 goto _test_eof69
1803 }
1804 st_case_69:
1805 //line parser.go:1811
1806 switch data[p] {
1807 case 35:
1808 goto tr64
1809 case 37:
1810 goto st58
1811 case 47:
1812 goto tr66
1813 case 63:
1814 goto tr67
1815 case 92:
1816 goto tr80
1817 }
1818 switch {
1819 case data[p] < 71:
1820 switch {
1821 case data[p] < 48:
1822 if 32 <= data[p] && data[p] <= 46 {
1823 goto st57
1824 }
1825 case data[p] > 57:
1826 switch {
1827 case data[p] > 64:
1828 if 65 <= data[p] && data[p] <= 70 {
1829 goto tr72
1830 }
1831 case data[p] >= 58:
1832 goto st57
1833 }
1834 default:
1835 goto st55
1836 }
1837 case data[p] > 90:
1838 switch {
1839 case data[p] < 97:
1840 if 91 <= data[p] && data[p] <= 96 {
1841 goto st57
1842 }
1843 case data[p] > 102:
1844 switch {
1845 case data[p] > 122:
1846 if 123 <= data[p] && data[p] <= 126 {
1847 goto st57
1848 }
1849 case data[p] >= 103:
1850 goto tr79
1851 }
1852 default:
1853 goto tr72
1854 }
1855 default:
1856 goto tr79
1857 }
1858 goto st0
1859 tr73:
1860 //line parser.rl:13
1861
1862 if port_mark > host_mark {
1863 u.Port = data[port_mark:p]
1864 }
1865
1866 //line parser.rl:10
1867 mark = p
1868 goto st70
1869 tr149:
1870 //line parser.rl:27
1871
1872 u.Host = data[host_mark:p]
1873
1874 //line parser.rl:13
1875
1876 if port_mark > host_mark {
1877 u.Port = data[port_mark:p]
1878 }
1879
1880 //line parser.rl:10
1881 mark = p
1882 goto st70
1883 st70:
1884 if p++; p == pe {
1885 goto _test_eof70
1886 }
1887 st_case_70:
1888 //line parser.go:1894
1889 switch data[p] {
1890 case 35:
1891 goto tr84
1892 case 37:
1893 goto st72
1894 case 47:
1895 goto tr66
1896 case 63:
1897 goto tr85
1898 case 91:
1899 goto st71
1900 }
1901 switch {
1902 case data[p] < 93:
1903 switch {
1904 case data[p] > 64:
1905 if 65 <= data[p] && data[p] <= 92 {
1906 goto tr98
1907 }
1908 case data[p] >= 32:
1909 goto st71
1910 }
1911 case data[p] > 96:
1912 switch {
1913 case data[p] > 122:
1914 if 123 <= data[p] && data[p] <= 126 {
1915 goto st71
1916 }
1917 case data[p] >= 97:
1918 goto tr98
1919 }
1920 default:
1921 goto st71
1922 }
1923 goto st0
1924 tr98:
1925 //line parser.rl:13
1926
1927 if port_mark > host_mark {
1928 u.Port = data[port_mark:p]
1929 }
1930
1931 //line parser.rl:10
1932 mark = p
1933 goto st71
1934 st71:
1935 if p++; p == pe {
1936 goto _test_eof71
1937 }
1938 st_case_71:
1939 //line parser.go:1945
1940 switch data[p] {
1941 case 35:
1942 goto tr84
1943 case 37:
1944 goto st66
1945 case 47:
1946 goto tr86
1947 case 63:
1948 goto tr85
1949 case 91:
1950 goto st65
1951 }
1952 switch {
1953 case data[p] < 93:
1954 switch {
1955 case data[p] > 64:
1956 if 65 <= data[p] && data[p] <= 92 {
1957 goto tr91
1958 }
1959 case data[p] >= 32:
1960 goto st65
1961 }
1962 case data[p] > 96:
1963 switch {
1964 case data[p] > 122:
1965 if 123 <= data[p] && data[p] <= 126 {
1966 goto st65
1967 }
1968 case data[p] >= 97:
1969 goto tr91
1970 }
1971 default:
1972 goto st65
1973 }
1974 goto st0
1975 st72:
1976 if p++; p == pe {
1977 goto _test_eof72
1978 }
1979 st_case_72:
1980 switch data[p] {
1981 case 35:
1982 goto tr84
1983 case 37:
1984 goto st66
1985 case 47:
1986 goto tr86
1987 case 63:
1988 goto tr85
1989 case 91:
1990 goto st65
1991 }
1992 switch {
1993 case data[p] < 71:
1994 switch {
1995 case data[p] < 48:
1996 if 32 <= data[p] && data[p] <= 46 {
1997 goto st65
1998 }
1999 case data[p] > 57:
2000 switch {
2001 case data[p] > 64:
2002 if 65 <= data[p] && data[p] <= 70 {
2003 goto tr100
2004 }
2005 case data[p] >= 58:
2006 goto st65
2007 }
2008 default:
2009 goto st73
2010 }
2011 case data[p] > 92:
2012 switch {
2013 case data[p] < 97:
2014 if 93 <= data[p] && data[p] <= 96 {
2015 goto st65
2016 }
2017 case data[p] > 102:
2018 switch {
2019 case data[p] > 122:
2020 if 123 <= data[p] && data[p] <= 126 {
2021 goto st65
2022 }
2023 case data[p] >= 103:
2024 goto tr91
2025 }
2026 default:
2027 goto tr100
2028 }
2029 default:
2030 goto tr91
2031 }
2032 goto st0
2033 tr100:
2034 //line parser.rl:13
2035
2036 if port_mark > host_mark {
2037 u.Port = data[port_mark:p]
2038 }
2039
2040 //line parser.rl:10
2041 mark = p
2042 goto st73
2043 st73:
2044 if p++; p == pe {
2045 goto _test_eof73
2046 }
2047 st_case_73:
2048 //line parser.go:2054
2049 switch data[p] {
2050 case 35:
2051 goto tr84
2052 case 47:
2053 goto tr86
2054 case 63:
2055 goto tr85
2056 case 91:
2057 goto st50
2058 }
2059 switch {
2060 case data[p] < 71:
2061 switch {
2062 case data[p] < 48:
2063 if 32 <= data[p] && data[p] <= 46 {
2064 goto st50
2065 }
2066 case data[p] > 57:
2067 switch {
2068 case data[p] > 64:
2069 if 65 <= data[p] && data[p] <= 70 {
2070 goto tr98
2071 }
2072 case data[p] >= 58:
2073 goto st50
2074 }
2075 default:
2076 goto st71
2077 }
2078 case data[p] > 92:
2079 switch {
2080 case data[p] < 97:
2081 if 93 <= data[p] && data[p] <= 96 {
2082 goto st50
2083 }
2084 case data[p] > 102:
2085 switch {
2086 case data[p] > 122:
2087 if 123 <= data[p] && data[p] <= 126 {
2088 goto st50
2089 }
2090 case data[p] >= 103:
2091 goto tr86
2092 }
2093 default:
2094 goto tr98
2095 }
2096 default:
2097 goto tr86
2098 }
2099 goto st0
2100 st74:
2101 if p++; p == pe {
2102 goto _test_eof74
2103 }
2104 st_case_74:
2105 switch data[p] {
2106 case 35:
2107 goto tr64
2108 case 37:
2109 goto st68
2110 case 47:
2111 goto tr66
2112 case 63:
2113 goto tr67
2114 case 92:
2115 goto tr73
2116 }
2117 switch {
2118 case data[p] < 71:
2119 switch {
2120 case data[p] < 48:
2121 if 32 <= data[p] && data[p] <= 46 {
2122 goto st55
2123 }
2124 case data[p] > 57:
2125 switch {
2126 case data[p] > 64:
2127 if 65 <= data[p] && data[p] <= 70 {
2128 goto tr102
2129 }
2130 case data[p] >= 58:
2131 goto st55
2132 }
2133 default:
2134 goto st75
2135 }
2136 case data[p] > 90:
2137 switch {
2138 case data[p] < 97:
2139 if 91 <= data[p] && data[p] <= 96 {
2140 goto st55
2141 }
2142 case data[p] > 102:
2143 switch {
2144 case data[p] > 122:
2145 if 123 <= data[p] && data[p] <= 126 {
2146 goto st55
2147 }
2148 case data[p] >= 103:
2149 goto tr72
2150 }
2151 default:
2152 goto tr102
2153 }
2154 default:
2155 goto tr72
2156 }
2157 goto st0
2158 tr102:
2159 //line parser.rl:13
2160
2161 if port_mark > host_mark {
2162 u.Port = data[port_mark:p]
2163 }
2164
2165 //line parser.rl:10
2166 mark = p
2167 goto st75
2168 st75:
2169 if p++; p == pe {
2170 goto _test_eof75
2171 }
2172 st_case_75:
2173 //line parser.go:2179
2174 switch data[p] {
2175 case 35:
2176 goto tr64
2177 case 37:
2178 goto st61
2179 case 47:
2180 goto tr66
2181 case 63:
2182 goto tr67
2183 case 92:
2184 goto tr77
2185 }
2186 switch {
2187 case data[p] < 71:
2188 switch {
2189 case data[p] < 48:
2190 if 32 <= data[p] && data[p] <= 46 {
2191 goto st56
2192 }
2193 case data[p] > 57:
2194 switch {
2195 case data[p] > 64:
2196 if 65 <= data[p] && data[p] <= 70 {
2197 goto tr68
2198 }
2199 case data[p] >= 58:
2200 goto st56
2201 }
2202 default:
2203 goto st54
2204 }
2205 case data[p] > 90:
2206 switch {
2207 case data[p] < 97:
2208 if 91 <= data[p] && data[p] <= 96 {
2209 goto st56
2210 }
2211 case data[p] > 102:
2212 switch {
2213 case data[p] > 122:
2214 if 123 <= data[p] && data[p] <= 126 {
2215 goto st56
2216 }
2217 case data[p] >= 103:
2218 goto tr76
2219 }
2220 default:
2221 goto tr68
2222 }
2223 default:
2224 goto tr76
2225 }
2226 goto st0
2227 tr69:
2228 //line parser.rl:13
2229
2230 if port_mark > host_mark {
2231 u.Port = data[port_mark:p]
2232 }
2233
2234 //line parser.rl:10
2235 mark = p
2236 goto st76
2237 tr239:
2238 //line parser.rl:27
2239
2240 u.Host = data[host_mark:p]
2241
2242 //line parser.rl:13
2243
2244 if port_mark > host_mark {
2245 u.Port = data[port_mark:p]
2246 }
2247
2248 //line parser.rl:10
2249 mark = p
2250 goto st76
2251 st76:
2252 if p++; p == pe {
2253 goto _test_eof76
2254 }
2255 st_case_76:
2256 //line parser.go:2262
2257 switch data[p] {
2258 case 35:
2259 goto tr84
2260 case 37:
2261 goto st78
2262 case 47:
2263 goto tr66
2264 case 63:
2265 goto tr85
2266 case 91:
2267 goto st77
2268 }
2269 switch {
2270 case data[p] < 93:
2271 switch {
2272 case data[p] > 64:
2273 if 65 <= data[p] && data[p] <= 92 {
2274 goto tr105
2275 }
2276 case data[p] >= 32:
2277 goto st77
2278 }
2279 case data[p] > 96:
2280 switch {
2281 case data[p] > 122:
2282 if 123 <= data[p] && data[p] <= 126 {
2283 goto st77
2284 }
2285 case data[p] >= 97:
2286 goto tr105
2287 }
2288 default:
2289 goto st77
2290 }
2291 goto st0
2292 tr105:
2293 //line parser.rl:13
2294
2295 if port_mark > host_mark {
2296 u.Port = data[port_mark:p]
2297 }
2298
2299 //line parser.rl:10
2300 mark = p
2301 goto st77
2302 st77:
2303 if p++; p == pe {
2304 goto _test_eof77
2305 }
2306 st_case_77:
2307 //line parser.go:2313
2308 switch data[p] {
2309 case 35:
2310 goto tr84
2311 case 37:
2312 goto st72
2313 case 47:
2314 goto tr86
2315 case 63:
2316 goto tr85
2317 case 91:
2318 goto st71
2319 }
2320 switch {
2321 case data[p] < 93:
2322 switch {
2323 case data[p] > 64:
2324 if 65 <= data[p] && data[p] <= 92 {
2325 goto tr98
2326 }
2327 case data[p] >= 32:
2328 goto st71
2329 }
2330 case data[p] > 96:
2331 switch {
2332 case data[p] > 122:
2333 if 123 <= data[p] && data[p] <= 126 {
2334 goto st71
2335 }
2336 case data[p] >= 97:
2337 goto tr98
2338 }
2339 default:
2340 goto st71
2341 }
2342 goto st0
2343 st78:
2344 if p++; p == pe {
2345 goto _test_eof78
2346 }
2347 st_case_78:
2348 switch data[p] {
2349 case 35:
2350 goto tr84
2351 case 37:
2352 goto st72
2353 case 47:
2354 goto tr86
2355 case 63:
2356 goto tr85
2357 case 91:
2358 goto st71
2359 }
2360 switch {
2361 case data[p] < 71:
2362 switch {
2363 case data[p] < 48:
2364 if 32 <= data[p] && data[p] <= 46 {
2365 goto st71
2366 }
2367 case data[p] > 57:
2368 switch {
2369 case data[p] > 64:
2370 if 65 <= data[p] && data[p] <= 70 {
2371 goto tr107
2372 }
2373 case data[p] >= 58:
2374 goto st71
2375 }
2376 default:
2377 goto st79
2378 }
2379 case data[p] > 92:
2380 switch {
2381 case data[p] < 97:
2382 if 93 <= data[p] && data[p] <= 96 {
2383 goto st71
2384 }
2385 case data[p] > 102:
2386 switch {
2387 case data[p] > 122:
2388 if 123 <= data[p] && data[p] <= 126 {
2389 goto st71
2390 }
2391 case data[p] >= 103:
2392 goto tr98
2393 }
2394 default:
2395 goto tr107
2396 }
2397 default:
2398 goto tr98
2399 }
2400 goto st0
2401 tr107:
2402 //line parser.rl:13
2403
2404 if port_mark > host_mark {
2405 u.Port = data[port_mark:p]
2406 }
2407
2408 //line parser.rl:10
2409 mark = p
2410 goto st79
2411 st79:
2412 if p++; p == pe {
2413 goto _test_eof79
2414 }
2415 st_case_79:
2416 //line parser.go:2422
2417 switch data[p] {
2418 case 35:
2419 goto tr84
2420 case 37:
2421 goto st66
2422 case 47:
2423 goto tr86
2424 case 63:
2425 goto tr85
2426 case 91:
2427 goto st65
2428 }
2429 switch {
2430 case data[p] < 71:
2431 switch {
2432 case data[p] < 48:
2433 if 32 <= data[p] && data[p] <= 46 {
2434 goto st65
2435 }
2436 case data[p] > 57:
2437 switch {
2438 case data[p] > 64:
2439 if 65 <= data[p] && data[p] <= 70 {
2440 goto tr105
2441 }
2442 case data[p] >= 58:
2443 goto st65
2444 }
2445 default:
2446 goto st77
2447 }
2448 case data[p] > 92:
2449 switch {
2450 case data[p] < 97:
2451 if 93 <= data[p] && data[p] <= 96 {
2452 goto st65
2453 }
2454 case data[p] > 102:
2455 switch {
2456 case data[p] > 122:
2457 if 123 <= data[p] && data[p] <= 126 {
2458 goto st65
2459 }
2460 case data[p] >= 103:
2461 goto tr91
2462 }
2463 default:
2464 goto tr105
2465 }
2466 default:
2467 goto tr91
2468 }
2469 goto st0
2470 tr4:
2471 //line parser.rl:11
2472 port_mark = p
2473 goto st80
2474 tr137:
2475 //line parser.rl:13
2476
2477 if port_mark > host_mark {
2478 u.Port = data[port_mark:p]
2479 }
2480
2481 //line parser.rl:10
2482 mark = p
2483 goto st80
2484 tr160:
2485 //line parser.rl:11
2486 port_mark = p
2487 //line parser.rl:13
2488
2489 if port_mark > host_mark {
2490 u.Port = data[port_mark:p]
2491 }
2492
2493 //line parser.rl:10
2494 mark = p
2495 goto st80
2496 tr231:
2497 //line parser.rl:19
2498
2499 u.Protocol = data[0 : p-1]
2500
2501 //line parser.rl:11
2502 port_mark = p
2503 goto st80
2504 st80:
2505 if p++; p == pe {
2506 goto _test_eof80
2507 }
2508 st_case_80:
2509 //line parser.go:2515
2510 switch data[p] {
2511 case 33:
2512 goto st81
2513 case 35:
2514 goto tr64
2515 case 37:
2516 goto st142
2517 case 47:
2518 goto tr66
2519 case 60:
2520 goto st54
2521 case 62:
2522 goto st54
2523 case 63:
2524 goto tr67
2525 case 64:
2526 goto st119
2527 case 92:
2528 goto tr69
2529 case 95:
2530 goto st81
2531 case 126:
2532 goto st81
2533 }
2534 switch {
2535 case data[p] < 65:
2536 switch {
2537 case data[p] > 34:
2538 if 36 <= data[p] && data[p] <= 61 {
2539 goto st81
2540 }
2541 case data[p] >= 32:
2542 goto st54
2543 }
2544 case data[p] > 90:
2545 switch {
2546 case data[p] < 97:
2547 if 91 <= data[p] && data[p] <= 96 {
2548 goto st54
2549 }
2550 case data[p] > 122:
2551 if 123 <= data[p] && data[p] <= 125 {
2552 goto st54
2553 }
2554 default:
2555 goto tr111
2556 }
2557 default:
2558 goto tr111
2559 }
2560 goto st0
2561 tr111:
2562 //line parser.rl:13
2563
2564 if port_mark > host_mark {
2565 u.Port = data[port_mark:p]
2566 }
2567
2568 //line parser.rl:10
2569 mark = p
2570 goto st81
2571 st81:
2572 if p++; p == pe {
2573 goto _test_eof81
2574 }
2575 st_case_81:
2576 //line parser.go:2582
2577 switch data[p] {
2578 case 33:
2579 goto st82
2580 case 35:
2581 goto tr64
2582 case 37:
2583 goto st140
2584 case 47:
2585 goto tr66
2586 case 60:
2587 goto st55
2588 case 62:
2589 goto st55
2590 case 63:
2591 goto tr67
2592 case 64:
2593 goto st112
2594 case 92:
2595 goto tr73
2596 case 95:
2597 goto st82
2598 case 126:
2599 goto st82
2600 }
2601 switch {
2602 case data[p] < 65:
2603 switch {
2604 case data[p] > 34:
2605 if 36 <= data[p] && data[p] <= 61 {
2606 goto st82
2607 }
2608 case data[p] >= 32:
2609 goto st55
2610 }
2611 case data[p] > 90:
2612 switch {
2613 case data[p] < 97:
2614 if 91 <= data[p] && data[p] <= 96 {
2615 goto st55
2616 }
2617 case data[p] > 122:
2618 if 123 <= data[p] && data[p] <= 125 {
2619 goto st55
2620 }
2621 default:
2622 goto tr115
2623 }
2624 default:
2625 goto tr115
2626 }
2627 goto st0
2628 tr115:
2629 //line parser.rl:13
2630
2631 if port_mark > host_mark {
2632 u.Port = data[port_mark:p]
2633 }
2634
2635 //line parser.rl:10
2636 mark = p
2637 goto st82
2638 st82:
2639 if p++; p == pe {
2640 goto _test_eof82
2641 }
2642 st_case_82:
2643 //line parser.go:2649
2644 switch data[p] {
2645 case 33:
2646 goto st83
2647 case 35:
2648 goto tr64
2649 case 37:
2650 goto st137
2651 case 47:
2652 goto tr66
2653 case 60:
2654 goto st56
2655 case 62:
2656 goto st56
2657 case 63:
2658 goto tr67
2659 case 64:
2660 goto st108
2661 case 92:
2662 goto tr77
2663 case 95:
2664 goto st83
2665 case 126:
2666 goto st83
2667 }
2668 switch {
2669 case data[p] < 65:
2670 switch {
2671 case data[p] > 34:
2672 if 36 <= data[p] && data[p] <= 61 {
2673 goto st83
2674 }
2675 case data[p] >= 32:
2676 goto st56
2677 }
2678 case data[p] > 90:
2679 switch {
2680 case data[p] < 97:
2681 if 91 <= data[p] && data[p] <= 96 {
2682 goto st56
2683 }
2684 case data[p] > 122:
2685 if 123 <= data[p] && data[p] <= 125 {
2686 goto st56
2687 }
2688 default:
2689 goto tr119
2690 }
2691 default:
2692 goto tr119
2693 }
2694 goto st0
2695 tr119:
2696 //line parser.rl:13
2697
2698 if port_mark > host_mark {
2699 u.Port = data[port_mark:p]
2700 }
2701
2702 //line parser.rl:10
2703 mark = p
2704 goto st83
2705 st83:
2706 if p++; p == pe {
2707 goto _test_eof83
2708 }
2709 st_case_83:
2710 //line parser.go:2716
2711 switch data[p] {
2712 case 33:
2713 goto st84
2714 case 35:
2715 goto tr64
2716 case 37:
2717 goto st88
2718 case 47:
2719 goto tr66
2720 case 60:
2721 goto st57
2722 case 62:
2723 goto st57
2724 case 63:
2725 goto tr67
2726 case 64:
2727 goto st89
2728 case 92:
2729 goto tr80
2730 case 95:
2731 goto st84
2732 case 126:
2733 goto st84
2734 }
2735 switch {
2736 case data[p] < 65:
2737 switch {
2738 case data[p] > 34:
2739 if 36 <= data[p] && data[p] <= 61 {
2740 goto st84
2741 }
2742 case data[p] >= 32:
2743 goto st57
2744 }
2745 case data[p] > 90:
2746 switch {
2747 case data[p] < 97:
2748 if 91 <= data[p] && data[p] <= 96 {
2749 goto st57
2750 }
2751 case data[p] > 122:
2752 if 123 <= data[p] && data[p] <= 125 {
2753 goto st57
2754 }
2755 default:
2756 goto tr122
2757 }
2758 default:
2759 goto tr122
2760 }
2761 goto st0
2762 st84:
2763 if p++; p == pe {
2764 goto _test_eof84
2765 }
2766 st_case_84:
2767 switch data[p] {
2768 case 33:
2769 goto st8
2770 case 35:
2771 goto tr64
2772 case 37:
2773 goto st9
2774 case 47:
2775 goto tr66
2776 case 61:
2777 goto st8
2778 case 63:
2779 goto tr67
2780 case 64:
2781 goto st11
2782 case 92:
2783 goto tr66
2784 case 95:
2785 goto st8
2786 case 126:
2787 goto st8
2788 }
2789 switch {
2790 case data[p] < 65:
2791 if 36 <= data[p] && data[p] <= 59 {
2792 goto st8
2793 }
2794 case data[p] > 90:
2795 if 97 <= data[p] && data[p] <= 122 {
2796 goto tr123
2797 }
2798 default:
2799 goto tr123
2800 }
2801 goto st0
2802 st8:
2803 if p++; p == pe {
2804 goto _test_eof8
2805 }
2806 st_case_8:
2807 switch data[p] {
2808 case 33:
2809 goto st8
2810 case 37:
2811 goto st9
2812 case 61:
2813 goto st8
2814 case 64:
2815 goto st11
2816 case 95:
2817 goto st8
2818 case 126:
2819 goto st8
2820 }
2821 switch {
2822 case data[p] < 48:
2823 if 36 <= data[p] && data[p] <= 46 {
2824 goto st8
2825 }
2826 case data[p] > 59:
2827 switch {
2828 case data[p] > 90:
2829 if 97 <= data[p] && data[p] <= 122 {
2830 goto st8
2831 }
2832 case data[p] >= 65:
2833 goto st8
2834 }
2835 default:
2836 goto st8
2837 }
2838 goto st0
2839 st9:
2840 if p++; p == pe {
2841 goto _test_eof9
2842 }
2843 st_case_9:
2844 switch {
2845 case data[p] < 65:
2846 if 48 <= data[p] && data[p] <= 57 {
2847 goto st10
2848 }
2849 case data[p] > 70:
2850 if 97 <= data[p] && data[p] <= 102 {
2851 goto st10
2852 }
2853 default:
2854 goto st10
2855 }
2856 goto st0
2857 st10:
2858 if p++; p == pe {
2859 goto _test_eof10
2860 }
2861 st_case_10:
2862 switch {
2863 case data[p] < 65:
2864 if 48 <= data[p] && data[p] <= 57 {
2865 goto st8
2866 }
2867 case data[p] > 70:
2868 if 97 <= data[p] && data[p] <= 102 {
2869 goto st8
2870 }
2871 default:
2872 goto st8
2873 }
2874 goto st0
2875 st11:
2876 if p++; p == pe {
2877 goto _test_eof11
2878 }
2879 st_case_11:
2880 switch data[p] {
2881 case 33:
2882 goto tr14
2883 case 37:
2884 goto tr15
2885 case 58:
2886 goto st8
2887 case 61:
2888 goto tr14
2889 case 64:
2890 goto st11
2891 case 91:
2892 goto tr16
2893 case 95:
2894 goto tr14
2895 case 126:
2896 goto tr14
2897 }
2898 switch {
2899 case data[p] < 48:
2900 if 36 <= data[p] && data[p] <= 46 {
2901 goto tr14
2902 }
2903 case data[p] > 59:
2904 switch {
2905 case data[p] > 90:
2906 if 97 <= data[p] && data[p] <= 122 {
2907 goto tr14
2908 }
2909 case data[p] >= 65:
2910 goto tr14
2911 }
2912 default:
2913 goto tr14
2914 }
2915 goto st0
2916 tr16:
2917 //line parser.rl:23
2918
2919 host_mark = p
2920
2921 goto st12
2922 st12:
2923 if p++; p == pe {
2924 goto _test_eof12
2925 }
2926 st_case_12:
2927 //line parser.go:2933
2928 if data[p] == 118 {
2929 goto st28
2930 }
2931 switch {
2932 case data[p] < 65:
2933 if 48 <= data[p] && data[p] <= 58 {
2934 goto st13
2935 }
2936 case data[p] > 70:
2937 if 97 <= data[p] && data[p] <= 102 {
2938 goto st13
2939 }
2940 default:
2941 goto st13
2942 }
2943 goto st0
2944 st13:
2945 if p++; p == pe {
2946 goto _test_eof13
2947 }
2948 st_case_13:
2949 switch data[p] {
2950 case 58:
2951 goto st13
2952 case 93:
2953 goto st85
2954 }
2955 switch {
2956 case data[p] < 65:
2957 if 48 <= data[p] && data[p] <= 57 {
2958 goto st14
2959 }
2960 case data[p] > 70:
2961 if 97 <= data[p] && data[p] <= 102 {
2962 goto st13
2963 }
2964 default:
2965 goto st13
2966 }
2967 goto st0
2968 st14:
2969 if p++; p == pe {
2970 goto _test_eof14
2971 }
2972 st_case_14:
2973 switch data[p] {
2974 case 46:
2975 goto st15
2976 case 58:
2977 goto st13
2978 case 93:
2979 goto st85
2980 }
2981 switch {
2982 case data[p] < 65:
2983 if 48 <= data[p] && data[p] <= 57 {
2984 goto st14
2985 }
2986 case data[p] > 70:
2987 if 97 <= data[p] && data[p] <= 102 {
2988 goto st13
2989 }
2990 default:
2991 goto st13
2992 }
2993 goto st0
2994 st15:
2995 if p++; p == pe {
2996 goto _test_eof15
2997 }
2998 st_case_15:
2999 if 48 <= data[p] && data[p] <= 57 {
3000 goto st16
3001 }
3002 goto st0
3003 st16:
3004 if p++; p == pe {
3005 goto _test_eof16
3006 }
3007 st_case_16:
3008 if data[p] == 46 {
3009 goto st17
3010 }
3011 if 48 <= data[p] && data[p] <= 57 {
3012 goto st26
3013 }
3014 goto st0
3015 st17:
3016 if p++; p == pe {
3017 goto _test_eof17
3018 }
3019 st_case_17:
3020 if 48 <= data[p] && data[p] <= 57 {
3021 goto st18
3022 }
3023 goto st0
3024 st18:
3025 if p++; p == pe {
3026 goto _test_eof18
3027 }
3028 st_case_18:
3029 if data[p] == 46 {
3030 goto st19
3031 }
3032 if 48 <= data[p] && data[p] <= 57 {
3033 goto st24
3034 }
3035 goto st0
3036 st19:
3037 if p++; p == pe {
3038 goto _test_eof19
3039 }
3040 st_case_19:
3041 if 48 <= data[p] && data[p] <= 57 {
3042 goto st20
3043 }
3044 goto st0
3045 st20:
3046 if p++; p == pe {
3047 goto _test_eof20
3048 }
3049 st_case_20:
3050 if data[p] == 93 {
3051 goto st85
3052 }
3053 if 48 <= data[p] && data[p] <= 57 {
3054 goto st21
3055 }
3056 goto st0
3057 st21:
3058 if p++; p == pe {
3059 goto _test_eof21
3060 }
3061 st_case_21:
3062 if data[p] == 93 {
3063 goto st85
3064 }
3065 if 48 <= data[p] && data[p] <= 57 {
3066 goto st22
3067 }
3068 goto st0
3069 st22:
3070 if p++; p == pe {
3071 goto _test_eof22
3072 }
3073 st_case_22:
3074 if data[p] == 93 {
3075 goto st85
3076 }
3077 goto st0
3078 st85:
3079 if p++; p == pe {
3080 goto _test_eof85
3081 }
3082 st_case_85:
3083 switch data[p] {
3084 case 35:
3085 goto tr48
3086 case 47:
3087 goto tr50
3088 case 58:
3089 goto tr124
3090 case 63:
3091 goto tr52
3092 case 92:
3093 goto tr50
3094 }
3095 switch {
3096 case data[p] > 90:
3097 if 97 <= data[p] && data[p] <= 122 {
3098 goto tr125
3099 }
3100 case data[p] >= 65:
3101 goto tr125
3102 }
3103 goto st0
3104 tr124:
3105 //line parser.rl:27
3106
3107 u.Host = data[host_mark:p]
3108
3109 goto st23
3110 st23:
3111 if p++; p == pe {
3112 goto _test_eof23
3113 }
3114 st_case_23:
3115 //line parser.go:3121
3116 if data[p] == 37 {
3117 goto tr31
3118 }
3119 switch {
3120 case data[p] < 36:
3121 if 32 <= data[p] && data[p] <= 34 {
3122 goto tr3
3123 }
3124 case data[p] > 46:
3125 switch {
3126 case data[p] > 62:
3127 if 64 <= data[p] && data[p] <= 126 {
3128 goto tr3
3129 }
3130 case data[p] >= 48:
3131 goto tr3
3132 }
3133 default:
3134 goto tr3
3135 }
3136 goto st0
3137 tr31:
3138 //line parser.rl:11
3139 port_mark = p
3140 goto st86
3141 st86:
3142 if p++; p == pe {
3143 goto _test_eof86
3144 }
3145 st_case_86:
3146 //line parser.go:3152
3147 switch data[p] {
3148 case 35:
3149 goto tr64
3150 case 37:
3151 goto st74
3152 case 47:
3153 goto tr66
3154 case 63:
3155 goto tr67
3156 case 92:
3157 goto tr69
3158 }
3159 switch {
3160 case data[p] < 71:
3161 switch {
3162 case data[p] < 48:
3163 if 32 <= data[p] && data[p] <= 46 {
3164 goto st54
3165 }
3166 case data[p] > 57:
3167 switch {
3168 case data[p] > 64:
3169 if 65 <= data[p] && data[p] <= 70 {
3170 goto tr127
3171 }
3172 case data[p] >= 58:
3173 goto st54
3174 }
3175 default:
3176 goto st87
3177 }
3178 case data[p] > 90:
3179 switch {
3180 case data[p] < 97:
3181 if 91 <= data[p] && data[p] <= 96 {
3182 goto st54
3183 }
3184 case data[p] > 102:
3185 switch {
3186 case data[p] > 122:
3187 if 123 <= data[p] && data[p] <= 126 {
3188 goto st54
3189 }
3190 case data[p] >= 103:
3191 goto tr68
3192 }
3193 default:
3194 goto tr127
3195 }
3196 default:
3197 goto tr68
3198 }
3199 goto st0
3200 tr127:
3201 //line parser.rl:13
3202
3203 if port_mark > host_mark {
3204 u.Port = data[port_mark:p]
3205 }
3206
3207 //line parser.rl:10
3208 mark = p
3209 goto st87
3210 st87:
3211 if p++; p == pe {
3212 goto _test_eof87
3213 }
3214 st_case_87:
3215 //line parser.go:3221
3216 switch data[p] {
3217 case 35:
3218 goto tr64
3219 case 37:
3220 goto st68
3221 case 47:
3222 goto tr66
3223 case 63:
3224 goto tr67
3225 case 92:
3226 goto tr73
3227 }
3228 switch {
3229 case data[p] < 71:
3230 switch {
3231 case data[p] < 48:
3232 if 32 <= data[p] && data[p] <= 46 {
3233 goto st55
3234 }
3235 case data[p] > 57:
3236 switch {
3237 case data[p] > 64:
3238 if 65 <= data[p] && data[p] <= 70 {
3239 goto tr129
3240 }
3241 case data[p] >= 58:
3242 goto st55
3243 }
3244 default:
3245 goto st53
3246 }
3247 case data[p] > 90:
3248 switch {
3249 case data[p] < 97:
3250 if 91 <= data[p] && data[p] <= 96 {
3251 goto st55
3252 }
3253 case data[p] > 102:
3254 switch {
3255 case data[p] > 122:
3256 if 123 <= data[p] && data[p] <= 126 {
3257 goto st55
3258 }
3259 case data[p] >= 103:
3260 goto tr72
3261 }
3262 default:
3263 goto tr129
3264 }
3265 default:
3266 goto tr72
3267 }
3268 goto st0
3269 st24:
3270 if p++; p == pe {
3271 goto _test_eof24
3272 }
3273 st_case_24:
3274 if data[p] == 46 {
3275 goto st19
3276 }
3277 if 48 <= data[p] && data[p] <= 57 {
3278 goto st25
3279 }
3280 goto st0
3281 st25:
3282 if p++; p == pe {
3283 goto _test_eof25
3284 }
3285 st_case_25:
3286 if data[p] == 46 {
3287 goto st19
3288 }
3289 goto st0
3290 st26:
3291 if p++; p == pe {
3292 goto _test_eof26
3293 }
3294 st_case_26:
3295 if data[p] == 46 {
3296 goto st17
3297 }
3298 if 48 <= data[p] && data[p] <= 57 {
3299 goto st27
3300 }
3301 goto st0
3302 st27:
3303 if p++; p == pe {
3304 goto _test_eof27
3305 }
3306 st_case_27:
3307 if data[p] == 46 {
3308 goto st17
3309 }
3310 goto st0
3311 st28:
3312 if p++; p == pe {
3313 goto _test_eof28
3314 }
3315 st_case_28:
3316 switch {
3317 case data[p] < 65:
3318 if 48 <= data[p] && data[p] <= 57 {
3319 goto st29
3320 }
3321 case data[p] > 70:
3322 if 97 <= data[p] && data[p] <= 102 {
3323 goto st29
3324 }
3325 default:
3326 goto st29
3327 }
3328 goto st0
3329 st29:
3330 if p++; p == pe {
3331 goto _test_eof29
3332 }
3333 st_case_29:
3334 if data[p] == 46 {
3335 goto st30
3336 }
3337 switch {
3338 case data[p] < 65:
3339 if 48 <= data[p] && data[p] <= 57 {
3340 goto st29
3341 }
3342 case data[p] > 70:
3343 if 97 <= data[p] && data[p] <= 102 {
3344 goto st29
3345 }
3346 default:
3347 goto st29
3348 }
3349 goto st0
3350 st30:
3351 if p++; p == pe {
3352 goto _test_eof30
3353 }
3354 st_case_30:
3355 switch data[p] {
3356 case 33:
3357 goto st31
3358 case 36:
3359 goto st31
3360 case 61:
3361 goto st31
3362 case 95:
3363 goto st31
3364 case 126:
3365 goto st31
3366 }
3367 switch {
3368 case data[p] < 48:
3369 if 38 <= data[p] && data[p] <= 46 {
3370 goto st31
3371 }
3372 case data[p] > 59:
3373 switch {
3374 case data[p] > 90:
3375 if 97 <= data[p] && data[p] <= 122 {
3376 goto st31
3377 }
3378 case data[p] >= 65:
3379 goto st31
3380 }
3381 default:
3382 goto st31
3383 }
3384 goto st0
3385 st31:
3386 if p++; p == pe {
3387 goto _test_eof31
3388 }
3389 st_case_31:
3390 switch data[p] {
3391 case 33:
3392 goto st31
3393 case 36:
3394 goto st31
3395 case 61:
3396 goto st31
3397 case 93:
3398 goto st85
3399 case 95:
3400 goto st31
3401 case 126:
3402 goto st31
3403 }
3404 switch {
3405 case data[p] < 48:
3406 if 38 <= data[p] && data[p] <= 46 {
3407 goto st31
3408 }
3409 case data[p] > 59:
3410 switch {
3411 case data[p] > 90:
3412 if 97 <= data[p] && data[p] <= 122 {
3413 goto st31
3414 }
3415 case data[p] >= 65:
3416 goto st31
3417 }
3418 default:
3419 goto st31
3420 }
3421 goto st0
3422 tr123:
3423 //line parser.rl:13
3424
3425 if port_mark > host_mark {
3426 u.Port = data[port_mark:p]
3427 }
3428
3429 //line parser.rl:10
3430 mark = p
3431 goto st32
3432 st32:
3433 if p++; p == pe {
3434 goto _test_eof32
3435 }
3436 st_case_32:
3437 //line parser.go:3443
3438 switch data[p] {
3439 case 33:
3440 goto st8
3441 case 37:
3442 goto st9
3443 case 58:
3444 goto st33
3445 case 61:
3446 goto st8
3447 case 64:
3448 goto st11
3449 case 95:
3450 goto st8
3451 case 126:
3452 goto st8
3453 }
3454 switch {
3455 case data[p] < 48:
3456 if 36 <= data[p] && data[p] <= 46 {
3457 goto st8
3458 }
3459 case data[p] > 59:
3460 switch {
3461 case data[p] > 90:
3462 if 97 <= data[p] && data[p] <= 122 {
3463 goto st8
3464 }
3465 case data[p] >= 65:
3466 goto st8
3467 }
3468 default:
3469 goto st8
3470 }
3471 goto st0
3472 st33:
3473 if p++; p == pe {
3474 goto _test_eof33
3475 }
3476 st_case_33:
3477 switch data[p] {
3478 case 33:
3479 goto st8
3480 case 37:
3481 goto st9
3482 case 47:
3483 goto st49
3484 case 61:
3485 goto st8
3486 case 64:
3487 goto st11
3488 case 92:
3489 goto st49
3490 case 95:
3491 goto st8
3492 case 126:
3493 goto st8
3494 }
3495 switch {
3496 case data[p] < 65:
3497 if 36 <= data[p] && data[p] <= 59 {
3498 goto st8
3499 }
3500 case data[p] > 90:
3501 if 97 <= data[p] && data[p] <= 122 {
3502 goto st8
3503 }
3504 default:
3505 goto st8
3506 }
3507 goto st0
3508 st88:
3509 if p++; p == pe {
3510 goto _test_eof88
3511 }
3512 st_case_88:
3513 switch data[p] {
3514 case 35:
3515 goto tr64
3516 case 47:
3517 goto tr66
3518 case 63:
3519 goto tr67
3520 case 92:
3521 goto tr66
3522 }
3523 switch {
3524 case data[p] < 71:
3525 switch {
3526 case data[p] > 57:
3527 if 65 <= data[p] && data[p] <= 70 {
3528 goto tr131
3529 }
3530 case data[p] >= 48:
3531 goto st34
3532 }
3533 case data[p] > 90:
3534 switch {
3535 case data[p] > 102:
3536 if 103 <= data[p] && data[p] <= 122 {
3537 goto tr81
3538 }
3539 case data[p] >= 97:
3540 goto tr131
3541 }
3542 default:
3543 goto tr81
3544 }
3545 goto st0
3546 st34:
3547 if p++; p == pe {
3548 goto _test_eof34
3549 }
3550 st_case_34:
3551 switch {
3552 case data[p] < 65:
3553 if 48 <= data[p] && data[p] <= 57 {
3554 goto st84
3555 }
3556 case data[p] > 70:
3557 if 97 <= data[p] && data[p] <= 102 {
3558 goto st84
3559 }
3560 default:
3561 goto st84
3562 }
3563 goto st0
3564 tr131:
3565 //line parser.rl:13
3566
3567 if port_mark > host_mark {
3568 u.Port = data[port_mark:p]
3569 }
3570
3571 //line parser.rl:10
3572 mark = p
3573 goto st35
3574 st35:
3575 if p++; p == pe {
3576 goto _test_eof35
3577 }
3578 st_case_35:
3579 //line parser.go:3585
3580 if data[p] == 58 {
3581 goto st5
3582 }
3583 switch {
3584 case data[p] < 65:
3585 if 48 <= data[p] && data[p] <= 57 {
3586 goto st84
3587 }
3588 case data[p] > 70:
3589 if 97 <= data[p] && data[p] <= 102 {
3590 goto st84
3591 }
3592 default:
3593 goto st84
3594 }
3595 goto st0
3596 st89:
3597 if p++; p == pe {
3598 goto _test_eof89
3599 }
3600 st_case_89:
3601 switch data[p] {
3602 case 33:
3603 goto tr14
3604 case 35:
3605 goto tr64
3606 case 37:
3607 goto tr15
3608 case 47:
3609 goto tr66
3610 case 58:
3611 goto st8
3612 case 61:
3613 goto tr14
3614 case 63:
3615 goto tr67
3616 case 64:
3617 goto st11
3618 case 91:
3619 goto tr16
3620 case 92:
3621 goto tr66
3622 case 95:
3623 goto tr14
3624 case 126:
3625 goto tr14
3626 }
3627 switch {
3628 case data[p] < 65:
3629 if 36 <= data[p] && data[p] <= 59 {
3630 goto tr14
3631 }
3632 case data[p] > 90:
3633 if 97 <= data[p] && data[p] <= 122 {
3634 goto tr132
3635 }
3636 default:
3637 goto tr132
3638 }
3639 goto st0
3640 tr53:
3641 //line parser.rl:27
3642
3643 u.Host = data[host_mark:p]
3644
3645 //line parser.rl:10
3646 mark = p
3647 goto st90
3648 tr132:
3649 //line parser.rl:23
3650
3651 host_mark = p
3652
3653 //line parser.rl:13
3654
3655 if port_mark > host_mark {
3656 u.Port = data[port_mark:p]
3657 }
3658
3659 //line parser.rl:10
3660 mark = p
3661 goto st90
3662 tr157:
3663 //line parser.rl:27
3664
3665 u.Host = data[host_mark:p]
3666
3667 //line parser.rl:13
3668
3669 if port_mark > host_mark {
3670 u.Port = data[port_mark:p]
3671 }
3672
3673 //line parser.rl:10
3674 mark = p
3675 goto st90
3676 tr223:
3677 //line parser.rl:23
3678
3679 host_mark = p
3680
3681 //line parser.rl:10
3682 mark = p
3683 goto st90
3684 st90:
3685 if p++; p == pe {
3686 goto _test_eof90
3687 }
3688 st_case_90:
3689 //line parser.go:3695
3690 switch data[p] {
3691 case 33:
3692 goto st46
3693 case 35:
3694 goto tr48
3695 case 37:
3696 goto st1
3697 case 47:
3698 goto tr50
3699 case 58:
3700 goto tr133
3701 case 61:
3702 goto st46
3703 case 63:
3704 goto tr52
3705 case 64:
3706 goto st11
3707 case 92:
3708 goto tr50
3709 case 95:
3710 goto st46
3711 case 126:
3712 goto st46
3713 }
3714 switch {
3715 case data[p] < 65:
3716 if 36 <= data[p] && data[p] <= 59 {
3717 goto st46
3718 }
3719 case data[p] > 90:
3720 if 97 <= data[p] && data[p] <= 122 {
3721 goto tr53
3722 }
3723 default:
3724 goto tr53
3725 }
3726 goto st0
3727 tr133:
3728 //line parser.rl:27
3729
3730 u.Host = data[host_mark:p]
3731
3732 goto st36
3733 st36:
3734 if p++; p == pe {
3735 goto _test_eof36
3736 }
3737 st_case_36:
3738 //line parser.go:3744
3739 switch data[p] {
3740 case 33:
3741 goto tr4
3742 case 37:
3743 goto tr5
3744 case 47:
3745 goto st49
3746 case 60:
3747 goto tr3
3748 case 62:
3749 goto tr3
3750 case 64:
3751 goto tr6
3752 case 92:
3753 goto tr39
3754 case 95:
3755 goto tr4
3756 case 126:
3757 goto tr4
3758 }
3759 switch {
3760 case data[p] < 65:
3761 switch {
3762 case data[p] > 34:
3763 if 36 <= data[p] && data[p] <= 61 {
3764 goto tr4
3765 }
3766 case data[p] >= 32:
3767 goto tr3
3768 }
3769 case data[p] > 90:
3770 switch {
3771 case data[p] < 97:
3772 if 91 <= data[p] && data[p] <= 96 {
3773 goto tr3
3774 }
3775 case data[p] > 122:
3776 if 123 <= data[p] && data[p] <= 125 {
3777 goto tr3
3778 }
3779 default:
3780 goto tr4
3781 }
3782 default:
3783 goto tr4
3784 }
3785 goto st0
3786 tr5:
3787 //line parser.rl:11
3788 port_mark = p
3789 goto st91
3790 st91:
3791 if p++; p == pe {
3792 goto _test_eof91
3793 }
3794 st_case_91:
3795 //line parser.go:3801
3796 switch data[p] {
3797 case 35:
3798 goto tr64
3799 case 37:
3800 goto st74
3801 case 47:
3802 goto tr66
3803 case 63:
3804 goto tr67
3805 case 92:
3806 goto tr69
3807 }
3808 switch {
3809 case data[p] < 71:
3810 switch {
3811 case data[p] < 48:
3812 if 32 <= data[p] && data[p] <= 46 {
3813 goto st54
3814 }
3815 case data[p] > 57:
3816 switch {
3817 case data[p] > 64:
3818 if 65 <= data[p] && data[p] <= 70 {
3819 goto tr135
3820 }
3821 case data[p] >= 58:
3822 goto st54
3823 }
3824 default:
3825 goto st92
3826 }
3827 case data[p] > 90:
3828 switch {
3829 case data[p] < 97:
3830 if 91 <= data[p] && data[p] <= 96 {
3831 goto st54
3832 }
3833 case data[p] > 102:
3834 switch {
3835 case data[p] > 122:
3836 if 123 <= data[p] && data[p] <= 126 {
3837 goto st54
3838 }
3839 case data[p] >= 103:
3840 goto tr68
3841 }
3842 default:
3843 goto tr135
3844 }
3845 default:
3846 goto tr68
3847 }
3848 goto st0
3849 tr135:
3850 //line parser.rl:13
3851
3852 if port_mark > host_mark {
3853 u.Port = data[port_mark:p]
3854 }
3855
3856 //line parser.rl:10
3857 mark = p
3858 goto st92
3859 st92:
3860 if p++; p == pe {
3861 goto _test_eof92
3862 }
3863 st_case_92:
3864 //line parser.go:3870
3865 switch data[p] {
3866 case 35:
3867 goto tr64
3868 case 37:
3869 goto st68
3870 case 47:
3871 goto tr66
3872 case 63:
3873 goto tr67
3874 case 92:
3875 goto tr73
3876 }
3877 switch {
3878 case data[p] < 71:
3879 switch {
3880 case data[p] < 48:
3881 if 32 <= data[p] && data[p] <= 46 {
3882 goto st55
3883 }
3884 case data[p] > 57:
3885 switch {
3886 case data[p] > 64:
3887 if 65 <= data[p] && data[p] <= 70 {
3888 goto tr137
3889 }
3890 case data[p] >= 58:
3891 goto st55
3892 }
3893 default:
3894 goto st80
3895 }
3896 case data[p] > 90:
3897 switch {
3898 case data[p] < 97:
3899 if 91 <= data[p] && data[p] <= 96 {
3900 goto st55
3901 }
3902 case data[p] > 102:
3903 switch {
3904 case data[p] > 122:
3905 if 123 <= data[p] && data[p] <= 126 {
3906 goto st55
3907 }
3908 case data[p] >= 103:
3909 goto tr72
3910 }
3911 default:
3912 goto tr137
3913 }
3914 default:
3915 goto tr72
3916 }
3917 goto st0
3918 tr6:
3919 //line parser.rl:11
3920 port_mark = p
3921 goto st93
3922 tr233:
3923 //line parser.rl:19
3924
3925 u.Protocol = data[0 : p-1]
3926
3927 //line parser.rl:11
3928 port_mark = p
3929 goto st93
3930 st93:
3931 if p++; p == pe {
3932 goto _test_eof93
3933 }
3934 st_case_93:
3935 //line parser.go:3941
3936 switch data[p] {
3937 case 33:
3938 goto tr138
3939 case 35:
3940 goto tr64
3941 case 37:
3942 goto tr139
3943 case 47:
3944 goto tr66
3945 case 58:
3946 goto st81
3947 case 60:
3948 goto st54
3949 case 62:
3950 goto st54
3951 case 63:
3952 goto tr67
3953 case 64:
3954 goto st119
3955 case 91:
3956 goto tr141
3957 case 92:
3958 goto tr69
3959 case 95:
3960 goto tr138
3961 case 126:
3962 goto tr138
3963 }
3964 switch {
3965 case data[p] < 65:
3966 switch {
3967 case data[p] > 34:
3968 if 36 <= data[p] && data[p] <= 61 {
3969 goto tr138
3970 }
3971 case data[p] >= 32:
3972 goto st54
3973 }
3974 case data[p] > 90:
3975 switch {
3976 case data[p] < 97:
3977 if 93 <= data[p] && data[p] <= 96 {
3978 goto st54
3979 }
3980 case data[p] > 122:
3981 if 123 <= data[p] && data[p] <= 125 {
3982 goto st54
3983 }
3984 default:
3985 goto tr140
3986 }
3987 default:
3988 goto tr140
3989 }
3990 goto st0
3991 tr138:
3992 //line parser.rl:23
3993
3994 host_mark = p
3995
3996 goto st94
3997 tr190:
3998 //line parser.rl:13
3999
4000 if port_mark > host_mark {
4001 u.Port = data[port_mark:p]
4002 }
4003
4004 //line parser.rl:10
4005 mark = p
4006 goto st94
4007 tr140:
4008 //line parser.rl:23
4009
4010 host_mark = p
4011
4012 //line parser.rl:13
4013
4014 if port_mark > host_mark {
4015 u.Port = data[port_mark:p]
4016 }
4017
4018 //line parser.rl:10
4019 mark = p
4020 goto st94
4021 tr238:
4022 //line parser.rl:27
4023
4024 u.Host = data[host_mark:p]
4025
4026 //line parser.rl:13
4027
4028 if port_mark > host_mark {
4029 u.Port = data[port_mark:p]
4030 }
4031
4032 //line parser.rl:10
4033 mark = p
4034 goto st94
4035 st94:
4036 if p++; p == pe {
4037 goto _test_eof94
4038 }
4039 st_case_94:
4040 //line parser.go:4046
4041 switch data[p] {
4042 case 33:
4043 goto st95
4044 case 35:
4045 goto tr143
4046 case 37:
4047 goto st110
4048 case 47:
4049 goto tr145
4050 case 58:
4051 goto tr146
4052 case 60:
4053 goto st55
4054 case 62:
4055 goto st55
4056 case 63:
4057 goto tr147
4058 case 64:
4059 goto st112
4060 case 92:
4061 goto tr149
4062 case 95:
4063 goto st95
4064 case 126:
4065 goto st95
4066 }
4067 switch {
4068 case data[p] < 65:
4069 switch {
4070 case data[p] > 34:
4071 if 36 <= data[p] && data[p] <= 61 {
4072 goto st95
4073 }
4074 case data[p] >= 32:
4075 goto st55
4076 }
4077 case data[p] > 90:
4078 switch {
4079 case data[p] < 97:
4080 if 91 <= data[p] && data[p] <= 96 {
4081 goto st55
4082 }
4083 case data[p] > 122:
4084 if 123 <= data[p] && data[p] <= 125 {
4085 goto st55
4086 }
4087 default:
4088 goto tr148
4089 }
4090 default:
4091 goto tr148
4092 }
4093 goto st0
4094 tr191:
4095 //line parser.rl:23
4096
4097 host_mark = p
4098
4099 goto st95
4100 tr178:
4101 //line parser.rl:13
4102
4103 if port_mark > host_mark {
4104 u.Port = data[port_mark:p]
4105 }
4106
4107 //line parser.rl:10
4108 mark = p
4109 goto st95
4110 tr193:
4111 //line parser.rl:23
4112
4113 host_mark = p
4114
4115 //line parser.rl:13
4116
4117 if port_mark > host_mark {
4118 u.Port = data[port_mark:p]
4119 }
4120
4121 //line parser.rl:10
4122 mark = p
4123 goto st95
4124 tr148:
4125 //line parser.rl:27
4126
4127 u.Host = data[host_mark:p]
4128
4129 //line parser.rl:13
4130
4131 if port_mark > host_mark {
4132 u.Port = data[port_mark:p]
4133 }
4134
4135 //line parser.rl:10
4136 mark = p
4137 goto st95
4138 st95:
4139 if p++; p == pe {
4140 goto _test_eof95
4141 }
4142 st_case_95:
4143 //line parser.go:4149
4144 switch data[p] {
4145 case 33:
4146 goto st96
4147 case 35:
4148 goto tr143
4149 case 37:
4150 goto st105
4151 case 47:
4152 goto tr145
4153 case 58:
4154 goto tr146
4155 case 60:
4156 goto st56
4157 case 62:
4158 goto st56
4159 case 63:
4160 goto tr147
4161 case 64:
4162 goto st108
4163 case 92:
4164 goto tr153
4165 case 95:
4166 goto st96
4167 case 126:
4168 goto st96
4169 }
4170 switch {
4171 case data[p] < 65:
4172 switch {
4173 case data[p] > 34:
4174 if 36 <= data[p] && data[p] <= 61 {
4175 goto st96
4176 }
4177 case data[p] >= 32:
4178 goto st56
4179 }
4180 case data[p] > 90:
4181 switch {
4182 case data[p] < 97:
4183 if 91 <= data[p] && data[p] <= 96 {
4184 goto st56
4185 }
4186 case data[p] > 122:
4187 if 123 <= data[p] && data[p] <= 125 {
4188 goto st56
4189 }
4190 default:
4191 goto tr152
4192 }
4193 default:
4194 goto tr152
4195 }
4196 goto st0
4197 tr179:
4198 //line parser.rl:23
4199
4200 host_mark = p
4201
4202 goto st96
4203 tr169:
4204 //line parser.rl:13
4205
4206 if port_mark > host_mark {
4207 u.Port = data[port_mark:p]
4208 }
4209
4210 //line parser.rl:10
4211 mark = p
4212 goto st96
4213 tr181:
4214 //line parser.rl:23
4215
4216 host_mark = p
4217
4218 //line parser.rl:13
4219
4220 if port_mark > host_mark {
4221 u.Port = data[port_mark:p]
4222 }
4223
4224 //line parser.rl:10
4225 mark = p
4226 goto st96
4227 tr152:
4228 //line parser.rl:27
4229
4230 u.Host = data[host_mark:p]
4231
4232 //line parser.rl:13
4233
4234 if port_mark > host_mark {
4235 u.Port = data[port_mark:p]
4236 }
4237
4238 //line parser.rl:10
4239 mark = p
4240 goto st96
4241 st96:
4242 if p++; p == pe {
4243 goto _test_eof96
4244 }
4245 st_case_96:
4246 //line parser.go:4252
4247 switch data[p] {
4248 case 33:
4249 goto st97
4250 case 35:
4251 goto tr143
4252 case 37:
4253 goto st98
4254 case 47:
4255 goto tr145
4256 case 58:
4257 goto tr146
4258 case 60:
4259 goto st57
4260 case 62:
4261 goto st57
4262 case 63:
4263 goto tr147
4264 case 64:
4265 goto st89
4266 case 92:
4267 goto tr156
4268 case 95:
4269 goto st97
4270 case 126:
4271 goto st97
4272 }
4273 switch {
4274 case data[p] < 65:
4275 switch {
4276 case data[p] > 34:
4277 if 36 <= data[p] && data[p] <= 61 {
4278 goto st97
4279 }
4280 case data[p] >= 32:
4281 goto st57
4282 }
4283 case data[p] > 90:
4284 switch {
4285 case data[p] < 97:
4286 if 91 <= data[p] && data[p] <= 96 {
4287 goto st57
4288 }
4289 case data[p] > 122:
4290 if 123 <= data[p] && data[p] <= 125 {
4291 goto st57
4292 }
4293 default:
4294 goto tr155
4295 }
4296 default:
4297 goto tr155
4298 }
4299 goto st0
4300 tr170:
4301 //line parser.rl:23
4302
4303 host_mark = p
4304
4305 goto st97
4306 st97:
4307 if p++; p == pe {
4308 goto _test_eof97
4309 }
4310 st_case_97:
4311 //line parser.go:4317
4312 switch data[p] {
4313 case 33:
4314 goto st46
4315 case 35:
4316 goto tr143
4317 case 37:
4318 goto st1
4319 case 47:
4320 goto tr145
4321 case 58:
4322 goto tr51
4323 case 61:
4324 goto st46
4325 case 63:
4326 goto tr147
4327 case 64:
4328 goto st11
4329 case 92:
4330 goto tr145
4331 case 95:
4332 goto st46
4333 case 126:
4334 goto st46
4335 }
4336 switch {
4337 case data[p] < 65:
4338 if 36 <= data[p] && data[p] <= 59 {
4339 goto st46
4340 }
4341 case data[p] > 90:
4342 if 97 <= data[p] && data[p] <= 122 {
4343 goto tr157
4344 }
4345 default:
4346 goto tr157
4347 }
4348 goto st0
4349 tr171:
4350 //line parser.rl:23
4351
4352 host_mark = p
4353
4354 goto st98
4355 st98:
4356 if p++; p == pe {
4357 goto _test_eof98
4358 }
4359 st_case_98:
4360 //line parser.go:4366
4361 switch data[p] {
4362 case 35:
4363 goto tr64
4364 case 47:
4365 goto tr66
4366 case 63:
4367 goto tr67
4368 case 92:
4369 goto tr66
4370 }
4371 switch {
4372 case data[p] < 71:
4373 switch {
4374 case data[p] > 57:
4375 if 65 <= data[p] && data[p] <= 70 {
4376 goto tr159
4377 }
4378 case data[p] >= 48:
4379 goto st37
4380 }
4381 case data[p] > 90:
4382 switch {
4383 case data[p] > 102:
4384 if 103 <= data[p] && data[p] <= 122 {
4385 goto tr81
4386 }
4387 case data[p] >= 97:
4388 goto tr159
4389 }
4390 default:
4391 goto tr81
4392 }
4393 goto st0
4394 st37:
4395 if p++; p == pe {
4396 goto _test_eof37
4397 }
4398 st_case_37:
4399 switch {
4400 case data[p] < 65:
4401 if 48 <= data[p] && data[p] <= 57 {
4402 goto st97
4403 }
4404 case data[p] > 70:
4405 if 97 <= data[p] && data[p] <= 102 {
4406 goto st97
4407 }
4408 default:
4409 goto st97
4410 }
4411 goto st0
4412 tr159:
4413 //line parser.rl:13
4414
4415 if port_mark > host_mark {
4416 u.Port = data[port_mark:p]
4417 }
4418
4419 //line parser.rl:10
4420 mark = p
4421 goto st38
4422 st38:
4423 if p++; p == pe {
4424 goto _test_eof38
4425 }
4426 st_case_38:
4427 //line parser.go:4433
4428 if data[p] == 58 {
4429 goto st5
4430 }
4431 switch {
4432 case data[p] < 65:
4433 if 48 <= data[p] && data[p] <= 57 {
4434 goto st97
4435 }
4436 case data[p] > 70:
4437 if 97 <= data[p] && data[p] <= 102 {
4438 goto st97
4439 }
4440 default:
4441 goto st97
4442 }
4443 goto st0
4444 tr146:
4445 //line parser.rl:27
4446
4447 u.Host = data[host_mark:p]
4448
4449 goto st99
4450 st99:
4451 if p++; p == pe {
4452 goto _test_eof99
4453 }
4454 st_case_99:
4455 //line parser.go:4461
4456 switch data[p] {
4457 case 33:
4458 goto tr4
4459 case 35:
4460 goto tr64
4461 case 37:
4462 goto tr5
4463 case 47:
4464 goto tr66
4465 case 60:
4466 goto tr3
4467 case 62:
4468 goto tr3
4469 case 63:
4470 goto tr67
4471 case 64:
4472 goto tr6
4473 case 92:
4474 goto tr161
4475 case 95:
4476 goto tr4
4477 case 126:
4478 goto tr4
4479 }
4480 switch {
4481 case data[p] < 65:
4482 switch {
4483 case data[p] > 34:
4484 if 36 <= data[p] && data[p] <= 61 {
4485 goto tr4
4486 }
4487 case data[p] >= 32:
4488 goto tr3
4489 }
4490 case data[p] > 90:
4491 switch {
4492 case data[p] < 97:
4493 if 91 <= data[p] && data[p] <= 96 {
4494 goto tr3
4495 }
4496 case data[p] > 122:
4497 if 123 <= data[p] && data[p] <= 125 {
4498 goto tr3
4499 }
4500 default:
4501 goto tr160
4502 }
4503 default:
4504 goto tr160
4505 }
4506 goto st0
4507 tr39:
4508 //line parser.rl:11
4509 port_mark = p
4510 goto st100
4511 tr161:
4512 //line parser.rl:11
4513 port_mark = p
4514 //line parser.rl:13
4515
4516 if port_mark > host_mark {
4517 u.Port = data[port_mark:p]
4518 }
4519
4520 //line parser.rl:10
4521 mark = p
4522 goto st100
4523 tr236:
4524 //line parser.rl:19
4525
4526 u.Protocol = data[0 : p-1]
4527
4528 //line parser.rl:11
4529 port_mark = p
4530 //line parser.rl:10
4531 mark = p
4532 goto st100
4533 st100:
4534 if p++; p == pe {
4535 goto _test_eof100
4536 }
4537 st_case_100:
4538 //line parser.go:4544
4539 switch data[p] {
4540 case 35:
4541 goto tr84
4542 case 37:
4543 goto st102
4544 case 47:
4545 goto tr66
4546 case 63:
4547 goto tr85
4548 case 91:
4549 goto st101
4550 }
4551 switch {
4552 case data[p] < 93:
4553 switch {
4554 case data[p] > 64:
4555 if 65 <= data[p] && data[p] <= 92 {
4556 goto tr164
4557 }
4558 case data[p] >= 32:
4559 goto st101
4560 }
4561 case data[p] > 96:
4562 switch {
4563 case data[p] > 122:
4564 if 123 <= data[p] && data[p] <= 126 {
4565 goto st101
4566 }
4567 case data[p] >= 97:
4568 goto tr164
4569 }
4570 default:
4571 goto st101
4572 }
4573 goto st0
4574 tr164:
4575 //line parser.rl:13
4576
4577 if port_mark > host_mark {
4578 u.Port = data[port_mark:p]
4579 }
4580
4581 //line parser.rl:10
4582 mark = p
4583 goto st101
4584 st101:
4585 if p++; p == pe {
4586 goto _test_eof101
4587 }
4588 st_case_101:
4589 //line parser.go:4595
4590 switch data[p] {
4591 case 35:
4592 goto tr84
4593 case 37:
4594 goto st78
4595 case 47:
4596 goto tr86
4597 case 63:
4598 goto tr85
4599 case 91:
4600 goto st77
4601 }
4602 switch {
4603 case data[p] < 93:
4604 switch {
4605 case data[p] > 64:
4606 if 65 <= data[p] && data[p] <= 92 {
4607 goto tr105
4608 }
4609 case data[p] >= 32:
4610 goto st77
4611 }
4612 case data[p] > 96:
4613 switch {
4614 case data[p] > 122:
4615 if 123 <= data[p] && data[p] <= 126 {
4616 goto st77
4617 }
4618 case data[p] >= 97:
4619 goto tr105
4620 }
4621 default:
4622 goto st77
4623 }
4624 goto st0
4625 st102:
4626 if p++; p == pe {
4627 goto _test_eof102
4628 }
4629 st_case_102:
4630 switch data[p] {
4631 case 35:
4632 goto tr84
4633 case 37:
4634 goto st78
4635 case 47:
4636 goto tr86
4637 case 63:
4638 goto tr85
4639 case 91:
4640 goto st77
4641 }
4642 switch {
4643 case data[p] < 71:
4644 switch {
4645 case data[p] < 48:
4646 if 32 <= data[p] && data[p] <= 46 {
4647 goto st77
4648 }
4649 case data[p] > 57:
4650 switch {
4651 case data[p] > 64:
4652 if 65 <= data[p] && data[p] <= 70 {
4653 goto tr166
4654 }
4655 case data[p] >= 58:
4656 goto st77
4657 }
4658 default:
4659 goto st103
4660 }
4661 case data[p] > 92:
4662 switch {
4663 case data[p] < 97:
4664 if 93 <= data[p] && data[p] <= 96 {
4665 goto st77
4666 }
4667 case data[p] > 102:
4668 switch {
4669 case data[p] > 122:
4670 if 123 <= data[p] && data[p] <= 126 {
4671 goto st77
4672 }
4673 case data[p] >= 103:
4674 goto tr105
4675 }
4676 default:
4677 goto tr166
4678 }
4679 default:
4680 goto tr105
4681 }
4682 goto st0
4683 tr166:
4684 //line parser.rl:13
4685
4686 if port_mark > host_mark {
4687 u.Port = data[port_mark:p]
4688 }
4689
4690 //line parser.rl:10
4691 mark = p
4692 goto st103
4693 st103:
4694 if p++; p == pe {
4695 goto _test_eof103
4696 }
4697 st_case_103:
4698 //line parser.go:4704
4699 switch data[p] {
4700 case 35:
4701 goto tr84
4702 case 37:
4703 goto st72
4704 case 47:
4705 goto tr86
4706 case 63:
4707 goto tr85
4708 case 91:
4709 goto st71
4710 }
4711 switch {
4712 case data[p] < 71:
4713 switch {
4714 case data[p] < 48:
4715 if 32 <= data[p] && data[p] <= 46 {
4716 goto st71
4717 }
4718 case data[p] > 57:
4719 switch {
4720 case data[p] > 64:
4721 if 65 <= data[p] && data[p] <= 70 {
4722 goto tr164
4723 }
4724 case data[p] >= 58:
4725 goto st71
4726 }
4727 default:
4728 goto st101
4729 }
4730 case data[p] > 92:
4731 switch {
4732 case data[p] < 97:
4733 if 93 <= data[p] && data[p] <= 96 {
4734 goto st71
4735 }
4736 case data[p] > 102:
4737 switch {
4738 case data[p] > 122:
4739 if 123 <= data[p] && data[p] <= 126 {
4740 goto st71
4741 }
4742 case data[p] >= 103:
4743 goto tr98
4744 }
4745 default:
4746 goto tr164
4747 }
4748 default:
4749 goto tr98
4750 }
4751 goto st0
4752 tr172:
4753 //line parser.rl:23
4754
4755 host_mark = p
4756
4757 //line parser.rl:13
4758
4759 if port_mark > host_mark {
4760 u.Port = data[port_mark:p]
4761 }
4762
4763 //line parser.rl:10
4764 mark = p
4765 goto st104
4766 tr155:
4767 //line parser.rl:27
4768
4769 u.Host = data[host_mark:p]
4770
4771 //line parser.rl:13
4772
4773 if port_mark > host_mark {
4774 u.Port = data[port_mark:p]
4775 }
4776
4777 //line parser.rl:10
4778 mark = p
4779 goto st104
4780 st104:
4781 if p++; p == pe {
4782 goto _test_eof104
4783 }
4784 st_case_104:
4785 //line parser.go:4791
4786 switch data[p] {
4787 case 33:
4788 goto st46
4789 case 35:
4790 goto tr143
4791 case 37:
4792 goto st1
4793 case 47:
4794 goto tr145
4795 case 58:
4796 goto tr133
4797 case 61:
4798 goto st46
4799 case 63:
4800 goto tr147
4801 case 64:
4802 goto st11
4803 case 92:
4804 goto tr145
4805 case 95:
4806 goto st46
4807 case 126:
4808 goto st46
4809 }
4810 switch {
4811 case data[p] < 65:
4812 if 36 <= data[p] && data[p] <= 59 {
4813 goto st46
4814 }
4815 case data[p] > 90:
4816 if 97 <= data[p] && data[p] <= 122 {
4817 goto tr157
4818 }
4819 default:
4820 goto tr157
4821 }
4822 goto st0
4823 tr180:
4824 //line parser.rl:23
4825
4826 host_mark = p
4827
4828 goto st105
4829 st105:
4830 if p++; p == pe {
4831 goto _test_eof105
4832 }
4833 st_case_105:
4834 //line parser.go:4840
4835 switch data[p] {
4836 case 35:
4837 goto tr64
4838 case 37:
4839 goto st58
4840 case 47:
4841 goto tr66
4842 case 63:
4843 goto tr67
4844 case 92:
4845 goto tr80
4846 }
4847 switch {
4848 case data[p] < 71:
4849 switch {
4850 case data[p] < 48:
4851 if 32 <= data[p] && data[p] <= 46 {
4852 goto st57
4853 }
4854 case data[p] > 57:
4855 switch {
4856 case data[p] > 64:
4857 if 65 <= data[p] && data[p] <= 70 {
4858 goto tr168
4859 }
4860 case data[p] >= 58:
4861 goto st57
4862 }
4863 default:
4864 goto st106
4865 }
4866 case data[p] > 90:
4867 switch {
4868 case data[p] < 97:
4869 if 91 <= data[p] && data[p] <= 96 {
4870 goto st57
4871 }
4872 case data[p] > 102:
4873 switch {
4874 case data[p] > 122:
4875 if 123 <= data[p] && data[p] <= 126 {
4876 goto st57
4877 }
4878 case data[p] >= 103:
4879 goto tr79
4880 }
4881 default:
4882 goto tr168
4883 }
4884 default:
4885 goto tr79
4886 }
4887 goto st0
4888 st106:
4889 if p++; p == pe {
4890 goto _test_eof106
4891 }
4892 st_case_106:
4893 switch data[p] {
4894 case 35:
4895 goto tr64
4896 case 47:
4897 goto tr66
4898 case 63:
4899 goto tr67
4900 case 92:
4901 goto tr66
4902 }
4903 switch {
4904 case data[p] < 71:
4905 switch {
4906 case data[p] > 57:
4907 if 65 <= data[p] && data[p] <= 70 {
4908 goto tr169
4909 }
4910 case data[p] >= 48:
4911 goto st96
4912 }
4913 case data[p] > 90:
4914 switch {
4915 case data[p] > 102:
4916 if 103 <= data[p] && data[p] <= 122 {
4917 goto tr81
4918 }
4919 case data[p] >= 97:
4920 goto tr169
4921 }
4922 default:
4923 goto tr81
4924 }
4925 goto st0
4926 tr168:
4927 //line parser.rl:13
4928
4929 if port_mark > host_mark {
4930 u.Port = data[port_mark:p]
4931 }
4932
4933 //line parser.rl:10
4934 mark = p
4935 goto st107
4936 st107:
4937 if p++; p == pe {
4938 goto _test_eof107
4939 }
4940 st_case_107:
4941 //line parser.go:4947
4942 switch data[p] {
4943 case 35:
4944 goto tr64
4945 case 47:
4946 goto tr66
4947 case 58:
4948 goto st5
4949 case 63:
4950 goto tr67
4951 case 92:
4952 goto tr66
4953 }
4954 switch {
4955 case data[p] < 71:
4956 switch {
4957 case data[p] > 57:
4958 if 65 <= data[p] && data[p] <= 70 {
4959 goto tr169
4960 }
4961 case data[p] >= 48:
4962 goto st96
4963 }
4964 case data[p] > 90:
4965 switch {
4966 case data[p] > 102:
4967 if 103 <= data[p] && data[p] <= 122 {
4968 goto tr81
4969 }
4970 case data[p] >= 97:
4971 goto tr169
4972 }
4973 default:
4974 goto tr81
4975 }
4976 goto st0
4977 st108:
4978 if p++; p == pe {
4979 goto _test_eof108
4980 }
4981 st_case_108:
4982 switch data[p] {
4983 case 33:
4984 goto tr170
4985 case 35:
4986 goto tr64
4987 case 37:
4988 goto tr171
4989 case 47:
4990 goto tr66
4991 case 58:
4992 goto st84
4993 case 60:
4994 goto st57
4995 case 62:
4996 goto st57
4997 case 63:
4998 goto tr67
4999 case 64:
5000 goto st89
5001 case 91:
5002 goto tr173
5003 case 92:
5004 goto tr80
5005 case 95:
5006 goto tr170
5007 case 126:
5008 goto tr170
5009 }
5010 switch {
5011 case data[p] < 65:
5012 switch {
5013 case data[p] > 34:
5014 if 36 <= data[p] && data[p] <= 61 {
5015 goto tr170
5016 }
5017 case data[p] >= 32:
5018 goto st57
5019 }
5020 case data[p] > 90:
5021 switch {
5022 case data[p] < 97:
5023 if 93 <= data[p] && data[p] <= 96 {
5024 goto st57
5025 }
5026 case data[p] > 122:
5027 if 123 <= data[p] && data[p] <= 125 {
5028 goto st57
5029 }
5030 default:
5031 goto tr172
5032 }
5033 default:
5034 goto tr172
5035 }
5036 goto st0
5037 tr173:
5038 //line parser.rl:23
5039
5040 host_mark = p
5041
5042 goto st109
5043 st109:
5044 if p++; p == pe {
5045 goto _test_eof109
5046 }
5047 st_case_109:
5048 //line parser.go:5054
5049 switch data[p] {
5050 case 35:
5051 goto tr64
5052 case 47:
5053 goto tr66
5054 case 63:
5055 goto tr67
5056 case 92:
5057 goto tr66
5058 case 118:
5059 goto tr175
5060 }
5061 switch {
5062 case data[p] < 71:
5063 switch {
5064 case data[p] > 58:
5065 if 65 <= data[p] && data[p] <= 70 {
5066 goto tr174
5067 }
5068 case data[p] >= 48:
5069 goto st13
5070 }
5071 case data[p] > 90:
5072 switch {
5073 case data[p] > 102:
5074 if 103 <= data[p] && data[p] <= 122 {
5075 goto tr81
5076 }
5077 case data[p] >= 97:
5078 goto tr174
5079 }
5080 default:
5081 goto tr81
5082 }
5083 goto st0
5084 tr174:
5085 //line parser.rl:13
5086
5087 if port_mark > host_mark {
5088 u.Port = data[port_mark:p]
5089 }
5090
5091 //line parser.rl:10
5092 mark = p
5093 goto st39
5094 st39:
5095 if p++; p == pe {
5096 goto _test_eof39
5097 }
5098 st_case_39:
5099 //line parser.go:5105
5100 switch data[p] {
5101 case 58:
5102 goto st40
5103 case 93:
5104 goto st85
5105 }
5106 switch {
5107 case data[p] < 65:
5108 if 48 <= data[p] && data[p] <= 57 {
5109 goto st14
5110 }
5111 case data[p] > 70:
5112 if 97 <= data[p] && data[p] <= 102 {
5113 goto st13
5114 }
5115 default:
5116 goto st13
5117 }
5118 goto st0
5119 st40:
5120 if p++; p == pe {
5121 goto _test_eof40
5122 }
5123 st_case_40:
5124 switch data[p] {
5125 case 47:
5126 goto st49
5127 case 58:
5128 goto st13
5129 case 92:
5130 goto st49
5131 case 93:
5132 goto st85
5133 }
5134 switch {
5135 case data[p] < 65:
5136 if 48 <= data[p] && data[p] <= 57 {
5137 goto st14
5138 }
5139 case data[p] > 70:
5140 if 97 <= data[p] && data[p] <= 102 {
5141 goto st13
5142 }
5143 default:
5144 goto st13
5145 }
5146 goto st0
5147 tr175:
5148 //line parser.rl:13
5149
5150 if port_mark > host_mark {
5151 u.Port = data[port_mark:p]
5152 }
5153
5154 //line parser.rl:10
5155 mark = p
5156 goto st41
5157 st41:
5158 if p++; p == pe {
5159 goto _test_eof41
5160 }
5161 st_case_41:
5162 //line parser.go:5168
5163 if data[p] == 58 {
5164 goto st5
5165 }
5166 switch {
5167 case data[p] < 65:
5168 if 48 <= data[p] && data[p] <= 57 {
5169 goto st29
5170 }
5171 case data[p] > 70:
5172 if 97 <= data[p] && data[p] <= 102 {
5173 goto st29
5174 }
5175 default:
5176 goto st29
5177 }
5178 goto st0
5179 tr192:
5180 //line parser.rl:23
5181
5182 host_mark = p
5183
5184 goto st110
5185 st110:
5186 if p++; p == pe {
5187 goto _test_eof110
5188 }
5189 st_case_110:
5190 //line parser.go:5196
5191 switch data[p] {
5192 case 35:
5193 goto tr64
5194 case 37:
5195 goto st61
5196 case 47:
5197 goto tr66
5198 case 63:
5199 goto tr67
5200 case 92:
5201 goto tr77
5202 }
5203 switch {
5204 case data[p] < 71:
5205 switch {
5206 case data[p] < 48:
5207 if 32 <= data[p] && data[p] <= 46 {
5208 goto st56
5209 }
5210 case data[p] > 57:
5211 switch {
5212 case data[p] > 64:
5213 if 65 <= data[p] && data[p] <= 70 {
5214 goto tr177
5215 }
5216 case data[p] >= 58:
5217 goto st56
5218 }
5219 default:
5220 goto st111
5221 }
5222 case data[p] > 90:
5223 switch {
5224 case data[p] < 97:
5225 if 91 <= data[p] && data[p] <= 96 {
5226 goto st56
5227 }
5228 case data[p] > 102:
5229 switch {
5230 case data[p] > 122:
5231 if 123 <= data[p] && data[p] <= 126 {
5232 goto st56
5233 }
5234 case data[p] >= 103:
5235 goto tr76
5236 }
5237 default:
5238 goto tr177
5239 }
5240 default:
5241 goto tr76
5242 }
5243 goto st0
5244 tr177:
5245 //line parser.rl:13
5246
5247 if port_mark > host_mark {
5248 u.Port = data[port_mark:p]
5249 }
5250
5251 //line parser.rl:10
5252 mark = p
5253 goto st111
5254 st111:
5255 if p++; p == pe {
5256 goto _test_eof111
5257 }
5258 st_case_111:
5259 //line parser.go:5265
5260 switch data[p] {
5261 case 35:
5262 goto tr64
5263 case 37:
5264 goto st58
5265 case 47:
5266 goto tr66
5267 case 63:
5268 goto tr67
5269 case 92:
5270 goto tr80
5271 }
5272 switch {
5273 case data[p] < 71:
5274 switch {
5275 case data[p] < 48:
5276 if 32 <= data[p] && data[p] <= 46 {
5277 goto st57
5278 }
5279 case data[p] > 57:
5280 switch {
5281 case data[p] > 64:
5282 if 65 <= data[p] && data[p] <= 70 {
5283 goto tr178
5284 }
5285 case data[p] >= 58:
5286 goto st57
5287 }
5288 default:
5289 goto st95
5290 }
5291 case data[p] > 90:
5292 switch {
5293 case data[p] < 97:
5294 if 91 <= data[p] && data[p] <= 96 {
5295 goto st57
5296 }
5297 case data[p] > 102:
5298 switch {
5299 case data[p] > 122:
5300 if 123 <= data[p] && data[p] <= 126 {
5301 goto st57
5302 }
5303 case data[p] >= 103:
5304 goto tr79
5305 }
5306 default:
5307 goto tr178
5308 }
5309 default:
5310 goto tr79
5311 }
5312 goto st0
5313 st112:
5314 if p++; p == pe {
5315 goto _test_eof112
5316 }
5317 st_case_112:
5318 switch data[p] {
5319 case 33:
5320 goto tr179
5321 case 35:
5322 goto tr64
5323 case 37:
5324 goto tr180
5325 case 47:
5326 goto tr66
5327 case 58:
5328 goto st83
5329 case 60:
5330 goto st56
5331 case 62:
5332 goto st56
5333 case 63:
5334 goto tr67
5335 case 64:
5336 goto st108
5337 case 91:
5338 goto tr182
5339 case 92:
5340 goto tr77
5341 case 95:
5342 goto tr179
5343 case 126:
5344 goto tr179
5345 }
5346 switch {
5347 case data[p] < 65:
5348 switch {
5349 case data[p] > 34:
5350 if 36 <= data[p] && data[p] <= 61 {
5351 goto tr179
5352 }
5353 case data[p] >= 32:
5354 goto st56
5355 }
5356 case data[p] > 90:
5357 switch {
5358 case data[p] < 97:
5359 if 93 <= data[p] && data[p] <= 96 {
5360 goto st56
5361 }
5362 case data[p] > 122:
5363 if 123 <= data[p] && data[p] <= 125 {
5364 goto st56
5365 }
5366 default:
5367 goto tr181
5368 }
5369 default:
5370 goto tr181
5371 }
5372 goto st0
5373 tr182:
5374 //line parser.rl:23
5375
5376 host_mark = p
5377
5378 goto st113
5379 st113:
5380 if p++; p == pe {
5381 goto _test_eof113
5382 }
5383 st_case_113:
5384 //line parser.go:5390
5385 switch data[p] {
5386 case 35:
5387 goto tr64
5388 case 37:
5389 goto st58
5390 case 47:
5391 goto tr66
5392 case 63:
5393 goto tr67
5394 case 92:
5395 goto tr80
5396 case 118:
5397 goto tr185
5398 }
5399 switch {
5400 case data[p] < 71:
5401 switch {
5402 case data[p] < 48:
5403 if 32 <= data[p] && data[p] <= 46 {
5404 goto st57
5405 }
5406 case data[p] > 58:
5407 switch {
5408 case data[p] > 64:
5409 if 65 <= data[p] && data[p] <= 70 {
5410 goto tr184
5411 }
5412 case data[p] >= 59:
5413 goto st57
5414 }
5415 default:
5416 goto st114
5417 }
5418 case data[p] > 90:
5419 switch {
5420 case data[p] < 97:
5421 if 91 <= data[p] && data[p] <= 96 {
5422 goto st57
5423 }
5424 case data[p] > 102:
5425 switch {
5426 case data[p] > 122:
5427 if 123 <= data[p] && data[p] <= 126 {
5428 goto st57
5429 }
5430 case data[p] >= 103:
5431 goto tr79
5432 }
5433 default:
5434 goto tr184
5435 }
5436 default:
5437 goto tr79
5438 }
5439 goto st0
5440 st114:
5441 if p++; p == pe {
5442 goto _test_eof114
5443 }
5444 st_case_114:
5445 switch data[p] {
5446 case 35:
5447 goto tr64
5448 case 47:
5449 goto tr66
5450 case 58:
5451 goto st13
5452 case 63:
5453 goto tr67
5454 case 92:
5455 goto tr66
5456 case 93:
5457 goto st85
5458 }
5459 switch {
5460 case data[p] < 71:
5461 switch {
5462 case data[p] > 57:
5463 if 65 <= data[p] && data[p] <= 70 {
5464 goto tr174
5465 }
5466 case data[p] >= 48:
5467 goto st14
5468 }
5469 case data[p] > 90:
5470 switch {
5471 case data[p] > 102:
5472 if 103 <= data[p] && data[p] <= 122 {
5473 goto tr81
5474 }
5475 case data[p] >= 97:
5476 goto tr174
5477 }
5478 default:
5479 goto tr81
5480 }
5481 goto st0
5482 tr184:
5483 //line parser.rl:13
5484
5485 if port_mark > host_mark {
5486 u.Port = data[port_mark:p]
5487 }
5488
5489 //line parser.rl:10
5490 mark = p
5491 goto st115
5492 st115:
5493 if p++; p == pe {
5494 goto _test_eof115
5495 }
5496 st_case_115:
5497 //line parser.go:5503
5498 switch data[p] {
5499 case 35:
5500 goto tr64
5501 case 47:
5502 goto tr66
5503 case 58:
5504 goto st40
5505 case 63:
5506 goto tr67
5507 case 92:
5508 goto tr66
5509 case 93:
5510 goto st85
5511 }
5512 switch {
5513 case data[p] < 71:
5514 switch {
5515 case data[p] > 57:
5516 if 65 <= data[p] && data[p] <= 70 {
5517 goto tr174
5518 }
5519 case data[p] >= 48:
5520 goto st14
5521 }
5522 case data[p] > 90:
5523 switch {
5524 case data[p] > 102:
5525 if 103 <= data[p] && data[p] <= 122 {
5526 goto tr81
5527 }
5528 case data[p] >= 97:
5529 goto tr174
5530 }
5531 default:
5532 goto tr81
5533 }
5534 goto st0
5535 tr185:
5536 //line parser.rl:13
5537
5538 if port_mark > host_mark {
5539 u.Port = data[port_mark:p]
5540 }
5541
5542 //line parser.rl:10
5543 mark = p
5544 goto st116
5545 st116:
5546 if p++; p == pe {
5547 goto _test_eof116
5548 }
5549 st_case_116:
5550 //line parser.go:5556
5551 switch data[p] {
5552 case 35:
5553 goto tr64
5554 case 47:
5555 goto tr66
5556 case 58:
5557 goto st5
5558 case 63:
5559 goto tr67
5560 case 92:
5561 goto tr66
5562 }
5563 switch {
5564 case data[p] < 71:
5565 switch {
5566 case data[p] > 57:
5567 if 65 <= data[p] && data[p] <= 70 {
5568 goto tr186
5569 }
5570 case data[p] >= 48:
5571 goto st29
5572 }
5573 case data[p] > 90:
5574 switch {
5575 case data[p] > 102:
5576 if 103 <= data[p] && data[p] <= 122 {
5577 goto tr81
5578 }
5579 case data[p] >= 97:
5580 goto tr186
5581 }
5582 default:
5583 goto tr81
5584 }
5585 goto st0
5586 tr186:
5587 //line parser.rl:13
5588
5589 if port_mark > host_mark {
5590 u.Port = data[port_mark:p]
5591 }
5592
5593 //line parser.rl:10
5594 mark = p
5595 goto st42
5596 st42:
5597 if p++; p == pe {
5598 goto _test_eof42
5599 }
5600 st_case_42:
5601 //line parser.go:5607
5602 switch data[p] {
5603 case 46:
5604 goto st30
5605 case 58:
5606 goto st5
5607 }
5608 switch {
5609 case data[p] < 65:
5610 if 48 <= data[p] && data[p] <= 57 {
5611 goto st29
5612 }
5613 case data[p] > 70:
5614 if 97 <= data[p] && data[p] <= 102 {
5615 goto st29
5616 }
5617 default:
5618 goto st29
5619 }
5620 goto st0
5621 tr139:
5622 //line parser.rl:23
5623
5624 host_mark = p
5625
5626 goto st117
5627 st117:
5628 if p++; p == pe {
5629 goto _test_eof117
5630 }
5631 st_case_117:
5632 //line parser.go:5638
5633 switch data[p] {
5634 case 35:
5635 goto tr64
5636 case 37:
5637 goto st68
5638 case 47:
5639 goto tr66
5640 case 63:
5641 goto tr67
5642 case 92:
5643 goto tr73
5644 }
5645 switch {
5646 case data[p] < 71:
5647 switch {
5648 case data[p] < 48:
5649 if 32 <= data[p] && data[p] <= 46 {
5650 goto st55
5651 }
5652 case data[p] > 57:
5653 switch {
5654 case data[p] > 64:
5655 if 65 <= data[p] && data[p] <= 70 {
5656 goto tr188
5657 }
5658 case data[p] >= 58:
5659 goto st55
5660 }
5661 default:
5662 goto st118
5663 }
5664 case data[p] > 90:
5665 switch {
5666 case data[p] < 97:
5667 if 91 <= data[p] && data[p] <= 96 {
5668 goto st55
5669 }
5670 case data[p] > 102:
5671 switch {
5672 case data[p] > 122:
5673 if 123 <= data[p] && data[p] <= 126 {
5674 goto st55
5675 }
5676 case data[p] >= 103:
5677 goto tr72
5678 }
5679 default:
5680 goto tr188
5681 }
5682 default:
5683 goto tr72
5684 }
5685 goto st0
5686 tr188:
5687 //line parser.rl:13
5688
5689 if port_mark > host_mark {
5690 u.Port = data[port_mark:p]
5691 }
5692
5693 //line parser.rl:10
5694 mark = p
5695 goto st118
5696 st118:
5697 if p++; p == pe {
5698 goto _test_eof118
5699 }
5700 st_case_118:
5701 //line parser.go:5707
5702 switch data[p] {
5703 case 35:
5704 goto tr64
5705 case 37:
5706 goto st61
5707 case 47:
5708 goto tr66
5709 case 63:
5710 goto tr67
5711 case 92:
5712 goto tr77
5713 }
5714 switch {
5715 case data[p] < 71:
5716 switch {
5717 case data[p] < 48:
5718 if 32 <= data[p] && data[p] <= 46 {
5719 goto st56
5720 }
5721 case data[p] > 57:
5722 switch {
5723 case data[p] > 64:
5724 if 65 <= data[p] && data[p] <= 70 {
5725 goto tr190
5726 }
5727 case data[p] >= 58:
5728 goto st56
5729 }
5730 default:
5731 goto st94
5732 }
5733 case data[p] > 90:
5734 switch {
5735 case data[p] < 97:
5736 if 91 <= data[p] && data[p] <= 96 {
5737 goto st56
5738 }
5739 case data[p] > 102:
5740 switch {
5741 case data[p] > 122:
5742 if 123 <= data[p] && data[p] <= 126 {
5743 goto st56
5744 }
5745 case data[p] >= 103:
5746 goto tr76
5747 }
5748 default:
5749 goto tr190
5750 }
5751 default:
5752 goto tr76
5753 }
5754 goto st0
5755 st119:
5756 if p++; p == pe {
5757 goto _test_eof119
5758 }
5759 st_case_119:
5760 switch data[p] {
5761 case 33:
5762 goto tr191
5763 case 35:
5764 goto tr64
5765 case 37:
5766 goto tr192
5767 case 47:
5768 goto tr66
5769 case 58:
5770 goto st82
5771 case 60:
5772 goto st55
5773 case 62:
5774 goto st55
5775 case 63:
5776 goto tr67
5777 case 64:
5778 goto st112
5779 case 91:
5780 goto tr194
5781 case 92:
5782 goto tr73
5783 case 95:
5784 goto tr191
5785 case 126:
5786 goto tr191
5787 }
5788 switch {
5789 case data[p] < 65:
5790 switch {
5791 case data[p] > 34:
5792 if 36 <= data[p] && data[p] <= 61 {
5793 goto tr191
5794 }
5795 case data[p] >= 32:
5796 goto st55
5797 }
5798 case data[p] > 90:
5799 switch {
5800 case data[p] < 97:
5801 if 93 <= data[p] && data[p] <= 96 {
5802 goto st55
5803 }
5804 case data[p] > 122:
5805 if 123 <= data[p] && data[p] <= 125 {
5806 goto st55
5807 }
5808 default:
5809 goto tr193
5810 }
5811 default:
5812 goto tr193
5813 }
5814 goto st0
5815 tr194:
5816 //line parser.rl:23
5817
5818 host_mark = p
5819
5820 goto st120
5821 st120:
5822 if p++; p == pe {
5823 goto _test_eof120
5824 }
5825 st_case_120:
5826 //line parser.go:5832
5827 switch data[p] {
5828 case 35:
5829 goto tr64
5830 case 37:
5831 goto st61
5832 case 47:
5833 goto tr66
5834 case 63:
5835 goto tr67
5836 case 92:
5837 goto tr77
5838 case 118:
5839 goto tr197
5840 }
5841 switch {
5842 case data[p] < 71:
5843 switch {
5844 case data[p] < 48:
5845 if 32 <= data[p] && data[p] <= 46 {
5846 goto st56
5847 }
5848 case data[p] > 58:
5849 switch {
5850 case data[p] > 64:
5851 if 65 <= data[p] && data[p] <= 70 {
5852 goto tr196
5853 }
5854 case data[p] >= 59:
5855 goto st56
5856 }
5857 default:
5858 goto st121
5859 }
5860 case data[p] > 90:
5861 switch {
5862 case data[p] < 97:
5863 if 91 <= data[p] && data[p] <= 96 {
5864 goto st56
5865 }
5866 case data[p] > 102:
5867 switch {
5868 case data[p] > 122:
5869 if 123 <= data[p] && data[p] <= 126 {
5870 goto st56
5871 }
5872 case data[p] >= 103:
5873 goto tr76
5874 }
5875 default:
5876 goto tr196
5877 }
5878 default:
5879 goto tr76
5880 }
5881 goto st0
5882 tr196:
5883 //line parser.rl:13
5884
5885 if port_mark > host_mark {
5886 u.Port = data[port_mark:p]
5887 }
5888
5889 //line parser.rl:10
5890 mark = p
5891 goto st121
5892 st121:
5893 if p++; p == pe {
5894 goto _test_eof121
5895 }
5896 st_case_121:
5897 //line parser.go:5903
5898 switch data[p] {
5899 case 35:
5900 goto tr64
5901 case 37:
5902 goto st58
5903 case 47:
5904 goto tr66
5905 case 58:
5906 goto st114
5907 case 63:
5908 goto tr67
5909 case 92:
5910 goto tr80
5911 case 93:
5912 goto st123
5913 }
5914 switch {
5915 case data[p] < 71:
5916 switch {
5917 case data[p] < 48:
5918 if 32 <= data[p] && data[p] <= 46 {
5919 goto st57
5920 }
5921 case data[p] > 57:
5922 switch {
5923 case data[p] > 64:
5924 if 65 <= data[p] && data[p] <= 70 {
5925 goto tr184
5926 }
5927 case data[p] >= 59:
5928 goto st57
5929 }
5930 default:
5931 goto st122
5932 }
5933 case data[p] > 90:
5934 switch {
5935 case data[p] < 97:
5936 if 91 <= data[p] && data[p] <= 96 {
5937 goto st57
5938 }
5939 case data[p] > 102:
5940 switch {
5941 case data[p] > 122:
5942 if 123 <= data[p] && data[p] <= 126 {
5943 goto st57
5944 }
5945 case data[p] >= 103:
5946 goto tr79
5947 }
5948 default:
5949 goto tr184
5950 }
5951 default:
5952 goto tr79
5953 }
5954 goto st0
5955 st122:
5956 if p++; p == pe {
5957 goto _test_eof122
5958 }
5959 st_case_122:
5960 switch data[p] {
5961 case 35:
5962 goto tr64
5963 case 46:
5964 goto st15
5965 case 47:
5966 goto tr66
5967 case 58:
5968 goto st13
5969 case 63:
5970 goto tr67
5971 case 92:
5972 goto tr66
5973 case 93:
5974 goto st85
5975 }
5976 switch {
5977 case data[p] < 71:
5978 switch {
5979 case data[p] > 57:
5980 if 65 <= data[p] && data[p] <= 70 {
5981 goto tr174
5982 }
5983 case data[p] >= 48:
5984 goto st14
5985 }
5986 case data[p] > 90:
5987 switch {
5988 case data[p] > 102:
5989 if 103 <= data[p] && data[p] <= 122 {
5990 goto tr81
5991 }
5992 case data[p] >= 97:
5993 goto tr174
5994 }
5995 default:
5996 goto tr81
5997 }
5998 goto st0
5999 st123:
6000 if p++; p == pe {
6001 goto _test_eof123
6002 }
6003 st_case_123:
6004 switch data[p] {
6005 case 35:
6006 goto tr143
6007 case 47:
6008 goto tr145
6009 case 58:
6010 goto tr124
6011 case 63:
6012 goto tr147
6013 case 92:
6014 goto tr145
6015 }
6016 switch {
6017 case data[p] > 90:
6018 if 97 <= data[p] && data[p] <= 122 {
6019 goto tr200
6020 }
6021 case data[p] >= 65:
6022 goto tr200
6023 }
6024 goto st0
6025 tr197:
6026 //line parser.rl:13
6027
6028 if port_mark > host_mark {
6029 u.Port = data[port_mark:p]
6030 }
6031
6032 //line parser.rl:10
6033 mark = p
6034 goto st124
6035 st124:
6036 if p++; p == pe {
6037 goto _test_eof124
6038 }
6039 st_case_124:
6040 //line parser.go:6046
6041 switch data[p] {
6042 case 35:
6043 goto tr64
6044 case 37:
6045 goto st58
6046 case 47:
6047 goto tr66
6048 case 63:
6049 goto tr67
6050 case 92:
6051 goto tr80
6052 }
6053 switch {
6054 case data[p] < 71:
6055 switch {
6056 case data[p] < 48:
6057 if 32 <= data[p] && data[p] <= 46 {
6058 goto st57
6059 }
6060 case data[p] > 57:
6061 switch {
6062 case data[p] > 64:
6063 if 65 <= data[p] && data[p] <= 70 {
6064 goto tr202
6065 }
6066 case data[p] >= 58:
6067 goto st57
6068 }
6069 default:
6070 goto st125
6071 }
6072 case data[p] > 90:
6073 switch {
6074 case data[p] < 97:
6075 if 91 <= data[p] && data[p] <= 96 {
6076 goto st57
6077 }
6078 case data[p] > 102:
6079 switch {
6080 case data[p] > 122:
6081 if 123 <= data[p] && data[p] <= 126 {
6082 goto st57
6083 }
6084 case data[p] >= 103:
6085 goto tr79
6086 }
6087 default:
6088 goto tr202
6089 }
6090 default:
6091 goto tr79
6092 }
6093 goto st0
6094 st125:
6095 if p++; p == pe {
6096 goto _test_eof125
6097 }
6098 st_case_125:
6099 switch data[p] {
6100 case 35:
6101 goto tr64
6102 case 46:
6103 goto st30
6104 case 47:
6105 goto tr66
6106 case 63:
6107 goto tr67
6108 case 92:
6109 goto tr66
6110 }
6111 switch {
6112 case data[p] < 71:
6113 switch {
6114 case data[p] > 57:
6115 if 65 <= data[p] && data[p] <= 70 {
6116 goto tr186
6117 }
6118 case data[p] >= 48:
6119 goto st29
6120 }
6121 case data[p] > 90:
6122 switch {
6123 case data[p] > 102:
6124 if 103 <= data[p] && data[p] <= 122 {
6125 goto tr81
6126 }
6127 case data[p] >= 97:
6128 goto tr186
6129 }
6130 default:
6131 goto tr81
6132 }
6133 goto st0
6134 tr202:
6135 //line parser.rl:13
6136
6137 if port_mark > host_mark {
6138 u.Port = data[port_mark:p]
6139 }
6140
6141 //line parser.rl:10
6142 mark = p
6143 goto st126
6144 st126:
6145 if p++; p == pe {
6146 goto _test_eof126
6147 }
6148 st_case_126:
6149 //line parser.go:6155
6150 switch data[p] {
6151 case 35:
6152 goto tr64
6153 case 46:
6154 goto st30
6155 case 47:
6156 goto tr66
6157 case 58:
6158 goto st5
6159 case 63:
6160 goto tr67
6161 case 92:
6162 goto tr66
6163 }
6164 switch {
6165 case data[p] < 71:
6166 switch {
6167 case data[p] > 57:
6168 if 65 <= data[p] && data[p] <= 70 {
6169 goto tr186
6170 }
6171 case data[p] >= 48:
6172 goto st29
6173 }
6174 case data[p] > 90:
6175 switch {
6176 case data[p] > 102:
6177 if 103 <= data[p] && data[p] <= 122 {
6178 goto tr81
6179 }
6180 case data[p] >= 97:
6181 goto tr186
6182 }
6183 default:
6184 goto tr81
6185 }
6186 goto st0
6187 tr141:
6188 //line parser.rl:23
6189
6190 host_mark = p
6191
6192 goto st127
6193 st127:
6194 if p++; p == pe {
6195 goto _test_eof127
6196 }
6197 st_case_127:
6198 //line parser.go:6204
6199 switch data[p] {
6200 case 35:
6201 goto tr64
6202 case 37:
6203 goto st68
6204 case 47:
6205 goto tr66
6206 case 63:
6207 goto tr67
6208 case 92:
6209 goto tr73
6210 case 118:
6211 goto tr205
6212 }
6213 switch {
6214 case data[p] < 71:
6215 switch {
6216 case data[p] < 48:
6217 if 32 <= data[p] && data[p] <= 46 {
6218 goto st55
6219 }
6220 case data[p] > 58:
6221 switch {
6222 case data[p] > 64:
6223 if 65 <= data[p] && data[p] <= 70 {
6224 goto tr204
6225 }
6226 case data[p] >= 59:
6227 goto st55
6228 }
6229 default:
6230 goto st128
6231 }
6232 case data[p] > 90:
6233 switch {
6234 case data[p] < 97:
6235 if 91 <= data[p] && data[p] <= 96 {
6236 goto st55
6237 }
6238 case data[p] > 102:
6239 switch {
6240 case data[p] > 122:
6241 if 123 <= data[p] && data[p] <= 126 {
6242 goto st55
6243 }
6244 case data[p] >= 103:
6245 goto tr72
6246 }
6247 default:
6248 goto tr204
6249 }
6250 default:
6251 goto tr72
6252 }
6253 goto st0
6254 tr204:
6255 //line parser.rl:13
6256
6257 if port_mark > host_mark {
6258 u.Port = data[port_mark:p]
6259 }
6260
6261 //line parser.rl:10
6262 mark = p
6263 goto st128
6264 st128:
6265 if p++; p == pe {
6266 goto _test_eof128
6267 }
6268 st_case_128:
6269 //line parser.go:6275
6270 switch data[p] {
6271 case 35:
6272 goto tr64
6273 case 37:
6274 goto st61
6275 case 47:
6276 goto tr66
6277 case 58:
6278 goto st121
6279 case 63:
6280 goto tr67
6281 case 92:
6282 goto tr77
6283 case 93:
6284 goto st131
6285 }
6286 switch {
6287 case data[p] < 71:
6288 switch {
6289 case data[p] < 48:
6290 if 32 <= data[p] && data[p] <= 46 {
6291 goto st56
6292 }
6293 case data[p] > 57:
6294 switch {
6295 case data[p] > 64:
6296 if 65 <= data[p] && data[p] <= 70 {
6297 goto tr196
6298 }
6299 case data[p] >= 59:
6300 goto st56
6301 }
6302 default:
6303 goto st129
6304 }
6305 case data[p] > 90:
6306 switch {
6307 case data[p] < 97:
6308 if 91 <= data[p] && data[p] <= 96 {
6309 goto st56
6310 }
6311 case data[p] > 102:
6312 switch {
6313 case data[p] > 122:
6314 if 123 <= data[p] && data[p] <= 126 {
6315 goto st56
6316 }
6317 case data[p] >= 103:
6318 goto tr76
6319 }
6320 default:
6321 goto tr196
6322 }
6323 default:
6324 goto tr76
6325 }
6326 goto st0
6327 st129:
6328 if p++; p == pe {
6329 goto _test_eof129
6330 }
6331 st_case_129:
6332 switch data[p] {
6333 case 35:
6334 goto tr64
6335 case 37:
6336 goto st58
6337 case 46:
6338 goto st130
6339 case 47:
6340 goto tr66
6341 case 58:
6342 goto st114
6343 case 63:
6344 goto tr67
6345 case 92:
6346 goto tr80
6347 case 93:
6348 goto st123
6349 }
6350 switch {
6351 case data[p] < 71:
6352 switch {
6353 case data[p] < 48:
6354 if 32 <= data[p] && data[p] <= 45 {
6355 goto st57
6356 }
6357 case data[p] > 57:
6358 switch {
6359 case data[p] > 64:
6360 if 65 <= data[p] && data[p] <= 70 {
6361 goto tr184
6362 }
6363 case data[p] >= 59:
6364 goto st57
6365 }
6366 default:
6367 goto st122
6368 }
6369 case data[p] > 90:
6370 switch {
6371 case data[p] < 97:
6372 if 91 <= data[p] && data[p] <= 96 {
6373 goto st57
6374 }
6375 case data[p] > 102:
6376 switch {
6377 case data[p] > 122:
6378 if 123 <= data[p] && data[p] <= 126 {
6379 goto st57
6380 }
6381 case data[p] >= 103:
6382 goto tr79
6383 }
6384 default:
6385 goto tr184
6386 }
6387 default:
6388 goto tr79
6389 }
6390 goto st0
6391 st130:
6392 if p++; p == pe {
6393 goto _test_eof130
6394 }
6395 st_case_130:
6396 switch data[p] {
6397 case 35:
6398 goto tr64
6399 case 47:
6400 goto tr66
6401 case 63:
6402 goto tr67
6403 case 92:
6404 goto tr66
6405 }
6406 switch {
6407 case data[p] < 65:
6408 if 48 <= data[p] && data[p] <= 57 {
6409 goto st16
6410 }
6411 case data[p] > 90:
6412 if 97 <= data[p] && data[p] <= 122 {
6413 goto tr81
6414 }
6415 default:
6416 goto tr81
6417 }
6418 goto st0
6419 st131:
6420 if p++; p == pe {
6421 goto _test_eof131
6422 }
6423 st_case_131:
6424 switch data[p] {
6425 case 35:
6426 goto tr143
6427 case 37:
6428 goto st58
6429 case 47:
6430 goto tr145
6431 case 58:
6432 goto tr209
6433 case 63:
6434 goto tr147
6435 case 92:
6436 goto tr156
6437 }
6438 switch {
6439 case data[p] < 91:
6440 switch {
6441 case data[p] > 64:
6442 if 65 <= data[p] && data[p] <= 90 {
6443 goto tr210
6444 }
6445 case data[p] >= 32:
6446 goto st57
6447 }
6448 case data[p] > 96:
6449 switch {
6450 case data[p] > 122:
6451 if 123 <= data[p] && data[p] <= 126 {
6452 goto st57
6453 }
6454 case data[p] >= 97:
6455 goto tr210
6456 }
6457 default:
6458 goto st57
6459 }
6460 goto st0
6461 tr209:
6462 //line parser.rl:27
6463
6464 u.Host = data[host_mark:p]
6465
6466 goto st132
6467 st132:
6468 if p++; p == pe {
6469 goto _test_eof132
6470 }
6471 st_case_132:
6472 //line parser.go:6478
6473 switch data[p] {
6474 case 35:
6475 goto tr64
6476 case 37:
6477 goto tr31
6478 case 47:
6479 goto tr66
6480 case 63:
6481 goto tr67
6482 case 92:
6483 goto tr161
6484 }
6485 switch {
6486 case data[p] < 91:
6487 switch {
6488 case data[p] > 64:
6489 if 65 <= data[p] && data[p] <= 90 {
6490 goto tr211
6491 }
6492 case data[p] >= 32:
6493 goto tr3
6494 }
6495 case data[p] > 96:
6496 switch {
6497 case data[p] > 122:
6498 if 123 <= data[p] && data[p] <= 126 {
6499 goto tr3
6500 }
6501 case data[p] >= 97:
6502 goto tr211
6503 }
6504 default:
6505 goto tr3
6506 }
6507 goto st0
6508 tr205:
6509 //line parser.rl:13
6510
6511 if port_mark > host_mark {
6512 u.Port = data[port_mark:p]
6513 }
6514
6515 //line parser.rl:10
6516 mark = p
6517 goto st133
6518 st133:
6519 if p++; p == pe {
6520 goto _test_eof133
6521 }
6522 st_case_133:
6523 //line parser.go:6529
6524 switch data[p] {
6525 case 35:
6526 goto tr64
6527 case 37:
6528 goto st61
6529 case 47:
6530 goto tr66
6531 case 63:
6532 goto tr67
6533 case 92:
6534 goto tr77
6535 }
6536 switch {
6537 case data[p] < 71:
6538 switch {
6539 case data[p] < 48:
6540 if 32 <= data[p] && data[p] <= 46 {
6541 goto st56
6542 }
6543 case data[p] > 57:
6544 switch {
6545 case data[p] > 64:
6546 if 65 <= data[p] && data[p] <= 70 {
6547 goto tr213
6548 }
6549 case data[p] >= 58:
6550 goto st56
6551 }
6552 default:
6553 goto st134
6554 }
6555 case data[p] > 90:
6556 switch {
6557 case data[p] < 97:
6558 if 91 <= data[p] && data[p] <= 96 {
6559 goto st56
6560 }
6561 case data[p] > 102:
6562 switch {
6563 case data[p] > 122:
6564 if 123 <= data[p] && data[p] <= 126 {
6565 goto st56
6566 }
6567 case data[p] >= 103:
6568 goto tr76
6569 }
6570 default:
6571 goto tr213
6572 }
6573 default:
6574 goto tr76
6575 }
6576 goto st0
6577 tr213:
6578 //line parser.rl:13
6579
6580 if port_mark > host_mark {
6581 u.Port = data[port_mark:p]
6582 }
6583
6584 //line parser.rl:10
6585 mark = p
6586 goto st134
6587 st134:
6588 if p++; p == pe {
6589 goto _test_eof134
6590 }
6591 st_case_134:
6592 //line parser.go:6598
6593 switch data[p] {
6594 case 35:
6595 goto tr64
6596 case 37:
6597 goto st58
6598 case 46:
6599 goto st135
6600 case 47:
6601 goto tr66
6602 case 63:
6603 goto tr67
6604 case 92:
6605 goto tr80
6606 }
6607 switch {
6608 case data[p] < 71:
6609 switch {
6610 case data[p] < 48:
6611 if 32 <= data[p] && data[p] <= 45 {
6612 goto st57
6613 }
6614 case data[p] > 57:
6615 switch {
6616 case data[p] > 64:
6617 if 65 <= data[p] && data[p] <= 70 {
6618 goto tr202
6619 }
6620 case data[p] >= 58:
6621 goto st57
6622 }
6623 default:
6624 goto st125
6625 }
6626 case data[p] > 90:
6627 switch {
6628 case data[p] < 97:
6629 if 91 <= data[p] && data[p] <= 96 {
6630 goto st57
6631 }
6632 case data[p] > 102:
6633 switch {
6634 case data[p] > 122:
6635 if 123 <= data[p] && data[p] <= 126 {
6636 goto st57
6637 }
6638 case data[p] >= 103:
6639 goto tr79
6640 }
6641 default:
6642 goto tr202
6643 }
6644 default:
6645 goto tr79
6646 }
6647 goto st0
6648 st135:
6649 if p++; p == pe {
6650 goto _test_eof135
6651 }
6652 st_case_135:
6653 switch data[p] {
6654 case 33:
6655 goto st31
6656 case 35:
6657 goto tr64
6658 case 36:
6659 goto st31
6660 case 47:
6661 goto tr66
6662 case 61:
6663 goto st31
6664 case 63:
6665 goto tr67
6666 case 92:
6667 goto tr66
6668 case 95:
6669 goto st31
6670 case 126:
6671 goto st31
6672 }
6673 switch {
6674 case data[p] < 65:
6675 if 38 <= data[p] && data[p] <= 59 {
6676 goto st31
6677 }
6678 case data[p] > 90:
6679 if 97 <= data[p] && data[p] <= 122 {
6680 goto tr215
6681 }
6682 default:
6683 goto tr215
6684 }
6685 goto st0
6686 tr215:
6687 //line parser.rl:13
6688
6689 if port_mark > host_mark {
6690 u.Port = data[port_mark:p]
6691 }
6692
6693 //line parser.rl:10
6694 mark = p
6695 goto st43
6696 st43:
6697 if p++; p == pe {
6698 goto _test_eof43
6699 }
6700 st_case_43:
6701 //line parser.go:6707
6702 switch data[p] {
6703 case 33:
6704 goto st31
6705 case 36:
6706 goto st31
6707 case 58:
6708 goto st44
6709 case 61:
6710 goto st31
6711 case 93:
6712 goto st85
6713 case 95:
6714 goto st31
6715 case 126:
6716 goto st31
6717 }
6718 switch {
6719 case data[p] < 48:
6720 if 38 <= data[p] && data[p] <= 46 {
6721 goto st31
6722 }
6723 case data[p] > 59:
6724 switch {
6725 case data[p] > 90:
6726 if 97 <= data[p] && data[p] <= 122 {
6727 goto st31
6728 }
6729 case data[p] >= 65:
6730 goto st31
6731 }
6732 default:
6733 goto st31
6734 }
6735 goto st0
6736 st44:
6737 if p++; p == pe {
6738 goto _test_eof44
6739 }
6740 st_case_44:
6741 switch data[p] {
6742 case 33:
6743 goto st31
6744 case 36:
6745 goto st31
6746 case 47:
6747 goto st49
6748 case 61:
6749 goto st31
6750 case 92:
6751 goto st49
6752 case 93:
6753 goto st85
6754 case 95:
6755 goto st31
6756 case 126:
6757 goto st31
6758 }
6759 switch {
6760 case data[p] < 65:
6761 if 38 <= data[p] && data[p] <= 59 {
6762 goto st31
6763 }
6764 case data[p] > 90:
6765 if 97 <= data[p] && data[p] <= 122 {
6766 goto st31
6767 }
6768 default:
6769 goto st31
6770 }
6771 goto st0
6772 tr122:
6773 //line parser.rl:13
6774
6775 if port_mark > host_mark {
6776 u.Port = data[port_mark:p]
6777 }
6778
6779 //line parser.rl:10
6780 mark = p
6781 goto st136
6782 st136:
6783 if p++; p == pe {
6784 goto _test_eof136
6785 }
6786 st_case_136:
6787 //line parser.go:6793
6788 switch data[p] {
6789 case 33:
6790 goto st8
6791 case 35:
6792 goto tr64
6793 case 37:
6794 goto st9
6795 case 47:
6796 goto tr66
6797 case 58:
6798 goto st33
6799 case 61:
6800 goto st8
6801 case 63:
6802 goto tr67
6803 case 64:
6804 goto st11
6805 case 92:
6806 goto tr66
6807 case 95:
6808 goto st8
6809 case 126:
6810 goto st8
6811 }
6812 switch {
6813 case data[p] < 65:
6814 if 36 <= data[p] && data[p] <= 59 {
6815 goto st8
6816 }
6817 case data[p] > 90:
6818 if 97 <= data[p] && data[p] <= 122 {
6819 goto tr123
6820 }
6821 default:
6822 goto tr123
6823 }
6824 goto st0
6825 st137:
6826 if p++; p == pe {
6827 goto _test_eof137
6828 }
6829 st_case_137:
6830 switch data[p] {
6831 case 35:
6832 goto tr64
6833 case 37:
6834 goto st58
6835 case 47:
6836 goto tr66
6837 case 63:
6838 goto tr67
6839 case 92:
6840 goto tr80
6841 }
6842 switch {
6843 case data[p] < 71:
6844 switch {
6845 case data[p] < 48:
6846 if 32 <= data[p] && data[p] <= 46 {
6847 goto st57
6848 }
6849 case data[p] > 57:
6850 switch {
6851 case data[p] > 64:
6852 if 65 <= data[p] && data[p] <= 70 {
6853 goto tr217
6854 }
6855 case data[p] >= 58:
6856 goto st57
6857 }
6858 default:
6859 goto st138
6860 }
6861 case data[p] > 90:
6862 switch {
6863 case data[p] < 97:
6864 if 91 <= data[p] && data[p] <= 96 {
6865 goto st57
6866 }
6867 case data[p] > 102:
6868 switch {
6869 case data[p] > 122:
6870 if 123 <= data[p] && data[p] <= 126 {
6871 goto st57
6872 }
6873 case data[p] >= 103:
6874 goto tr79
6875 }
6876 default:
6877 goto tr217
6878 }
6879 default:
6880 goto tr79
6881 }
6882 goto st0
6883 st138:
6884 if p++; p == pe {
6885 goto _test_eof138
6886 }
6887 st_case_138:
6888 switch data[p] {
6889 case 35:
6890 goto tr64
6891 case 47:
6892 goto tr66
6893 case 63:
6894 goto tr67
6895 case 92:
6896 goto tr66
6897 }
6898 switch {
6899 case data[p] < 71:
6900 switch {
6901 case data[p] > 57:
6902 if 65 <= data[p] && data[p] <= 70 {
6903 goto tr119
6904 }
6905 case data[p] >= 48:
6906 goto st83
6907 }
6908 case data[p] > 90:
6909 switch {
6910 case data[p] > 102:
6911 if 103 <= data[p] && data[p] <= 122 {
6912 goto tr81
6913 }
6914 case data[p] >= 97:
6915 goto tr119
6916 }
6917 default:
6918 goto tr81
6919 }
6920 goto st0
6921 tr217:
6922 //line parser.rl:13
6923
6924 if port_mark > host_mark {
6925 u.Port = data[port_mark:p]
6926 }
6927
6928 //line parser.rl:10
6929 mark = p
6930 goto st139
6931 st139:
6932 if p++; p == pe {
6933 goto _test_eof139
6934 }
6935 st_case_139:
6936 //line parser.go:6942
6937 switch data[p] {
6938 case 35:
6939 goto tr64
6940 case 47:
6941 goto tr66
6942 case 58:
6943 goto st5
6944 case 63:
6945 goto tr67
6946 case 92:
6947 goto tr66
6948 }
6949 switch {
6950 case data[p] < 71:
6951 switch {
6952 case data[p] > 57:
6953 if 65 <= data[p] && data[p] <= 70 {
6954 goto tr119
6955 }
6956 case data[p] >= 48:
6957 goto st83
6958 }
6959 case data[p] > 90:
6960 switch {
6961 case data[p] > 102:
6962 if 103 <= data[p] && data[p] <= 122 {
6963 goto tr81
6964 }
6965 case data[p] >= 97:
6966 goto tr119
6967 }
6968 default:
6969 goto tr81
6970 }
6971 goto st0
6972 st140:
6973 if p++; p == pe {
6974 goto _test_eof140
6975 }
6976 st_case_140:
6977 switch data[p] {
6978 case 35:
6979 goto tr64
6980 case 37:
6981 goto st61
6982 case 47:
6983 goto tr66
6984 case 63:
6985 goto tr67
6986 case 92:
6987 goto tr77
6988 }
6989 switch {
6990 case data[p] < 71:
6991 switch {
6992 case data[p] < 48:
6993 if 32 <= data[p] && data[p] <= 46 {
6994 goto st56
6995 }
6996 case data[p] > 57:
6997 switch {
6998 case data[p] > 64:
6999 if 65 <= data[p] && data[p] <= 70 {
7000 goto tr219
7001 }
7002 case data[p] >= 58:
7003 goto st56
7004 }
7005 default:
7006 goto st141
7007 }
7008 case data[p] > 90:
7009 switch {
7010 case data[p] < 97:
7011 if 91 <= data[p] && data[p] <= 96 {
7012 goto st56
7013 }
7014 case data[p] > 102:
7015 switch {
7016 case data[p] > 122:
7017 if 123 <= data[p] && data[p] <= 126 {
7018 goto st56
7019 }
7020 case data[p] >= 103:
7021 goto tr76
7022 }
7023 default:
7024 goto tr219
7025 }
7026 default:
7027 goto tr76
7028 }
7029 goto st0
7030 tr219:
7031 //line parser.rl:13
7032
7033 if port_mark > host_mark {
7034 u.Port = data[port_mark:p]
7035 }
7036
7037 //line parser.rl:10
7038 mark = p
7039 goto st141
7040 st141:
7041 if p++; p == pe {
7042 goto _test_eof141
7043 }
7044 st_case_141:
7045 //line parser.go:7051
7046 switch data[p] {
7047 case 35:
7048 goto tr64
7049 case 37:
7050 goto st58
7051 case 47:
7052 goto tr66
7053 case 63:
7054 goto tr67
7055 case 92:
7056 goto tr80
7057 }
7058 switch {
7059 case data[p] < 71:
7060 switch {
7061 case data[p] < 48:
7062 if 32 <= data[p] && data[p] <= 46 {
7063 goto st57
7064 }
7065 case data[p] > 57:
7066 switch {
7067 case data[p] > 64:
7068 if 65 <= data[p] && data[p] <= 70 {
7069 goto tr115
7070 }
7071 case data[p] >= 58:
7072 goto st57
7073 }
7074 default:
7075 goto st82
7076 }
7077 case data[p] > 90:
7078 switch {
7079 case data[p] < 97:
7080 if 91 <= data[p] && data[p] <= 96 {
7081 goto st57
7082 }
7083 case data[p] > 102:
7084 switch {
7085 case data[p] > 122:
7086 if 123 <= data[p] && data[p] <= 126 {
7087 goto st57
7088 }
7089 case data[p] >= 103:
7090 goto tr79
7091 }
7092 default:
7093 goto tr115
7094 }
7095 default:
7096 goto tr79
7097 }
7098 goto st0
7099 st142:
7100 if p++; p == pe {
7101 goto _test_eof142
7102 }
7103 st_case_142:
7104 switch data[p] {
7105 case 35:
7106 goto tr64
7107 case 37:
7108 goto st68
7109 case 47:
7110 goto tr66
7111 case 63:
7112 goto tr67
7113 case 92:
7114 goto tr73
7115 }
7116 switch {
7117 case data[p] < 71:
7118 switch {
7119 case data[p] < 48:
7120 if 32 <= data[p] && data[p] <= 46 {
7121 goto st55
7122 }
7123 case data[p] > 57:
7124 switch {
7125 case data[p] > 64:
7126 if 65 <= data[p] && data[p] <= 70 {
7127 goto tr221
7128 }
7129 case data[p] >= 58:
7130 goto st55
7131 }
7132 default:
7133 goto st143
7134 }
7135 case data[p] > 90:
7136 switch {
7137 case data[p] < 97:
7138 if 91 <= data[p] && data[p] <= 96 {
7139 goto st55
7140 }
7141 case data[p] > 102:
7142 switch {
7143 case data[p] > 122:
7144 if 123 <= data[p] && data[p] <= 126 {
7145 goto st55
7146 }
7147 case data[p] >= 103:
7148 goto tr72
7149 }
7150 default:
7151 goto tr221
7152 }
7153 default:
7154 goto tr72
7155 }
7156 goto st0
7157 tr221:
7158 //line parser.rl:13
7159
7160 if port_mark > host_mark {
7161 u.Port = data[port_mark:p]
7162 }
7163
7164 //line parser.rl:10
7165 mark = p
7166 goto st143
7167 st143:
7168 if p++; p == pe {
7169 goto _test_eof143
7170 }
7171 st_case_143:
7172 //line parser.go:7178
7173 switch data[p] {
7174 case 35:
7175 goto tr64
7176 case 37:
7177 goto st61
7178 case 47:
7179 goto tr66
7180 case 63:
7181 goto tr67
7182 case 92:
7183 goto tr77
7184 }
7185 switch {
7186 case data[p] < 71:
7187 switch {
7188 case data[p] < 48:
7189 if 32 <= data[p] && data[p] <= 46 {
7190 goto st56
7191 }
7192 case data[p] > 57:
7193 switch {
7194 case data[p] > 64:
7195 if 65 <= data[p] && data[p] <= 70 {
7196 goto tr111
7197 }
7198 case data[p] >= 58:
7199 goto st56
7200 }
7201 default:
7202 goto st81
7203 }
7204 case data[p] > 90:
7205 switch {
7206 case data[p] < 97:
7207 if 91 <= data[p] && data[p] <= 96 {
7208 goto st56
7209 }
7210 case data[p] > 102:
7211 switch {
7212 case data[p] > 122:
7213 if 123 <= data[p] && data[p] <= 126 {
7214 goto st56
7215 }
7216 case data[p] >= 103:
7217 goto tr76
7218 }
7219 default:
7220 goto tr111
7221 }
7222 default:
7223 goto tr76
7224 }
7225 goto st0
7226 tr44:
7227 //line parser.rl:10
7228 mark = p
7229 goto st144
7230 tr230:
7231 //line parser.rl:19
7232
7233 u.Protocol = data[0 : p-1]
7234
7235 //line parser.rl:10
7236 mark = p
7237 goto st144
7238 st144:
7239 if p++; p == pe {
7240 goto _test_eof144
7241 }
7242 st_case_144:
7243 //line parser.go:7249
7244 switch data[p] {
7245 case 35:
7246 goto tr57
7247 case 47:
7248 goto st145
7249 case 63:
7250 goto tr58
7251 }
7252 if 32 <= data[p] && data[p] <= 126 {
7253 goto st50
7254 }
7255 goto st0
7256 st145:
7257 if p++; p == pe {
7258 goto _test_eof145
7259 }
7260 st_case_145:
7261 switch data[p] {
7262 case 33:
7263 goto tr14
7264 case 35:
7265 goto st47
7266 case 37:
7267 goto tr15
7268 case 47:
7269 goto tr47
7270 case 58:
7271 goto st8
7272 case 61:
7273 goto tr14
7274 case 63:
7275 goto st51
7276 case 64:
7277 goto st11
7278 case 91:
7279 goto tr16
7280 case 92:
7281 goto tr47
7282 case 95:
7283 goto tr14
7284 case 126:
7285 goto tr14
7286 }
7287 switch {
7288 case data[p] < 65:
7289 if 36 <= data[p] && data[p] <= 59 {
7290 goto tr14
7291 }
7292 case data[p] > 90:
7293 if 97 <= data[p] && data[p] <= 122 {
7294 goto tr223
7295 }
7296 default:
7297 goto tr223
7298 }
7299 goto st0
7300 tr46:
7301 //line parser.rl:10
7302 mark = p
7303 //line parser.rl:23
7304
7305 host_mark = p
7306
7307 goto st146
7308 tr226:
7309 //line parser.rl:27
7310
7311 u.Host = data[host_mark:p]
7312
7313 //line parser.rl:10
7314 mark = p
7315 goto st146
7316 st146:
7317 if p++; p == pe {
7318 goto _test_eof146
7319 }
7320 st_case_146:
7321 //line parser.go:7327
7322 switch data[p] {
7323 case 33:
7324 goto st46
7325 case 35:
7326 goto tr48
7327 case 37:
7328 goto st1
7329 case 43:
7330 goto st146
7331 case 47:
7332 goto tr50
7333 case 58:
7334 goto tr225
7335 case 59:
7336 goto st46
7337 case 61:
7338 goto st46
7339 case 63:
7340 goto tr52
7341 case 64:
7342 goto st11
7343 case 92:
7344 goto tr50
7345 case 95:
7346 goto st46
7347 case 126:
7348 goto st46
7349 }
7350 switch {
7351 case data[p] < 45:
7352 if 36 <= data[p] && data[p] <= 44 {
7353 goto st46
7354 }
7355 case data[p] > 57:
7356 switch {
7357 case data[p] > 90:
7358 if 97 <= data[p] && data[p] <= 122 {
7359 goto tr226
7360 }
7361 case data[p] >= 65:
7362 goto tr226
7363 }
7364 default:
7365 goto st146
7366 }
7367 goto st0
7368 tr225:
7369 //line parser.rl:27
7370
7371 u.Host = data[host_mark:p]
7372
7373 goto st147
7374 st147:
7375 if p++; p == pe {
7376 goto _test_eof147
7377 }
7378 st_case_147:
7379 //line parser.go:7385
7380 switch data[p] {
7381 case 33:
7382 goto tr227
7383 case 35:
7384 goto tr228
7385 case 37:
7386 goto tr229
7387 case 47:
7388 goto tr230
7389 case 58:
7390 goto tr231
7391 case 60:
7392 goto tr3
7393 case 62:
7394 goto tr3
7395 case 63:
7396 goto tr232
7397 case 64:
7398 goto tr233
7399 case 91:
7400 goto tr235
7401 case 92:
7402 goto tr236
7403 case 95:
7404 goto tr227
7405 case 126:
7406 goto tr227
7407 }
7408 switch {
7409 case data[p] < 65:
7410 switch {
7411 case data[p] > 34:
7412 if 36 <= data[p] && data[p] <= 61 {
7413 goto tr227
7414 }
7415 case data[p] >= 32:
7416 goto tr3
7417 }
7418 case data[p] > 90:
7419 switch {
7420 case data[p] < 97:
7421 if 93 <= data[p] && data[p] <= 96 {
7422 goto tr3
7423 }
7424 case data[p] > 122:
7425 if 123 <= data[p] && data[p] <= 125 {
7426 goto tr3
7427 }
7428 default:
7429 goto tr234
7430 }
7431 default:
7432 goto tr234
7433 }
7434 goto st0
7435 tr243:
7436 //line parser.rl:13
7437
7438 if port_mark > host_mark {
7439 u.Port = data[port_mark:p]
7440 }
7441
7442 //line parser.rl:10
7443 mark = p
7444 goto st148
7445 tr227:
7446 //line parser.rl:19
7447
7448 u.Protocol = data[0 : p-1]
7449
7450 //line parser.rl:23
7451
7452 host_mark = p
7453
7454 //line parser.rl:11
7455 port_mark = p
7456 goto st148
7457 tr234:
7458 //line parser.rl:19
7459
7460 u.Protocol = data[0 : p-1]
7461
7462 //line parser.rl:23
7463
7464 host_mark = p
7465
7466 //line parser.rl:11
7467 port_mark = p
7468 //line parser.rl:10
7469 mark = p
7470 goto st148
7471 st148:
7472 if p++; p == pe {
7473 goto _test_eof148
7474 }
7475 st_case_148:
7476 //line parser.go:7482
7477 switch data[p] {
7478 case 33:
7479 goto st94
7480 case 35:
7481 goto tr143
7482 case 37:
7483 goto st117
7484 case 47:
7485 goto tr145
7486 case 58:
7487 goto tr146
7488 case 60:
7489 goto st54
7490 case 62:
7491 goto st54
7492 case 63:
7493 goto tr147
7494 case 64:
7495 goto st119
7496 case 92:
7497 goto tr239
7498 case 95:
7499 goto st94
7500 case 126:
7501 goto st94
7502 }
7503 switch {
7504 case data[p] < 65:
7505 switch {
7506 case data[p] > 34:
7507 if 36 <= data[p] && data[p] <= 61 {
7508 goto st94
7509 }
7510 case data[p] >= 32:
7511 goto st54
7512 }
7513 case data[p] > 90:
7514 switch {
7515 case data[p] < 97:
7516 if 91 <= data[p] && data[p] <= 96 {
7517 goto st54
7518 }
7519 case data[p] > 122:
7520 if 123 <= data[p] && data[p] <= 125 {
7521 goto st54
7522 }
7523 default:
7524 goto tr238
7525 }
7526 default:
7527 goto tr238
7528 }
7529 goto st0
7530 tr229:
7531 //line parser.rl:19
7532
7533 u.Protocol = data[0 : p-1]
7534
7535 //line parser.rl:23
7536
7537 host_mark = p
7538
7539 //line parser.rl:11
7540 port_mark = p
7541 goto st149
7542 st149:
7543 if p++; p == pe {
7544 goto _test_eof149
7545 }
7546 st_case_149:
7547 //line parser.go:7553
7548 switch data[p] {
7549 case 35:
7550 goto tr64
7551 case 37:
7552 goto st74
7553 case 47:
7554 goto tr66
7555 case 63:
7556 goto tr67
7557 case 92:
7558 goto tr69
7559 }
7560 switch {
7561 case data[p] < 71:
7562 switch {
7563 case data[p] < 48:
7564 if 32 <= data[p] && data[p] <= 46 {
7565 goto st54
7566 }
7567 case data[p] > 57:
7568 switch {
7569 case data[p] > 64:
7570 if 65 <= data[p] && data[p] <= 70 {
7571 goto tr241
7572 }
7573 case data[p] >= 58:
7574 goto st54
7575 }
7576 default:
7577 goto st150
7578 }
7579 case data[p] > 90:
7580 switch {
7581 case data[p] < 97:
7582 if 91 <= data[p] && data[p] <= 96 {
7583 goto st54
7584 }
7585 case data[p] > 102:
7586 switch {
7587 case data[p] > 122:
7588 if 123 <= data[p] && data[p] <= 126 {
7589 goto st54
7590 }
7591 case data[p] >= 103:
7592 goto tr68
7593 }
7594 default:
7595 goto tr241
7596 }
7597 default:
7598 goto tr68
7599 }
7600 goto st0
7601 tr241:
7602 //line parser.rl:13
7603
7604 if port_mark > host_mark {
7605 u.Port = data[port_mark:p]
7606 }
7607
7608 //line parser.rl:10
7609 mark = p
7610 goto st150
7611 st150:
7612 if p++; p == pe {
7613 goto _test_eof150
7614 }
7615 st_case_150:
7616 //line parser.go:7622
7617 switch data[p] {
7618 case 35:
7619 goto tr64
7620 case 37:
7621 goto st68
7622 case 47:
7623 goto tr66
7624 case 63:
7625 goto tr67
7626 case 92:
7627 goto tr73
7628 }
7629 switch {
7630 case data[p] < 71:
7631 switch {
7632 case data[p] < 48:
7633 if 32 <= data[p] && data[p] <= 46 {
7634 goto st55
7635 }
7636 case data[p] > 57:
7637 switch {
7638 case data[p] > 64:
7639 if 65 <= data[p] && data[p] <= 70 {
7640 goto tr243
7641 }
7642 case data[p] >= 58:
7643 goto st55
7644 }
7645 default:
7646 goto st148
7647 }
7648 case data[p] > 90:
7649 switch {
7650 case data[p] < 97:
7651 if 91 <= data[p] && data[p] <= 96 {
7652 goto st55
7653 }
7654 case data[p] > 102:
7655 switch {
7656 case data[p] > 122:
7657 if 123 <= data[p] && data[p] <= 126 {
7658 goto st55
7659 }
7660 case data[p] >= 103:
7661 goto tr72
7662 }
7663 default:
7664 goto tr243
7665 }
7666 default:
7667 goto tr72
7668 }
7669 goto st0
7670 tr235:
7671 //line parser.rl:19
7672
7673 u.Protocol = data[0 : p-1]
7674
7675 //line parser.rl:23
7676
7677 host_mark = p
7678
7679 //line parser.rl:11
7680 port_mark = p
7681 goto st151
7682 st151:
7683 if p++; p == pe {
7684 goto _test_eof151
7685 }
7686 st_case_151:
7687 //line parser.go:7693
7688 switch data[p] {
7689 case 35:
7690 goto tr64
7691 case 37:
7692 goto st74
7693 case 47:
7694 goto tr66
7695 case 63:
7696 goto tr67
7697 case 92:
7698 goto tr69
7699 case 118:
7700 goto tr246
7701 }
7702 switch {
7703 case data[p] < 71:
7704 switch {
7705 case data[p] < 48:
7706 if 32 <= data[p] && data[p] <= 46 {
7707 goto st54
7708 }
7709 case data[p] > 58:
7710 switch {
7711 case data[p] > 64:
7712 if 65 <= data[p] && data[p] <= 70 {
7713 goto tr245
7714 }
7715 case data[p] >= 59:
7716 goto st54
7717 }
7718 default:
7719 goto st152
7720 }
7721 case data[p] > 90:
7722 switch {
7723 case data[p] < 97:
7724 if 91 <= data[p] && data[p] <= 96 {
7725 goto st54
7726 }
7727 case data[p] > 102:
7728 switch {
7729 case data[p] > 122:
7730 if 123 <= data[p] && data[p] <= 126 {
7731 goto st54
7732 }
7733 case data[p] >= 103:
7734 goto tr68
7735 }
7736 default:
7737 goto tr245
7738 }
7739 default:
7740 goto tr68
7741 }
7742 goto st0
7743 tr245:
7744 //line parser.rl:13
7745
7746 if port_mark > host_mark {
7747 u.Port = data[port_mark:p]
7748 }
7749
7750 //line parser.rl:10
7751 mark = p
7752 goto st152
7753 st152:
7754 if p++; p == pe {
7755 goto _test_eof152
7756 }
7757 st_case_152:
7758 //line parser.go:7764
7759 switch data[p] {
7760 case 35:
7761 goto tr64
7762 case 37:
7763 goto st68
7764 case 47:
7765 goto tr66
7766 case 58:
7767 goto st128
7768 case 63:
7769 goto tr67
7770 case 92:
7771 goto tr73
7772 case 93:
7773 goto st156
7774 }
7775 switch {
7776 case data[p] < 71:
7777 switch {
7778 case data[p] < 48:
7779 if 32 <= data[p] && data[p] <= 46 {
7780 goto st55
7781 }
7782 case data[p] > 57:
7783 switch {
7784 case data[p] > 64:
7785 if 65 <= data[p] && data[p] <= 70 {
7786 goto tr204
7787 }
7788 case data[p] >= 59:
7789 goto st55
7790 }
7791 default:
7792 goto st153
7793 }
7794 case data[p] > 90:
7795 switch {
7796 case data[p] < 97:
7797 if 91 <= data[p] && data[p] <= 96 {
7798 goto st55
7799 }
7800 case data[p] > 102:
7801 switch {
7802 case data[p] > 122:
7803 if 123 <= data[p] && data[p] <= 126 {
7804 goto st55
7805 }
7806 case data[p] >= 103:
7807 goto tr72
7808 }
7809 default:
7810 goto tr204
7811 }
7812 default:
7813 goto tr72
7814 }
7815 goto st0
7816 st153:
7817 if p++; p == pe {
7818 goto _test_eof153
7819 }
7820 st_case_153:
7821 switch data[p] {
7822 case 35:
7823 goto tr64
7824 case 37:
7825 goto st61
7826 case 46:
7827 goto st154
7828 case 47:
7829 goto tr66
7830 case 58:
7831 goto st121
7832 case 63:
7833 goto tr67
7834 case 92:
7835 goto tr77
7836 case 93:
7837 goto st131
7838 }
7839 switch {
7840 case data[p] < 71:
7841 switch {
7842 case data[p] < 48:
7843 if 32 <= data[p] && data[p] <= 45 {
7844 goto st56
7845 }
7846 case data[p] > 57:
7847 switch {
7848 case data[p] > 64:
7849 if 65 <= data[p] && data[p] <= 70 {
7850 goto tr196
7851 }
7852 case data[p] >= 59:
7853 goto st56
7854 }
7855 default:
7856 goto st129
7857 }
7858 case data[p] > 90:
7859 switch {
7860 case data[p] < 97:
7861 if 91 <= data[p] && data[p] <= 96 {
7862 goto st56
7863 }
7864 case data[p] > 102:
7865 switch {
7866 case data[p] > 122:
7867 if 123 <= data[p] && data[p] <= 126 {
7868 goto st56
7869 }
7870 case data[p] >= 103:
7871 goto tr76
7872 }
7873 default:
7874 goto tr196
7875 }
7876 default:
7877 goto tr76
7878 }
7879 goto st0
7880 st154:
7881 if p++; p == pe {
7882 goto _test_eof154
7883 }
7884 st_case_154:
7885 switch data[p] {
7886 case 35:
7887 goto tr64
7888 case 37:
7889 goto st58
7890 case 47:
7891 goto tr66
7892 case 63:
7893 goto tr67
7894 case 92:
7895 goto tr80
7896 }
7897 switch {
7898 case data[p] < 65:
7899 switch {
7900 case data[p] < 48:
7901 if 32 <= data[p] && data[p] <= 46 {
7902 goto st57
7903 }
7904 case data[p] > 57:
7905 if 58 <= data[p] && data[p] <= 64 {
7906 goto st57
7907 }
7908 default:
7909 goto st155
7910 }
7911 case data[p] > 90:
7912 switch {
7913 case data[p] < 97:
7914 if 91 <= data[p] && data[p] <= 96 {
7915 goto st57
7916 }
7917 case data[p] > 122:
7918 if 123 <= data[p] && data[p] <= 126 {
7919 goto st57
7920 }
7921 default:
7922 goto tr79
7923 }
7924 default:
7925 goto tr79
7926 }
7927 goto st0
7928 st155:
7929 if p++; p == pe {
7930 goto _test_eof155
7931 }
7932 st_case_155:
7933 switch data[p] {
7934 case 35:
7935 goto tr64
7936 case 46:
7937 goto st17
7938 case 47:
7939 goto tr66
7940 case 63:
7941 goto tr67
7942 case 92:
7943 goto tr66
7944 }
7945 switch {
7946 case data[p] < 65:
7947 if 48 <= data[p] && data[p] <= 57 {
7948 goto st26
7949 }
7950 case data[p] > 90:
7951 if 97 <= data[p] && data[p] <= 122 {
7952 goto tr81
7953 }
7954 default:
7955 goto tr81
7956 }
7957 goto st0
7958 st156:
7959 if p++; p == pe {
7960 goto _test_eof156
7961 }
7962 st_case_156:
7963 switch data[p] {
7964 case 35:
7965 goto tr143
7966 case 37:
7967 goto st61
7968 case 47:
7969 goto tr145
7970 case 58:
7971 goto tr209
7972 case 63:
7973 goto tr147
7974 case 92:
7975 goto tr153
7976 }
7977 switch {
7978 case data[p] < 91:
7979 switch {
7980 case data[p] > 64:
7981 if 65 <= data[p] && data[p] <= 90 {
7982 goto tr251
7983 }
7984 case data[p] >= 32:
7985 goto st56
7986 }
7987 case data[p] > 96:
7988 switch {
7989 case data[p] > 122:
7990 if 123 <= data[p] && data[p] <= 126 {
7991 goto st56
7992 }
7993 case data[p] >= 97:
7994 goto tr251
7995 }
7996 default:
7997 goto st56
7998 }
7999 goto st0
8000 tr246:
8001 //line parser.rl:13
8002
8003 if port_mark > host_mark {
8004 u.Port = data[port_mark:p]
8005 }
8006
8007 //line parser.rl:10
8008 mark = p
8009 goto st157
8010 st157:
8011 if p++; p == pe {
8012 goto _test_eof157
8013 }
8014 st_case_157:
8015 //line parser.go:8021
8016 switch data[p] {
8017 case 35:
8018 goto tr64
8019 case 37:
8020 goto st68
8021 case 47:
8022 goto tr66
8023 case 63:
8024 goto tr67
8025 case 92:
8026 goto tr73
8027 }
8028 switch {
8029 case data[p] < 71:
8030 switch {
8031 case data[p] < 48:
8032 if 32 <= data[p] && data[p] <= 46 {
8033 goto st55
8034 }
8035 case data[p] > 57:
8036 switch {
8037 case data[p] > 64:
8038 if 65 <= data[p] && data[p] <= 70 {
8039 goto tr253
8040 }
8041 case data[p] >= 58:
8042 goto st55
8043 }
8044 default:
8045 goto st158
8046 }
8047 case data[p] > 90:
8048 switch {
8049 case data[p] < 97:
8050 if 91 <= data[p] && data[p] <= 96 {
8051 goto st55
8052 }
8053 case data[p] > 102:
8054 switch {
8055 case data[p] > 122:
8056 if 123 <= data[p] && data[p] <= 126 {
8057 goto st55
8058 }
8059 case data[p] >= 103:
8060 goto tr72
8061 }
8062 default:
8063 goto tr253
8064 }
8065 default:
8066 goto tr72
8067 }
8068 goto st0
8069 tr253:
8070 //line parser.rl:13
8071
8072 if port_mark > host_mark {
8073 u.Port = data[port_mark:p]
8074 }
8075
8076 //line parser.rl:10
8077 mark = p
8078 goto st158
8079 st158:
8080 if p++; p == pe {
8081 goto _test_eof158
8082 }
8083 st_case_158:
8084 //line parser.go:8090
8085 switch data[p] {
8086 case 35:
8087 goto tr64
8088 case 37:
8089 goto st61
8090 case 46:
8091 goto st159
8092 case 47:
8093 goto tr66
8094 case 63:
8095 goto tr67
8096 case 92:
8097 goto tr77
8098 }
8099 switch {
8100 case data[p] < 71:
8101 switch {
8102 case data[p] < 48:
8103 if 32 <= data[p] && data[p] <= 45 {
8104 goto st56
8105 }
8106 case data[p] > 57:
8107 switch {
8108 case data[p] > 64:
8109 if 65 <= data[p] && data[p] <= 70 {
8110 goto tr213
8111 }
8112 case data[p] >= 58:
8113 goto st56
8114 }
8115 default:
8116 goto st134
8117 }
8118 case data[p] > 90:
8119 switch {
8120 case data[p] < 97:
8121 if 91 <= data[p] && data[p] <= 96 {
8122 goto st56
8123 }
8124 case data[p] > 102:
8125 switch {
8126 case data[p] > 122:
8127 if 123 <= data[p] && data[p] <= 126 {
8128 goto st56
8129 }
8130 case data[p] >= 103:
8131 goto tr76
8132 }
8133 default:
8134 goto tr213
8135 }
8136 default:
8137 goto tr76
8138 }
8139 goto st0
8140 st159:
8141 if p++; p == pe {
8142 goto _test_eof159
8143 }
8144 st_case_159:
8145 switch data[p] {
8146 case 33:
8147 goto st160
8148 case 35:
8149 goto tr64
8150 case 37:
8151 goto st58
8152 case 47:
8153 goto tr66
8154 case 60:
8155 goto st57
8156 case 63:
8157 goto tr67
8158 case 92:
8159 goto tr80
8160 case 95:
8161 goto st160
8162 case 126:
8163 goto st160
8164 }
8165 switch {
8166 case data[p] < 65:
8167 switch {
8168 case data[p] < 36:
8169 if 32 <= data[p] && data[p] <= 34 {
8170 goto st57
8171 }
8172 case data[p] > 61:
8173 if 62 <= data[p] && data[p] <= 64 {
8174 goto st57
8175 }
8176 default:
8177 goto st160
8178 }
8179 case data[p] > 90:
8180 switch {
8181 case data[p] < 97:
8182 if 91 <= data[p] && data[p] <= 96 {
8183 goto st57
8184 }
8185 case data[p] > 122:
8186 if 123 <= data[p] && data[p] <= 125 {
8187 goto st57
8188 }
8189 default:
8190 goto tr256
8191 }
8192 default:
8193 goto tr256
8194 }
8195 goto st0
8196 st160:
8197 if p++; p == pe {
8198 goto _test_eof160
8199 }
8200 st_case_160:
8201 switch data[p] {
8202 case 33:
8203 goto st31
8204 case 35:
8205 goto tr64
8206 case 36:
8207 goto st31
8208 case 47:
8209 goto tr66
8210 case 61:
8211 goto st31
8212 case 63:
8213 goto tr67
8214 case 92:
8215 goto tr66
8216 case 93:
8217 goto st85
8218 case 95:
8219 goto st31
8220 case 126:
8221 goto st31
8222 }
8223 switch {
8224 case data[p] < 65:
8225 if 38 <= data[p] && data[p] <= 59 {
8226 goto st31
8227 }
8228 case data[p] > 90:
8229 if 97 <= data[p] && data[p] <= 122 {
8230 goto tr215
8231 }
8232 default:
8233 goto tr215
8234 }
8235 goto st0
8236 tr256:
8237 //line parser.rl:13
8238
8239 if port_mark > host_mark {
8240 u.Port = data[port_mark:p]
8241 }
8242
8243 //line parser.rl:10
8244 mark = p
8245 goto st161
8246 st161:
8247 if p++; p == pe {
8248 goto _test_eof161
8249 }
8250 st_case_161:
8251 //line parser.go:8257
8252 switch data[p] {
8253 case 33:
8254 goto st31
8255 case 35:
8256 goto tr64
8257 case 36:
8258 goto st31
8259 case 47:
8260 goto tr66
8261 case 58:
8262 goto st44
8263 case 61:
8264 goto st31
8265 case 63:
8266 goto tr67
8267 case 92:
8268 goto tr66
8269 case 93:
8270 goto st85
8271 case 95:
8272 goto st31
8273 case 126:
8274 goto st31
8275 }
8276 switch {
8277 case data[p] < 65:
8278 if 38 <= data[p] && data[p] <= 59 {
8279 goto st31
8280 }
8281 case data[p] > 90:
8282 if 97 <= data[p] && data[p] <= 122 {
8283 goto tr215
8284 }
8285 default:
8286 goto tr215
8287 }
8288 goto st0
8289 st_out:
8290 _test_eof46:
8291 cs = 46
8292 goto _test_eof
8293 _test_eof47:
8294 cs = 47
8295 goto _test_eof
8296 _test_eof48:
8297 cs = 48
8298 goto _test_eof
8299 _test_eof1:
8300 cs = 1
8301 goto _test_eof
8302 _test_eof2:
8303 cs = 2
8304 goto _test_eof
8305 _test_eof49:
8306 cs = 49
8307 goto _test_eof
8308 _test_eof50:
8309 cs = 50
8310 goto _test_eof
8311 _test_eof51:
8312 cs = 51
8313 goto _test_eof
8314 _test_eof52:
8315 cs = 52
8316 goto _test_eof
8317 _test_eof3:
8318 cs = 3
8319 goto _test_eof
8320 _test_eof53:
8321 cs = 53
8322 goto _test_eof
8323 _test_eof54:
8324 cs = 54
8325 goto _test_eof
8326 _test_eof55:
8327 cs = 55
8328 goto _test_eof
8329 _test_eof56:
8330 cs = 56
8331 goto _test_eof
8332 _test_eof57:
8333 cs = 57
8334 goto _test_eof
8335 _test_eof4:
8336 cs = 4
8337 goto _test_eof
8338 _test_eof5:
8339 cs = 5
8340 goto _test_eof
8341 _test_eof58:
8342 cs = 58
8343 goto _test_eof
8344 _test_eof6:
8345 cs = 6
8346 goto _test_eof
8347 _test_eof7:
8348 cs = 7
8349 goto _test_eof
8350 _test_eof59:
8351 cs = 59
8352 goto _test_eof
8353 _test_eof60:
8354 cs = 60
8355 goto _test_eof
8356 _test_eof61:
8357 cs = 61
8358 goto _test_eof
8359 _test_eof62:
8360 cs = 62
8361 goto _test_eof
8362 _test_eof63:
8363 cs = 63
8364 goto _test_eof
8365 _test_eof64:
8366 cs = 64
8367 goto _test_eof
8368 _test_eof65:
8369 cs = 65
8370 goto _test_eof
8371 _test_eof66:
8372 cs = 66
8373 goto _test_eof
8374 _test_eof67:
8375 cs = 67
8376 goto _test_eof
8377 _test_eof68:
8378 cs = 68
8379 goto _test_eof
8380 _test_eof69:
8381 cs = 69
8382 goto _test_eof
8383 _test_eof70:
8384 cs = 70
8385 goto _test_eof
8386 _test_eof71:
8387 cs = 71
8388 goto _test_eof
8389 _test_eof72:
8390 cs = 72
8391 goto _test_eof
8392 _test_eof73:
8393 cs = 73
8394 goto _test_eof
8395 _test_eof74:
8396 cs = 74
8397 goto _test_eof
8398 _test_eof75:
8399 cs = 75
8400 goto _test_eof
8401 _test_eof76:
8402 cs = 76
8403 goto _test_eof
8404 _test_eof77:
8405 cs = 77
8406 goto _test_eof
8407 _test_eof78:
8408 cs = 78
8409 goto _test_eof
8410 _test_eof79:
8411 cs = 79
8412 goto _test_eof
8413 _test_eof80:
8414 cs = 80
8415 goto _test_eof
8416 _test_eof81:
8417 cs = 81
8418 goto _test_eof
8419 _test_eof82:
8420 cs = 82
8421 goto _test_eof
8422 _test_eof83:
8423 cs = 83
8424 goto _test_eof
8425 _test_eof84:
8426 cs = 84
8427 goto _test_eof
8428 _test_eof8:
8429 cs = 8
8430 goto _test_eof
8431 _test_eof9:
8432 cs = 9
8433 goto _test_eof
8434 _test_eof10:
8435 cs = 10
8436 goto _test_eof
8437 _test_eof11:
8438 cs = 11
8439 goto _test_eof
8440 _test_eof12:
8441 cs = 12
8442 goto _test_eof
8443 _test_eof13:
8444 cs = 13
8445 goto _test_eof
8446 _test_eof14:
8447 cs = 14
8448 goto _test_eof
8449 _test_eof15:
8450 cs = 15
8451 goto _test_eof
8452 _test_eof16:
8453 cs = 16
8454 goto _test_eof
8455 _test_eof17:
8456 cs = 17
8457 goto _test_eof
8458 _test_eof18:
8459 cs = 18
8460 goto _test_eof
8461 _test_eof19:
8462 cs = 19
8463 goto _test_eof
8464 _test_eof20:
8465 cs = 20
8466 goto _test_eof
8467 _test_eof21:
8468 cs = 21
8469 goto _test_eof
8470 _test_eof22:
8471 cs = 22
8472 goto _test_eof
8473 _test_eof85:
8474 cs = 85
8475 goto _test_eof
8476 _test_eof23:
8477 cs = 23
8478 goto _test_eof
8479 _test_eof86:
8480 cs = 86
8481 goto _test_eof
8482 _test_eof87:
8483 cs = 87
8484 goto _test_eof
8485 _test_eof24:
8486 cs = 24
8487 goto _test_eof
8488 _test_eof25:
8489 cs = 25
8490 goto _test_eof
8491 _test_eof26:
8492 cs = 26
8493 goto _test_eof
8494 _test_eof27:
8495 cs = 27
8496 goto _test_eof
8497 _test_eof28:
8498 cs = 28
8499 goto _test_eof
8500 _test_eof29:
8501 cs = 29
8502 goto _test_eof
8503 _test_eof30:
8504 cs = 30
8505 goto _test_eof
8506 _test_eof31:
8507 cs = 31
8508 goto _test_eof
8509 _test_eof32:
8510 cs = 32
8511 goto _test_eof
8512 _test_eof33:
8513 cs = 33
8514 goto _test_eof
8515 _test_eof88:
8516 cs = 88
8517 goto _test_eof
8518 _test_eof34:
8519 cs = 34
8520 goto _test_eof
8521 _test_eof35:
8522 cs = 35
8523 goto _test_eof
8524 _test_eof89:
8525 cs = 89
8526 goto _test_eof
8527 _test_eof90:
8528 cs = 90
8529 goto _test_eof
8530 _test_eof36:
8531 cs = 36
8532 goto _test_eof
8533 _test_eof91:
8534 cs = 91
8535 goto _test_eof
8536 _test_eof92:
8537 cs = 92
8538 goto _test_eof
8539 _test_eof93:
8540 cs = 93
8541 goto _test_eof
8542 _test_eof94:
8543 cs = 94
8544 goto _test_eof
8545 _test_eof95:
8546 cs = 95
8547 goto _test_eof
8548 _test_eof96:
8549 cs = 96
8550 goto _test_eof
8551 _test_eof97:
8552 cs = 97
8553 goto _test_eof
8554 _test_eof98:
8555 cs = 98
8556 goto _test_eof
8557 _test_eof37:
8558 cs = 37
8559 goto _test_eof
8560 _test_eof38:
8561 cs = 38
8562 goto _test_eof
8563 _test_eof99:
8564 cs = 99
8565 goto _test_eof
8566 _test_eof100:
8567 cs = 100
8568 goto _test_eof
8569 _test_eof101:
8570 cs = 101
8571 goto _test_eof
8572 _test_eof102:
8573 cs = 102
8574 goto _test_eof
8575 _test_eof103:
8576 cs = 103
8577 goto _test_eof
8578 _test_eof104:
8579 cs = 104
8580 goto _test_eof
8581 _test_eof105:
8582 cs = 105
8583 goto _test_eof
8584 _test_eof106:
8585 cs = 106
8586 goto _test_eof
8587 _test_eof107:
8588 cs = 107
8589 goto _test_eof
8590 _test_eof108:
8591 cs = 108
8592 goto _test_eof
8593 _test_eof109:
8594 cs = 109
8595 goto _test_eof
8596 _test_eof39:
8597 cs = 39
8598 goto _test_eof
8599 _test_eof40:
8600 cs = 40
8601 goto _test_eof
8602 _test_eof41:
8603 cs = 41
8604 goto _test_eof
8605 _test_eof110:
8606 cs = 110
8607 goto _test_eof
8608 _test_eof111:
8609 cs = 111
8610 goto _test_eof
8611 _test_eof112:
8612 cs = 112
8613 goto _test_eof
8614 _test_eof113:
8615 cs = 113
8616 goto _test_eof
8617 _test_eof114:
8618 cs = 114
8619 goto _test_eof
8620 _test_eof115:
8621 cs = 115
8622 goto _test_eof
8623 _test_eof116:
8624 cs = 116
8625 goto _test_eof
8626 _test_eof42:
8627 cs = 42
8628 goto _test_eof
8629 _test_eof117:
8630 cs = 117
8631 goto _test_eof
8632 _test_eof118:
8633 cs = 118
8634 goto _test_eof
8635 _test_eof119:
8636 cs = 119
8637 goto _test_eof
8638 _test_eof120:
8639 cs = 120
8640 goto _test_eof
8641 _test_eof121:
8642 cs = 121
8643 goto _test_eof
8644 _test_eof122:
8645 cs = 122
8646 goto _test_eof
8647 _test_eof123:
8648 cs = 123
8649 goto _test_eof
8650 _test_eof124:
8651 cs = 124
8652 goto _test_eof
8653 _test_eof125:
8654 cs = 125
8655 goto _test_eof
8656 _test_eof126:
8657 cs = 126
8658 goto _test_eof
8659 _test_eof127:
8660 cs = 127
8661 goto _test_eof
8662 _test_eof128:
8663 cs = 128
8664 goto _test_eof
8665 _test_eof129:
8666 cs = 129
8667 goto _test_eof
8668 _test_eof130:
8669 cs = 130
8670 goto _test_eof
8671 _test_eof131:
8672 cs = 131
8673 goto _test_eof
8674 _test_eof132:
8675 cs = 132
8676 goto _test_eof
8677 _test_eof133:
8678 cs = 133
8679 goto _test_eof
8680 _test_eof134:
8681 cs = 134
8682 goto _test_eof
8683 _test_eof135:
8684 cs = 135
8685 goto _test_eof
8686 _test_eof43:
8687 cs = 43
8688 goto _test_eof
8689 _test_eof44:
8690 cs = 44
8691 goto _test_eof
8692 _test_eof136:
8693 cs = 136
8694 goto _test_eof
8695 _test_eof137:
8696 cs = 137
8697 goto _test_eof
8698 _test_eof138:
8699 cs = 138
8700 goto _test_eof
8701 _test_eof139:
8702 cs = 139
8703 goto _test_eof
8704 _test_eof140:
8705 cs = 140
8706 goto _test_eof
8707 _test_eof141:
8708 cs = 141
8709 goto _test_eof
8710 _test_eof142:
8711 cs = 142
8712 goto _test_eof
8713 _test_eof143:
8714 cs = 143
8715 goto _test_eof
8716 _test_eof144:
8717 cs = 144
8718 goto _test_eof
8719 _test_eof145:
8720 cs = 145
8721 goto _test_eof
8722 _test_eof146:
8723 cs = 146
8724 goto _test_eof
8725 _test_eof147:
8726 cs = 147
8727 goto _test_eof
8728 _test_eof148:
8729 cs = 148
8730 goto _test_eof
8731 _test_eof149:
8732 cs = 149
8733 goto _test_eof
8734 _test_eof150:
8735 cs = 150
8736 goto _test_eof
8737 _test_eof151:
8738 cs = 151
8739 goto _test_eof
8740 _test_eof152:
8741 cs = 152
8742 goto _test_eof
8743 _test_eof153:
8744 cs = 153
8745 goto _test_eof
8746 _test_eof154:
8747 cs = 154
8748 goto _test_eof
8749 _test_eof155:
8750 cs = 155
8751 goto _test_eof
8752 _test_eof156:
8753 cs = 156
8754 goto _test_eof
8755 _test_eof157:
8756 cs = 157
8757 goto _test_eof
8758 _test_eof158:
8759 cs = 158
8760 goto _test_eof
8761 _test_eof159:
8762 cs = 159
8763 goto _test_eof
8764 _test_eof160:
8765 cs = 160
8766 goto _test_eof
8767 _test_eof161:
8768 cs = 161
8769 goto _test_eof
8770
8771 _test_eof:
8772 {
8773 }
8774 if p == eof {
8775 switch cs {
8776 case 53, 54, 55, 56, 57, 58, 59, 61, 62, 63, 68, 69, 74, 75, 80, 81, 82, 83, 84, 86, 87, 88, 89, 91, 92, 93, 98, 99, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 124, 125, 126, 127, 128, 129, 130, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 149, 150, 151, 152, 153, 154, 155, 157, 158, 159, 160, 161:
8777 //line parser.rl:13
8778
8779 if port_mark > host_mark {
8780 u.Port = data[port_mark:p]
8781 }
8782
8783 case 147:
8784 //line parser.rl:19
8785
8786 u.Protocol = data[0 : p-1]
8787
8788 case 46, 85, 90, 146:
8789 //line parser.rl:27
8790
8791 u.Host = data[host_mark:p]
8792
8793 case 52:
8794 //line parser.rl:31
8795
8796 if u.Query == "" {
8797 u.Query = data[mark:p]
8798 }
8799
8800 case 49, 50, 67, 144:
8801 //line parser.rl:37
8802
8803 if u.Path == "" {
8804 u.Path = data[mark:p]
8805 }
8806
8807 case 48:
8808 //line parser.rl:43
8809
8810 u.Fragment = data[mark:p]
8811
8812 case 51:
8813 //line parser.rl:10
8814 mark = p
8815 //line parser.rl:31
8816
8817 if u.Query == "" {
8818 u.Query = data[mark:p]
8819 }
8820
8821 case 47:
8822 //line parser.rl:10
8823 mark = p
8824 //line parser.rl:43
8825
8826 u.Fragment = data[mark:p]
8827
8828 case 60, 64, 65, 66, 70, 71, 72, 73, 76, 77, 78, 79, 100, 101, 102, 103:
8829 //line parser.rl:13
8830
8831 if port_mark > host_mark {
8832 u.Port = data[port_mark:p]
8833 }
8834
8835 //line parser.rl:37
8836
8837 if u.Path == "" {
8838 u.Path = data[mark:p]
8839 }
8840
8841 case 94, 95, 96, 97, 104, 123, 131, 148, 156:
8842 //line parser.rl:27
8843
8844 u.Host = data[host_mark:p]
8845
8846 //line parser.rl:13
8847
8848 if port_mark > host_mark {
8849 u.Port = data[port_mark:p]
8850 }
8851
8852 //line parser.go:8536
8853 }
8854 }
8855
8856 _out:
8857 {
8858 }
8859 }
8860
8861 //line parser.rl:116
8862 if cs < url_parser_first_final {
8863 return nil, fmt.Errorf("Failed to match URL")
8864 } else {
8865 return u, nil
8866 }
8867 }
8868