Grammar that runs too slowly when converted to Perl6. See https://github.com/drforr/perl6-ANTLR4/issues/16

example.go

package main;

import "fmt";


func generate(ch chan<- int) {
	for i := 2; ; i++ {
		ch <- i;
	};
};



func filter(src <-chan int, dst chan<- int, prime int) {
	for i := range src {
		if i%prime != 0 {
			dst <- i;
		};
	};
};


func sieve() {
	ch := make(chan int);
	go generate(ch);
	for {
		prime := <-ch;
		fmt.Print(prime, "\n");
		ch1 := make(chan int);
		go filter(ch, ch1, prime);
		ch = ch1;
	};
};

func main() {
	sieve();
};

GoParser.g4

grammar GoParser;

sourceFile
    : packageClause eos (importDecl eos)* ((functionDecl | methodDecl | declaration) eos)*
    ;

packageClause
    : 'package' IDENTIFIER
    ;

importDecl
    : 'import' (importSpec | '(' (importSpec eos)* ')')
    ;

importSpec
    : ('.' | IDENTIFIER)? importPath
    ;

importPath
    : string_
    ;

declaration
    : constDecl
    | typeDecl
    | varDecl
    ;

constDecl
    : 'const' (constSpec | '(' (constSpec eos)* ')')
    ;

constSpec
    : identifierList (type_? '=' expressionList)?
    ;

identifierList
    : IDENTIFIER (',' IDENTIFIER)*
    ;

expressionList
    : expression (',' expression)*
    ;

typeDecl
    : 'type' (typeSpec | '(' (typeSpec eos)* ')')
    ;

typeSpec
    : IDENTIFIER ASSIGN? type_
    ;

// Function declarations

functionDecl
    : 'func' IDENTIFIER (signature block?)
    ;

methodDecl
    : 'func' receiver IDENTIFIER (signature block?)
    ;

receiver
    : parameters
    ;

varDecl
    : 'var' (varSpec | '(' (varSpec eos)* ')')
    ;

varSpec
    : identifierList (type_ ('=' expressionList)? | '=' expressionList)
    ;

block
    : '{' statementList? '}'
    ;

statementList
    : (statement eos)+
    ;

statement
    : declaration
    | labeledStmt
    | simpleStmt
    | goStmt
    | returnStmt
    | breakStmt
    | continueStmt
    | gotoStmt
    | fallthroughStmt
    | block
    | ifStmt
    | switchStmt
    | selectStmt
    | forStmt
    | deferStmt
    ;

simpleStmt
    : sendStmt
    | expressionStmt
    | incDecStmt
    | assignment
    | shortVarDecl
    | emptyStmt
    ;

expressionStmt
    : expression
    ;

sendStmt
    : expression '<-' expression
    ;

incDecStmt
    : expression (PLUS_PLUS | MINUS_MINUS)
    ;

assignment
    : expressionList assign_op expressionList
    ;

assign_op
    : ('+' | '-' | '|' | '^' | '*' | '/' | '%' | '<<' | '>>' | '&' | '&^')? '='
    ;

shortVarDecl
    : identifierList ':=' expressionList
    ;

emptyStmt
    : ';'
    ;

labeledStmt
    : IDENTIFIER ':' statement
    ;

returnStmt
    : 'return' expressionList?
    ;

breakStmt
    : 'break' IDENTIFIER?
    ;

continueStmt
    : 'continue' IDENTIFIER?
    ;

gotoStmt
    : 'goto' IDENTIFIER
    ;

fallthroughStmt
    : 'fallthrough'
    ;

deferStmt
    : 'defer' expression
    ;

ifStmt
    : 'if' (simpleStmt ';')? expression block ('else' (ifStmt | block))?
    ;

switchStmt
    : exprSwitchStmt
    | typeSwitchStmt
    ;

exprSwitchStmt
    : 'switch' (simpleStmt ';')? expression? '{' exprCaseClause* '}'
    ;

exprCaseClause
    : exprSwitchCase ':' statementList?
    ;

exprSwitchCase
    : 'case' expressionList
    | 'default'
    ;

typeSwitchStmt
    : 'switch' (simpleStmt ';')? typeSwitchGuard '{' typeCaseClause* '}'
    ;

typeSwitchGuard
    : (IDENTIFIER ':=')? primaryExpr '.' '(' 'type' ')'
    ;

typeCaseClause
    : typeSwitchCase ':' statementList?
    ;

typeSwitchCase
    : 'case' typeList
    | 'default'
    ;

typeList
    : (type_ | NIL_LIT) (',' (type_ | NIL_LIT))*
    ;

selectStmt
    : 'select' '{' commClause* '}'
    ;

commClause
    : commCase ':' statementList?
    ;

commCase
    : 'case' (sendStmt | recvStmt)
    | 'default'
    ;

recvStmt
    : (expressionList '=' | identifierList ':=')? expression
    ;

forStmt
    : 'for' (expression | forClause | rangeClause)? block
    ;

forClause
    : simpleStmt? ';' expression? ';' simpleStmt?
    ;

rangeClause
    : (expressionList '=' | identifierList ':=')? 'range' expression
    ;

goStmt
    : 'go' expression
    ;

type_
    : typeName
    | typeLit
    | '(' type_ ')'
    ;

typeName
    : IDENTIFIER
    | qualifiedIdent
    ;

typeLit
    : arrayType
    | structType
    | pointerType
    | functionType
    | interfaceType
    | sliceType
    | mapType
    | channelType
    ;

arrayType
    : '[' arrayLength ']' elementType
    ;

arrayLength
    : expression
    ;

elementType
    : type_
    ;

pointerType
    : '*' type_
    ;

interfaceType
    : 'interface' '{' (methodSpec eos)* '}'
    ;

sliceType
    : '[' ']' elementType
    ;

// It's possible to replace `type` with more restricted typeLit list and also pay attention to nil maps
mapType
    : 'map' '[' type_ ']' elementType
    ;

channelType
    : ('chan' | 'chan' '<-' | '<-' 'chan') elementType
    ;

methodSpec
    : IDENTIFIER parameters result
    | typeName
    | IDENTIFIER parameters
    ;

functionType
    : 'func' signature
    ;

signature
    : parameters result
    | parameters
    ;

result
    : parameters
    | type_
    ;

parameters
    : '(' (parameterDecl (COMMA parameterDecl)* COMMA?)? ')'
    ;

parameterDecl
    : identifierList? '...'? type_
    ;

expression
    : primaryExpr
    | unaryExpr
    | expression ('*' | '/' | '%' | '<<' | '>>' | '&' | '&^') expression
    | expression ('+' | '-' | '|' | '^') expression
    | expression ('==' | '!=' | '<' | '<=' | '>' | '>=') expression
    | expression '&&' expression
    | expression '||' expression
    ;

primaryExpr
    : operand
    | conversion
    | primaryExpr ( DOT IDENTIFIER
                  | index
                  | slice
                  | typeAssertion
                  | arguments)
    ;

unaryExpr
    : primaryExpr
    | ('+' | '-' | '!' | '^' | '*' | '&' | '<-') expression
    ;

conversion
    : type_ '(' expression ','? ')'
    ;

operand
    : literal
    | operandName
    | methodExpr
    | '(' expression ')'
    ;

literal
    : basicLit
    | compositeLit
    | functionLit
    ;

basicLit
    : NIL_LIT
    | integer
    | string_
    | FLOAT_LIT
    | IMAGINARY_LIT
    | RUNE_LIT
    ;

integer
    : DECIMAL_LIT
    | OCTAL_LIT
    | HEX_LIT
    | IMAGINARY_LIT
    | RUNE_LIT
    ;

operandName
    : IDENTIFIER
    | qualifiedIdent
    ;

qualifiedIdent
    : IDENTIFIER '.' IDENTIFIER
    ;

compositeLit
    : literalType literalValue
    ;

literalType
    : structType
    | arrayType
    | '[' '...' ']' elementType
    | sliceType
    | mapType
    | typeName
    ;

literalValue
    : '{' (elementList ','?)? '}'
    ;

elementList
    : keyedElement (',' keyedElement)*
    ;

keyedElement
    : (key ':')? element
    ;

key
    : IDENTIFIER
    | expression
    | literalValue
    ;

element
    : expression
    | literalValue
    ;

structType
    : 'struct' '{' (fieldDecl eos)* '}'
    ;

fieldDecl
    : (identifierList type_ | anonymousField) string_?
    ;

string_
    : RAW_STRING_LIT
    | INTERPRETED_STRING_LIT
    ;

anonymousField
    : '*'? typeName
    ;

functionLit
    : 'func' signature block // function
    ;

index
    : '[' expression ']'
    ;

slice
    : '[' (expression? ':' expression? | expression? ':' expression ':' expression) ']'
    ;

typeAssertion
    : '.' '(' type_ ')'
    ;

arguments
    : '(' ((expressionList | type_ (',' expressionList)?) '...'? ','?)? ')'
    ;

methodExpr
    : receiverType DOT IDENTIFIER
    ;

receiverType
    : typeName
    | '(' ('*' typeName | receiverType) ')'
    ;

eos
    : ';'
    | EOF
    ;

BREAK                  : 'break';
DEFAULT                : 'default';
FUNC                   : 'func';
INTERFACE              : 'interface';
SELECT                 : 'select';
CASE                   : 'case';
DEFER                  : 'defer';
GO                     : 'go';
MAP                    : 'map';
STRUCT                 : 'struct';
CHAN                   : 'chan';
ELSE                   : 'else';
GOTO                   : 'goto';
PACKAGE                : 'package';
SWITCH                 : 'switch';
CONST                  : 'const';
FALLTHROUGH            : 'fallthrough';
IF                     : 'if';
RANGE                  : 'range';
TYPE                   : 'type';
CONTINUE               : 'continue';
FOR                    : 'for';
IMPORT                 : 'import';
RETURN                 : 'return';
VAR                    : 'var';

NIL_LIT                : 'nil';

IDENTIFIER             : LETTER (LETTER | UNICODE_DIGIT)*;

L_PAREN                : '(';
R_PAREN                : ')';
L_CURLY                : '{';
R_CURLY                : '}';
L_BRACKET              : '[';
R_BRACKET              : ']';
ASSIGN                 : '=';
COMMA                  : ',';
SEMI                   : ';';
COLON                  : ':';
DOT                    : '.';
PLUS_PLUS              : '++';
MINUS_MINUS            : '--';
DECLARE_ASSIGN         : ':=';
ELLIPSIS               : '...';

LOGICAL_OR             : '||';
LOGICAL_AND            : '&&';

EQUALS                 : '==';
NOT_EQUALS             : '!=';
LESS                   : '<';
LESS_OR_EQUALS         : '<=';
GREATER                : '>';
GREATER_OR_EQUALS      : '>=';

OR                     : '|';
DIV                    : '/';
MOD                    : '%';
LSHIFT                 : '<<';
RSHIFT                 : '>>';
BIT_CLEAR              : '&^';

EXCLAMATION            : '!';

PLUS                   : '+';
MINUS                  : '-';
CARET                  : '^';
STAR                   : '*';
AMPERSAND              : '&';
RECEIVE                : '<-';

DECIMAL_LIT            : [1-9] [0-9]*;
OCTAL_LIT              : '0' OCTAL_DIGIT*;
HEX_LIT                : '0' [xX] HEX_DIGIT+;

FLOAT_LIT              : DECIMALS ('.' DECIMALS? EXPONENT? | EXPONENT)
                       | '.' DECIMALS EXPONENT?
                       ;

IMAGINARY_LIT          : (DECIMALS | FLOAT_LIT) 'i';

RUNE_LIT               : '\'' (~[\n\\] | ESCAPED_VALUE) '\'';

RAW_STRING_LIT         : '`' ~'`'*                      '`';
INTERPRETED_STRING_LIT : '"' (~["\\] | ESCAPED_VALUE)*  '"';

WS                     : [ \t]+             -> channel(HIDDEN);
COMMENT                : '/*' .*? '*/'      -> channel(HIDDEN);
TERMINATOR             : [\r\n]+            -> channel(HIDDEN);
LINE_COMMENT           : '//' ~[\r\n]*      -> channel(HIDDEN);

fragment ESCAPED_VALUE
    : '\\' ('u' HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT
           | 'U' HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT
           | [abfnrtv\\'"]
           | OCTAL_DIGIT OCTAL_DIGIT OCTAL_DIGIT
           | 'x' HEX_DIGIT HEX_DIGIT)
    ;

fragment DECIMALS
    : [0-9]+
    ;

fragment OCTAL_DIGIT
    : [0-7]
    ;

fragment HEX_DIGIT
    : [0-9a-fA-F]
    ;

fragment EXPONENT
    : [eE] [+-]? DECIMALS
    ;

fragment LETTER
    : UNICODE_LETTER
    | '_'
    ;

fragment UNICODE_DIGIT
    : [\u0030-\u0039]
    | [\u0660-\u0669]
    | [\u06F0-\u06F9]
    | [\u0966-\u096F]
    | [\u09E6-\u09EF]
    | [\u0A66-\u0A6F]
    | [\u0AE6-\u0AEF]
    | [\u0B66-\u0B6F]
    | [\u0BE7-\u0BEF]
    | [\u0C66-\u0C6F]
    | [\u0CE6-\u0CEF]
    | [\u0D66-\u0D6F]
    | [\u0E50-\u0E59]
    | [\u0ED0-\u0ED9]
    | [\u0F20-\u0F29]
    | [\u1040-\u1049]
    | [\u1369-\u1371]
    | [\u17E0-\u17E9]
    | [\u1810-\u1819]
    | [\uFF10-\uFF19]
    ;

fragment UNICODE_LETTER
    : [\u0041-\u005A]
    | [\u0061-\u007A]
    | [\u00AA]
    | [\u00B5]
    | [\u00BA]
    | [\u00C0-\u00D6]
    | [\u00D8-\u00F6]
    | [\u00F8-\u021F]
    | [\u0222-\u0233]
    | [\u0250-\u02AD]
    | [\u02B0-\u02B8]
    | [\u02BB-\u02C1]
    | [\u02D0-\u02D1]
    | [\u02E0-\u02E4]
    | [\u02EE]
    | [\u037A]
    | [\u0386]
    | [\u0388-\u038A]
    | [\u038C]
    | [\u038E-\u03A1]
    | [\u03A3-\u03CE]
    | [\u03D0-\u03D7]
    | [\u03DA-\u03F3]
    | [\u0400-\u0481]
    | [\u048C-\u04C4]
    | [\u04C7-\u04C8]
    | [\u04CB-\u04CC]
    | [\u04D0-\u04F5]
    | [\u04F8-\u04F9]
    | [\u0531-\u0556]
    | [\u0559]
    | [\u0561-\u0587]
    | [\u05D0-\u05EA]
    | [\u05F0-\u05F2]
    | [\u0621-\u063A]
    | [\u0640-\u064A]
    | [\u0671-\u06D3]
    | [\u06D5]
    | [\u06E5-\u06E6]
    | [\u06FA-\u06FC]
    | [\u0710]
    | [\u0712-\u072C]
    | [\u0780-\u07A5]
    | [\u0905-\u0939]
    | [\u093D]
    | [\u0950]
    | [\u0958-\u0961]
    | [\u0985-\u098C]
    | [\u098F-\u0990]
    | [\u0993-\u09A8]
    | [\u09AA-\u09B0]
    | [\u09B2]
    | [\u09B6-\u09B9]
    | [\u09DC-\u09DD]
    | [\u09DF-\u09E1]
    | [\u09F0-\u09F1]
    | [\u0A05-\u0A0A]
    | [\u0A0F-\u0A10]
    | [\u0A13-\u0A28]
    | [\u0A2A-\u0A30]
    | [\u0A32-\u0A33]
    | [\u0A35-\u0A36]
    | [\u0A38-\u0A39]
    | [\u0A59-\u0A5C]
    | [\u0A5E]
    | [\u0A72-\u0A74]
    | [\u0A85-\u0A8B]
    | [\u0A8D]
    | [\u0A8F-\u0A91]
    | [\u0A93-\u0AA8]
    | [\u0AAA-\u0AB0]
    | [\u0AB2-\u0AB3]
    | [\u0AB5-\u0AB9]
    | [\u0ABD]
    | [\u0AD0]
    | [\u0AE0]
    | [\u0B05-\u0B0C]
    | [\u0B0F-\u0B10]
    | [\u0B13-\u0B28]
    | [\u0B2A-\u0B30]
    | [\u0B32-\u0B33]
    | [\u0B36-\u0B39]
    | [\u0B3D]
    | [\u0B5C-\u0B5D]
    | [\u0B5F-\u0B61]
    | [\u0B85-\u0B8A]
    | [\u0B8E-\u0B90]
    | [\u0B92-\u0B95]
    | [\u0B99-\u0B9A]
    | [\u0B9C]
    | [\u0B9E-\u0B9F]
    | [\u0BA3-\u0BA4]
    | [\u0BA8-\u0BAA]
    | [\u0BAE-\u0BB5]
    | [\u0BB7-\u0BB9]
    | [\u0C05-\u0C0C]
    | [\u0C0E-\u0C10]
    | [\u0C12-\u0C28]
    | [\u0C2A-\u0C33]
    | [\u0C35-\u0C39]
    | [\u0C60-\u0C61]
    | [\u0C85-\u0C8C]
    | [\u0C8E-\u0C90]
    | [\u0C92-\u0CA8]
    | [\u0CAA-\u0CB3]
    | [\u0CB5-\u0CB9]
    | [\u0CDE]
    | [\u0CE0-\u0CE1]
    | [\u0D05-\u0D0C]
    | [\u0D0E-\u0D10]
    | [\u0D12-\u0D28]
    | [\u0D2A-\u0D39]
    | [\u0D60-\u0D61]
    | [\u0D85-\u0D96]
    | [\u0D9A-\u0DB1]
    | [\u0DB3-\u0DBB]
    | [\u0DBD]
    | [\u0DC0-\u0DC6]
    | [\u0E01-\u0E30]
    | [\u0E32-\u0E33]
    | [\u0E40-\u0E46]
    | [\u0E81-\u0E82]
    | [\u0E84]
    | [\u0E87-\u0E88]
    | [\u0E8A]
    | [\u0E8D]
    | [\u0E94-\u0E97]
    | [\u0E99-\u0E9F]
    | [\u0EA1-\u0EA3]
    | [\u0EA5]
    | [\u0EA7]
    | [\u0EAA-\u0EAB]
    | [\u0EAD-\u0EB0]
    | [\u0EB2-\u0EB3]
    | [\u0EBD-\u0EC4]
    | [\u0EC6]
    | [\u0EDC-\u0EDD]
    | [\u0F00]
    | [\u0F40-\u0F6A]
    | [\u0F88-\u0F8B]
    | [\u1000-\u1021]
    | [\u1023-\u1027]
    | [\u1029-\u102A]
    | [\u1050-\u1055]
    | [\u10A0-\u10C5]
    | [\u10D0-\u10F6]
    | [\u1100-\u1159]
    | [\u115F-\u11A2]
    | [\u11A8-\u11F9]
    | [\u1200-\u1206]
    | [\u1208-\u1246]
    | [\u1248]
    | [\u124A-\u124D]
    | [\u1250-\u1256]
    | [\u1258]
    | [\u125A-\u125D]
    | [\u1260-\u1286]
    | [\u1288]
    | [\u128A-\u128D]
    | [\u1290-\u12AE]
    | [\u12B0]
    | [\u12B2-\u12B5]
    | [\u12B8-\u12BE]
    | [\u12C0]
    | [\u12C2-\u12C5]
    | [\u12C8-\u12CE]
    | [\u12D0-\u12D6]
    | [\u12D8-\u12EE]
    | [\u12F0-\u130E]
    | [\u1310]
    | [\u1312-\u1315]
    | [\u1318-\u131E]
    | [\u1320-\u1346]
    | [\u1348-\u135A]
    | [\u13A0-\u13B0]
    | [\u13B1-\u13F4]
    | [\u1401-\u1676]
    | [\u1681-\u169A]
    | [\u16A0-\u16EA]
    | [\u1780-\u17B3]
    | [\u1820-\u1877]
    | [\u1880-\u18A8]
    | [\u1E00-\u1E9B]
    | [\u1EA0-\u1EE0]
    | [\u1EE1-\u1EF9]
    | [\u1F00-\u1F15]
    | [\u1F18-\u1F1D]
    | [\u1F20-\u1F39]
    | [\u1F3A-\u1F45]
    | [\u1F48-\u1F4D]
    | [\u1F50-\u1F57]
    | [\u1F59]
    | [\u1F5B]
    | [\u1F5D]
    | [\u1F5F-\u1F7D]
    | [\u1F80-\u1FB4]
    | [\u1FB6-\u1FBC]
    | [\u1FBE]
    | [\u1FC2-\u1FC4]
    | [\u1FC6-\u1FCC]
    | [\u1FD0-\u1FD3]
    | [\u1FD6-\u1FDB]
    | [\u1FE0-\u1FEC]
    | [\u1FF2-\u1FF4]
    | [\u1FF6-\u1FFC]
    | [\u207F]
    | [\u2102]
    | [\u2107]
    | [\u210A-\u2113]
    | [\u2115]
    | [\u2119-\u211D]
    | [\u2124]
    | [\u2126]
    | [\u2128]
    | [\u212A-\u212D]
    | [\u212F-\u2131]
    | [\u2133-\u2139]
    | [\u2160-\u2183]
    | [\u3005-\u3007]
    | [\u3021-\u3029]
    | [\u3031-\u3035]
    | [\u3038-\u303A]
    | [\u3041-\u3094]
    | [\u309D-\u309E]
    | [\u30A1-\u30FA]
    | [\u30FC-\u30FE]
    | [\u3105-\u312C]
    | [\u3131-\u318E]
    | [\u31A0-\u31B7]
    | [\u3400]
    | [\u4DB5]
    | [\u4E00]
    | [\u9FA5]
    | [\uA000-\uA48C]
    | [\uAC00]
    | [\uD7A3]
    | [\uF900-\uFA2D]
    | [\uFB00-\uFB06]
    | [\uFB13-\uFB17]
    | [\uFB1D]
    | [\uFB1F-\uFB28]
    | [\uFB2A-\uFB36]
    | [\uFB38-\uFB3C]
    | [\uFB3E]
    | [\uFB40-\uFB41]
    | [\uFB43-\uFB44]
    | [\uFB46-\uFBB1]
    | [\uFBD3-\uFD3D]
    | [\uFD50-\uFD8F]
    | [\uFD92-\uFDC7]
    | [\uFDF0-\uFDFB]
    | [\uFE70-\uFE72]
    | [\uFE74]
    | [\uFE76-\uFEFC]
    | [\uFF21-\uFF3A]
    | [\uFF41-\uFF5A]
    | [\uFF66-\uFFBE]
    | [\uFFC2-\uFFC7]
    | [\uFFCA-\uFFCF]
    | [\uFFD2-\uFFD7]
    | [\uFFDA-\uFFDC]
    ;

GoParser.pl6

# auto-converted
grammar GoParser {
	token sourceFile {
		||	<packageClause>
			<eos>
			(	||	<importDecl>
					<eos>
			)*
			(	||	(	||	<functionDecl>
						||	<methodDecl>
						||	<declaration>
					)
					<eos>
			)*
	}
	token packageClause {
		||	'package'
			<IDENTIFIER>
	}
	token importDecl {
		||	'import'
			(	||	<importSpec>
				||	'('
					(	||	<importSpec>
							<eos>
					)*
					')'
			)
	}
	token importSpec {
		||	(	||	'.'
				||	<IDENTIFIER>
			)?
			<importPath>
	}
	token importPath {
		||	<string_>
	}
	token declaration {
		||	<constDecl>
		||	<typeDecl>
		||	<varDecl>
	}
	token constDecl {
		||	'const'
			(	||	<constSpec>
				||	'('
					(	||	<constSpec>
							<eos>
					)*
					')'
			)
	}
	token constSpec {
		||	<identifierList>
			(	||	<type_>?
					'='
					<expressionList>
			)?
	}
	token identifierList {
		||	<IDENTIFIER>
			(	||	','
					<IDENTIFIER>
			)*
	}
	token expressionList {
		||	<expression>
			(	||	','
					<expression>
			)*
	}
	token typeDecl {
		||	'type'
			(	||	<typeSpec>
				||	'('
					(	||	<typeSpec>
							<eos>
					)*
					')'
			)
	}
	token typeSpec {
		||	<IDENTIFIER>
			<ASSIGN>?
			<type_>
	}
	token functionDecl {
		||	'func'
			<IDENTIFIER>
			(	||	<signature>
					<block>?
			)
	}
	token methodDecl {
		||	'func'
			<receiver>
			<IDENTIFIER>
			(	||	<signature>
					<block>?
			)
	}
	token receiver {
		||	<parameters>
	}
	token varDecl {
		||	'var'
			(	||	<varSpec>
				||	'('
					(	||	<varSpec>
							<eos>
					)*
					')'
			)
	}
	token varSpec {
		||	<identifierList>
			(	||	<type_>
					(	||	'='
							<expressionList>
					)?
				||	'='
					<expressionList>
			)
	}
	token block {
		||	'{'
			<statementList>?
			'}'
	}
	token statementList {
		||	(	||	<statement>
					<eos>
			)+
	}
	token statement {
		||	<declaration>
		||	<labeledStmt>
		||	<simpleStmt>
		||	<goStmt>
		||	<returnStmt>
		||	<breakStmt>
		||	<continueStmt>
		||	<gotoStmt>
		||	<fallthroughStmt>
		||	<block>
		||	<ifStmt>
		||	<switchStmt>
		||	<selectStmt>
		||	<forStmt>
		||	<deferStmt>
	}
	token simpleStmt {
		||	<sendStmt>
		||	<expressionStmt>
		||	<incDecStmt>
		||	<assignment>
		||	<shortVarDecl>
		||	<emptyStmt>
	}
	token expressionStmt {
		||	<expression>
	}
	token sendStmt {
		||	<expression>
			'<-'
			<expression>
	}
	token incDecStmt {
		||	<expression>
			(	||	<PLUS_PLUS>
				||	<MINUS_MINUS>
			)
	}
	token assignment {
		||	<expressionList>
			<assign_op>
			<expressionList>
	}
	token assign_op {
		||	(	||	'+'
				||	'-'
				||	'|'
				||	'^'
				||	'*'
				||	'/'
				||	'%'
				||	'<<'
				||	'>>'
				||	'&'
				||	'&^'
			)?
			'='
	}
	token shortVarDecl {
		||	<identifierList>
			':='
			<expressionList>
	}
	token emptyStmt {
		||	';'
	}
	token labeledStmt {
		||	<IDENTIFIER>
			':'
			<statement>
	}
	token returnStmt {
		||	'return'
			<expressionList>?
	}
	token breakStmt {
		||	'break'
			<IDENTIFIER>?
	}
	token continueStmt {
		||	'continue'
			<IDENTIFIER>?
	}
	token gotoStmt {
		||	'goto'
			<IDENTIFIER>
	}
	token fallthroughStmt {
		||	'fallthrough'
	}
	token deferStmt {
		||	'defer'
			<expression>
	}
	token ifStmt {
		||	'if'
			(	||	<simpleStmt>
					';'
			)?
			<expression>
			<block>
			(	||	'else'
					(	||	<ifStmt>
						||	<block>
					)
			)?
	}
	token switchStmt {
		||	<exprSwitchStmt>
		||	<typeSwitchStmt>
	}
	token exprSwitchStmt {
		||	'switch'
			(	||	<simpleStmt>
					';'
			)?
			<expression>?
			'{'
			<exprCaseClause>*
			'}'
	}
	token exprCaseClause {
		||	<exprSwitchCase>
			':'
			<statementList>?
	}
	token exprSwitchCase {
		||	'case'
			<expressionList>
		||	'default'
	}
	token typeSwitchStmt {
		||	'switch'
			(	||	<simpleStmt>
					';'
			)?
			<typeSwitchGuard>
			'{'
			<typeCaseClause>*
			'}'
	}
	token typeSwitchGuard {
		||	(	||	<IDENTIFIER>
					':='
			)?
			<primaryExpr>
			'.'
			'('
			'type'
			')'
	}
	token typeCaseClause {
		||	<typeSwitchCase>
			':'
			<statementList>?
	}
	token typeSwitchCase {
		||	'case'
			<typeList>
		||	'default'
	}
	token typeList {
		||	(	||	<type_>
				||	<NIL_LIT>
			)
			(	||	','
					(	||	<type_>
						||	<NIL_LIT>
					)
			)*
	}
	token selectStmt {
		||	'select'
			'{'
			<commClause>*
			'}'
	}
	token commClause {
		||	<commCase>
			':'
			<statementList>?
	}
	token commCase {
		||	'case'
			(	||	<sendStmt>
				||	<recvStmt>
			)
		||	'default'
	}
	token recvStmt {
		||	(	||	<expressionList>
					'='
				||	<identifierList>
					':='
			)?
			<expression>
	}
	token forStmt {
		||	'for'
			(	||	<expression>
				||	<forClause>
				||	<rangeClause>
			)?
			<block>
	}
	token forClause {
		||	<simpleStmt>?
			';'
			<expression>?
			';'
			<simpleStmt>?
	}
	token rangeClause {
		||	(	||	<expressionList>
					'='
				||	<identifierList>
					':='
			)?
			'range'
			<expression>
	}
	token goStmt {
		||	'go'
			<expression>
	}
	token type_ {
		||	<typeName>
		||	<typeLit>
		||	'('
			<type_>
			')'
	}
	token typeName {
		||	<IDENTIFIER>
		||	<qualifiedIdent>
	}
	token typeLit {
		||	<arrayType>
		||	<structType>
		||	<pointerType>
		||	<functionType>
		||	<interfaceType>
		||	<sliceType>
		||	<mapType>
		||	<channelType>
	}
	token arrayType {
		||	'['
			<arrayLength>
			'\]'
			<elementType>
	}
	token arrayLength {
		||	<expression>
	}
	token elementType {
		||	<type_>
	}
	token pointerType {
		||	'*'
			<type_>
	}
	token interfaceType {
		||	'interface'
			'{'
			(	||	<methodSpec>
					<eos>
			)*
			'}'
	}
	token sliceType {
		||	'['
			'\]'
			<elementType>
	}
	token mapType {
		||	'map'
			'['
			<type_>
			'\]'
			<elementType>
	}
	token channelType {
		||	(	||	'chan'
				||	'chan'
					'<-'
				||	'<-'
					'chan'
			)
			<elementType>
	}
	token methodSpec {
		||	<IDENTIFIER>
			<parameters>
			<result>
		||	<typeName>
		||	<IDENTIFIER>
			<parameters>
	}
	token functionType {
		||	'func'
			<signature>
	}
	token signature {
		||	<parameters>
			<result>
		||	<parameters>
	}
	token result {
		||	<parameters>
		||	<type_>
	}
	token parameters {
		||	'('
			(	||	<parameterDecl>
					(	||	<COMMA>
							<parameterDecl>
					)*
					<COMMA>?
			)?
			')'
	}
	token parameterDecl {
		||	<identifierList>?
			'...'?
			<type_>
	}
	token expression {
		||	<primaryExpr>
		||	<unaryExpr>
		||	<expression>
			(	||	'*'
				||	'/'
				||	'%'
				||	'<<'
				||	'>>'
				||	'&'
				||	'&^'
			)
			<expression>
		||	<expression>
			(	||	'+'
				||	'-'
				||	'|'
				||	'^'
			)
			<expression>
		||	<expression>
			(	||	'=='
				||	'!='
				||	'<'
				||	'<='
				||	'>'
				||	'>='
			)
			<expression>
		||	<expression>
			'&&'
			<expression>
		||	<expression>
			'||'
			<expression>
	}
	token primaryExpr {
		||	<operand>
		||	<conversion>
		||	<primaryExpr>
			(	||	<DOT>
					<IDENTIFIER>
				||	<index>
				||	<slice>
				||	<typeAssertion>
				||	<arguments>
			)
	}
	token unaryExpr {
		||	<primaryExpr>
		||	(	||	'+'
				||	'-'
				||	'!'
				||	'^'
				||	'*'
				||	'&'
				||	'<-'
			)
			<expression>
	}
	token conversion {
		||	<type_>
			'('
			<expression>
			','?
			')'
	}
	token operand {
		||	<literal>
		||	<operandName>
		||	<methodExpr>
		||	'('
			<expression>
			')'
	}
	token literal {
		||	<basicLit>
		||	<compositeLit>
		||	<functionLit>
	}
	token basicLit {
		||	<NIL_LIT>
		||	<integer>
		||	<string_>
		||	<FLOAT_LIT>
		||	<IMAGINARY_LIT>
		||	<RUNE_LIT>
	}
	token integer {
		||	<DECIMAL_LIT>
		||	<OCTAL_LIT>
		||	<HEX_LIT>
		||	<IMAGINARY_LIT>
		||	<RUNE_LIT>
	}
	token operandName {
		||	<IDENTIFIER>
		||	<qualifiedIdent>
	}
	token qualifiedIdent {
		||	<IDENTIFIER>
			'.'
			<IDENTIFIER>
	}
	token compositeLit {
		||	<literalType>
			<literalValue>
	}
	token literalType {
		||	<structType>
		||	<arrayType>
		||	'['
			'...'
			'\]'
			<elementType>
		||	<sliceType>
		||	<mapType>
		||	<typeName>
	}
	token literalValue {
		||	'{'
			(	||	<elementList>
					','?
			)?
			'}'
	}
	token elementList {
		||	<keyedElement>
			(	||	','
					<keyedElement>
			)*
	}
	token keyedElement {
		||	(	||	<key>
					':'
			)?
			<element>
	}
	token key {
		||	<IDENTIFIER>
		||	<expression>
		||	<literalValue>
	}
	token element {
		||	<expression>
		||	<literalValue>
	}
	token structType {
		||	'struct'
			'{'
			(	||	<fieldDecl>
					<eos>
			)*
			'}'
	}
	token fieldDecl {
		||	(	||	<identifierList>
					<type_>
				||	<anonymousField>
			)
			<string_>?
	}
	token string_ {
		||	<RAW_STRING_LIT>
		||	<INTERPRETED_STRING_LIT>
	}
	token anonymousField {
		||	'*'?
			<typeName>
	}
	token functionLit {
		||	'func'
			<signature>
			<block>
	}
	token index {
		||	'['
			<expression>
			'\]'
	}
	token slice {
		||	'['
			(	||	<expression>?
					':'
					<expression>?
				||	<expression>?
					':'
					<expression>
					':'
					<expression>
			)
			'\]'
	}
	token typeAssertion {
		||	'.'
			'('
			<type_>
			')'
	}
	token arguments {
		||	'('
			(	||	(	||	<expressionList>
						||	<type_>
							(	||	','
									<expressionList>
							)?
					)
					'...'?
					','?
			)?
			')'
	}
	token methodExpr {
		||	<receiverType>
			<DOT>
			<IDENTIFIER>
	}
	token receiverType {
		||	<typeName>
		||	'('
			(	||	'*'
					<typeName>
				||	<receiverType>
			)
			')'
	}
	token eos {
		||	';'
		||	$
	}
	token BREAK {
		||	'break'
	}
	token DEFAULT {
		||	'default'
	}
	token FUNC {
		||	'func'
	}
	token INTERFACE {
		||	'interface'
	}
	token SELECT {
		||	'select'
	}
	token CASE {
		||	'case'
	}
	token DEFER {
		||	'defer'
	}
	token GO {
		||	'go'
	}
	token MAP {
		||	'map'
	}
	token STRUCT {
		||	'struct'
	}
	token CHAN {
		||	'chan'
	}
	token ELSE {
		||	'else'
	}
	token GOTO {
		||	'goto'
	}
	token PACKAGE {
		||	'package'
	}
	token SWITCH {
		||	'switch'
	}
	token CONST {
		||	'const'
	}
	token FALLTHROUGH {
		||	'fallthrough'
	}
	token IF {
		||	'if'
	}
	token RANGE {
		||	'range'
	}
	token TYPE {
		||	'type'
	}
	token CONTINUE {
		||	'continue'
	}
	token FOR {
		||	'for'
	}
	token IMPORT {
		||	'import'
	}
	token RETURN {
		||	'return'
	}
	token VAR {
		||	'var'
	}
	token NIL_LIT {
		||	'nil'
	}
	token IDENTIFIER {
		||	<LETTER>
			(	||	<LETTER>
				||	<UNICODE_DIGIT>
			)*
	}
	token L_PAREN {
		||	'('
	}
	token R_PAREN {
		||	')'
	}
	token L_CURLY {
		||	'{'
	}
	token R_CURLY {
		||	'}'
	}
	token L_BRACKET {
		||	'['
	}
	token R_BRACKET {
		||	'\]'
	}
	token ASSIGN {
		||	'='
	}
	token COMMA {
		||	','
	}
	token SEMI {
		||	';'
	}
	token COLON {
		||	':'
	}
	token DOT {
		||	'.'
	}
	token PLUS_PLUS {
		||	'++'
	}
	token MINUS_MINUS {
		||	'--'
	}
	token DECLARE_ASSIGN {
		||	':='
	}
	token ELLIPSIS {
		||	'...'
	}
	token LOGICAL_OR {
		||	'||'
	}
	token LOGICAL_AND {
		||	'&&'
	}
	token EQUALS {
		||	'=='
	}
	token NOT_EQUALS {
		||	'!='
	}
	token LESS {
		||	'<'
	}
	token LESS_OR_EQUALS {
		||	'<='
	}
	token GREATER {
		||	'>'
	}
	token GREATER_OR_EQUALS {
		||	'>='
	}
	token OR {
		||	'|'
	}
	token DIV {
		||	'/'
	}
	token MOD {
		||	'%'
	}
	token LSHIFT {
		||	'<<'
	}
	token RSHIFT {
		||	'>>'
	}
	token BIT_CLEAR {
		||	'&^'
	}
	token EXCLAMATION {
		||	'!'
	}
	token PLUS {
		||	'+'
	}
	token MINUS {
		||	'-'
	}
	token CARET {
		||	'^'
	}
	token STAR {
		||	'*'
	}
	token AMPERSAND {
		||	'&'
	}
	token RECEIVE {
		||	'<-'
	}
	token DECIMAL_LIT {
		||	<[ 1 .. 9 ]>
			<[ 0 .. 9 ]>*
	}
	token OCTAL_LIT {
		||	'0'
			<OCTAL_DIGIT>*
	}
	token HEX_LIT {
		||	'0'
			<[ x X ]>
			<HEX_DIGIT>+
	}
	token FLOAT_LIT {
		||	<DECIMALS>
			(	||	'.'
					<DECIMALS>?
					<EXPONENT>?
				||	<EXPONENT>
			)
		||	'.'
			<DECIMALS>
			<EXPONENT>?
	}
	token IMAGINARY_LIT {
		||	(	||	<DECIMALS>
				||	<FLOAT_LIT>
			)
			'i'
	}
	token RUNE_LIT {
		||	'\''
			(	||	<-[ \n \\ ]>
				||	<ESCAPED_VALUE>
			)
			'\''
	}
	token RAW_STRING_LIT {
		||	'`'
			<-[ ` ]>*
			'`'
	}
	token INTERPRETED_STRING_LIT {
		||	'"'
			(	||	<-[ " \\ ]>
				||	<ESCAPED_VALUE>
			)*
			'"'
	}
	token WS {
		||	<[   \t ]>+
	}
	token COMMENT {
		||	'/*'
			.*?
			'*/'
	}
	token TERMINATOR {
		||	<[ \r \n ]>+
	}
	token LINE_COMMENT {
		||	'//'
			<-[ \r \n ]>*
	}
	token ESCAPED_VALUE {
		||	'\\'
			(	||	'u'
					<HEX_DIGIT>
					<HEX_DIGIT>
					<HEX_DIGIT>
					<HEX_DIGIT>
				||	'U'
					<HEX_DIGIT>
					<HEX_DIGIT>
					<HEX_DIGIT>
					<HEX_DIGIT>
					<HEX_DIGIT>
					<HEX_DIGIT>
					<HEX_DIGIT>
					<HEX_DIGIT>
				||	<[ a b f n r t v \\ \' " ]>
				||	<OCTAL_DIGIT>
					<OCTAL_DIGIT>
					<OCTAL_DIGIT>
				||	'x'
					<HEX_DIGIT>
					<HEX_DIGIT>
			)
	}
	token DECIMALS {
		||	<[ 0 .. 9 ]>+
	}
	token OCTAL_DIGIT {
		||	<[ 0 .. 7 ]>
	}
	token HEX_DIGIT {
		||	<[ 0 .. 9 ]>
	}
	token EXPONENT {
		||	<[ e E ]>
			<[ + - ]>?
			<DECIMALS>
	}
	token LETTER {
		||	<UNICODE_LETTER>
		||	'_'
	}
	token UNICODE_DIGIT {
		||	<[ \x[0030] .. \x[0039] ]>
		||	<[ \x[0660] .. \x[0669] ]>
		||	<[ \x[06F0] .. \x[06F9] ]>
		||	<[ \x[0966] .. \x[096F] ]>
		||	<[ \x[09E6] .. \x[09EF] ]>
		||	<[ \x[0A66] .. \x[0A6F] ]>
		||	<[ \x[0AE6] .. \x[0AEF] ]>
		||	<[ \x[0B66] .. \x[0B6F] ]>
		||	<[ \x[0BE7] .. \x[0BEF] ]>
		||	<[ \x[0C66] .. \x[0C6F] ]>
		||	<[ \x[0CE6] .. \x[0CEF] ]>
		||	<[ \x[0D66] .. \x[0D6F] ]>
		||	<[ \x[0E50] .. \x[0E59] ]>
		||	<[ \x[0ED0] .. \x[0ED9] ]>
		||	<[ \x[0F20] .. \x[0F29] ]>
		||	<[ \x[1040] .. \x[1049] ]>
		||	<[ \x[1369] .. \x[1371] ]>
		||	<[ \x[17E0] .. \x[17E9] ]>
		||	<[ \x[1810] .. \x[1819] ]>
		||	<[ \x[FF10] .. \x[FF19] ]>
	}
	token UNICODE_LETTER {
		||	<[ \x[0041] .. \x[005A] ]>
		||	<[ \x[0061] .. \x[007A] ]>
		||	<[ \x[00AA] ]>
		||	<[ \x[00B5] ]>
		||	<[ \x[00BA] ]>
		||	<[ \x[00C0] .. \x[00D6] ]>
		||	<[ \x[00D8] .. \x[00F6] ]>
		||	<[ \x[00F8] .. \x[021F] ]>
		||	<[ \x[0222] .. \x[0233] ]>
		||	<[ \x[0250] .. \x[02AD] ]>
		||	<[ \x[02B0] .. \x[02B8] ]>
		||	<[ \x[02BB] .. \x[02C1] ]>
		||	<[ \x[02D0] .. \x[02D1] ]>
		||	<[ \x[02E0] .. \x[02E4] ]>
		||	<[ \x[02EE] ]>
		||	<[ \x[037A] ]>
		||	<[ \x[0386] ]>
		||	<[ \x[0388] .. \x[038A] ]>
		||	<[ \x[038C] ]>
		||	<[ \x[038E] .. \x[03A1] ]>
		||	<[ \x[03A3] .. \x[03CE] ]>
		||	<[ \x[03D0] .. \x[03D7] ]>
		||	<[ \x[03DA] .. \x[03F3] ]>
		||	<[ \x[0400] .. \x[0481] ]>
		||	<[ \x[048C] .. \x[04C4] ]>
		||	<[ \x[04C7] .. \x[04C8] ]>
		||	<[ \x[04CB] .. \x[04CC] ]>
		||	<[ \x[04D0] .. \x[04F5] ]>
		||	<[ \x[04F8] .. \x[04F9] ]>
		||	<[ \x[0531] .. \x[0556] ]>
		||	<[ \x[0559] ]>
		||	<[ \x[0561] .. \x[0587] ]>
		||	<[ \x[05D0] .. \x[05EA] ]>
		||	<[ \x[05F0] .. \x[05F2] ]>
		||	<[ \x[0621] .. \x[063A] ]>
		||	<[ \x[0640] .. \x[064A] ]>
		||	<[ \x[0671] .. \x[06D3] ]>
		||	<[ \x[06D5] ]>
		||	<[ \x[06E5] .. \x[06E6] ]>
		||	<[ \x[06FA] .. \x[06FC] ]>
		||	<[ \x[0710] ]>
		||	<[ \x[0712] .. \x[072C] ]>
		||	<[ \x[0780] .. \x[07A5] ]>
		||	<[ \x[0905] .. \x[0939] ]>
		||	<[ \x[093D] ]>
		||	<[ \x[0950] ]>
		||	<[ \x[0958] .. \x[0961] ]>
		||	<[ \x[0985] .. \x[098C] ]>
		||	<[ \x[098F] .. \x[0990] ]>
		||	<[ \x[0993] .. \x[09A8] ]>
		||	<[ \x[09AA] .. \x[09B0] ]>
		||	<[ \x[09B2] ]>
		||	<[ \x[09B6] .. \x[09B9] ]>
		||	<[ \x[09DC] .. \x[09DD] ]>
		||	<[ \x[09DF] .. \x[09E1] ]>
		||	<[ \x[09F0] .. \x[09F1] ]>
		||	<[ \x[0A05] .. \x[0A0A] ]>
		||	<[ \x[0A0F] .. \x[0A10] ]>
		||	<[ \x[0A13] .. \x[0A28] ]>
		||	<[ \x[0A2A] .. \x[0A30] ]>
		||	<[ \x[0A32] .. \x[0A33] ]>
		||	<[ \x[0A35] .. \x[0A36] ]>
		||	<[ \x[0A38] .. \x[0A39] ]>
		||	<[ \x[0A59] .. \x[0A5C] ]>
		||	<[ \x[0A5E] ]>
		||	<[ \x[0A72] .. \x[0A74] ]>
		||	<[ \x[0A85] .. \x[0A8B] ]>
		||	<[ \x[0A8D] ]>
		||	<[ \x[0A8F] .. \x[0A91] ]>
		||	<[ \x[0A93] .. \x[0AA8] ]>
		||	<[ \x[0AAA] .. \x[0AB0] ]>
		||	<[ \x[0AB2] .. \x[0AB3] ]>
		||	<[ \x[0AB5] .. \x[0AB9] ]>
		||	<[ \x[0ABD] ]>
		||	<[ \x[0AD0] ]>
		||	<[ \x[0AE0] ]>
		||	<[ \x[0B05] .. \x[0B0C] ]>
		||	<[ \x[0B0F] .. \x[0B10] ]>
		||	<[ \x[0B13] .. \x[0B28] ]>
		||	<[ \x[0B2A] .. \x[0B30] ]>
		||	<[ \x[0B32] .. \x[0B33] ]>
		||	<[ \x[0B36] .. \x[0B39] ]>
		||	<[ \x[0B3D] ]>
		||	<[ \x[0B5C] .. \x[0B5D] ]>
		||	<[ \x[0B5F] .. \x[0B61] ]>
		||	<[ \x[0B85] .. \x[0B8A] ]>
		||	<[ \x[0B8E] .. \x[0B90] ]>
		||	<[ \x[0B92] .. \x[0B95] ]>
		||	<[ \x[0B99] .. \x[0B9A] ]>
		||	<[ \x[0B9C] ]>
		||	<[ \x[0B9E] .. \x[0B9F] ]>
		||	<[ \x[0BA3] .. \x[0BA4] ]>
		||	<[ \x[0BA8] .. \x[0BAA] ]>
		||	<[ \x[0BAE] .. \x[0BB5] ]>
		||	<[ \x[0BB7] .. \x[0BB9] ]>
		||	<[ \x[0C05] .. \x[0C0C] ]>
		||	<[ \x[0C0E] .. \x[0C10] ]>
		||	<[ \x[0C12] .. \x[0C28] ]>
		||	<[ \x[0C2A] .. \x[0C33] ]>
		||	<[ \x[0C35] .. \x[0C39] ]>
		||	<[ \x[0C60] .. \x[0C61] ]>
		||	<[ \x[0C85] .. \x[0C8C] ]>
		||	<[ \x[0C8E] .. \x[0C90] ]>
		||	<[ \x[0C92] .. \x[0CA8] ]>
		||	<[ \x[0CAA] .. \x[0CB3] ]>
		||	<[ \x[0CB5] .. \x[0CB9] ]>
		||	<[ \x[0CDE] ]>
		||	<[ \x[0CE0] .. \x[0CE1] ]>
		||	<[ \x[0D05] .. \x[0D0C] ]>
		||	<[ \x[0D0E] .. \x[0D10] ]>
		||	<[ \x[0D12] .. \x[0D28] ]>
		||	<[ \x[0D2A] .. \x[0D39] ]>
		||	<[ \x[0D60] .. \x[0D61] ]>
		||	<[ \x[0D85] .. \x[0D96] ]>
		||	<[ \x[0D9A] .. \x[0DB1] ]>
		||	<[ \x[0DB3] .. \x[0DBB] ]>
		||	<[ \x[0DBD] ]>
		||	<[ \x[0DC0] .. \x[0DC6] ]>
		||	<[ \x[0E01] .. \x[0E30] ]>
		||	<[ \x[0E32] .. \x[0E33] ]>
		||	<[ \x[0E40] .. \x[0E46] ]>
		||	<[ \x[0E81] .. \x[0E82] ]>
		||	<[ \x[0E84] ]>
		||	<[ \x[0E87] .. \x[0E88] ]>
		||	<[ \x[0E8A] ]>
		||	<[ \x[0E8D] ]>
		||	<[ \x[0E94] .. \x[0E97] ]>
		||	<[ \x[0E99] .. \x[0E9F] ]>
		||	<[ \x[0EA1] .. \x[0EA3] ]>
		||	<[ \x[0EA5] ]>
		||	<[ \x[0EA7] ]>
		||	<[ \x[0EAA] .. \x[0EAB] ]>
		||	<[ \x[0EAD] .. \x[0EB0] ]>
		||	<[ \x[0EB2] .. \x[0EB3] ]>
		||	<[ \x[0EBD] .. \x[0EC4] ]>
		||	<[ \x[0EC6] ]>
		||	<[ \x[0EDC] .. \x[0EDD] ]>
		||	<[ \x[0F00] ]>
		||	<[ \x[0F40] .. \x[0F6A] ]>
		||	<[ \x[0F88] .. \x[0F8B] ]>
		||	<[ \x[1000] .. \x[1021] ]>
		||	<[ \x[1023] .. \x[1027] ]>
		||	<[ \x[1029] .. \x[102A] ]>
		||	<[ \x[1050] .. \x[1055] ]>
		||	<[ \x[10A0] .. \x[10C5] ]>
		||	<[ \x[10D0] .. \x[10F6] ]>
		||	<[ \x[1100] .. \x[1159] ]>
		||	<[ \x[115F] .. \x[11A2] ]>
		||	<[ \x[11A8] .. \x[11F9] ]>
		||	<[ \x[1200] .. \x[1206] ]>
		||	<[ \x[1208] .. \x[1246] ]>
		||	<[ \x[1248] ]>
		||	<[ \x[124A] .. \x[124D] ]>
		||	<[ \x[1250] .. \x[1256] ]>
		||	<[ \x[1258] ]>
		||	<[ \x[125A] .. \x[125D] ]>
		||	<[ \x[1260] .. \x[1286] ]>
		||	<[ \x[1288] ]>
		||	<[ \x[128A] .. \x[128D] ]>
		||	<[ \x[1290] .. \x[12AE] ]>
		||	<[ \x[12B0] ]>
		||	<[ \x[12B2] .. \x[12B5] ]>
		||	<[ \x[12B8] .. \x[12BE] ]>
		||	<[ \x[12C0] ]>
		||	<[ \x[12C2] .. \x[12C5] ]>
		||	<[ \x[12C8] .. \x[12CE] ]>
		||	<[ \x[12D0] .. \x[12D6] ]>
		||	<[ \x[12D8] .. \x[12EE] ]>
		||	<[ \x[12F0] .. \x[130E] ]>
		||	<[ \x[1310] ]>
		||	<[ \x[1312] .. \x[1315] ]>
		||	<[ \x[1318] .. \x[131E] ]>
		||	<[ \x[1320] .. \x[1346] ]>
		||	<[ \x[1348] .. \x[135A] ]>
		||	<[ \x[13A0] .. \x[13B0] ]>
		||	<[ \x[13B1] .. \x[13F4] ]>
		||	<[ \x[1401] .. \x[1676] ]>
		||	<[ \x[1681] .. \x[169A] ]>
		||	<[ \x[16A0] .. \x[16EA] ]>
		||	<[ \x[1780] .. \x[17B3] ]>
		||	<[ \x[1820] .. \x[1877] ]>
		||	<[ \x[1880] .. \x[18A8] ]>
		||	<[ \x[1E00] .. \x[1E9B] ]>
		||	<[ \x[1EA0] .. \x[1EE0] ]>
		||	<[ \x[1EE1] .. \x[1EF9] ]>
		||	<[ \x[1F00] .. \x[1F15] ]>
		||	<[ \x[1F18] .. \x[1F1D] ]>
		||	<[ \x[1F20] .. \x[1F39] ]>
		||	<[ \x[1F3A] .. \x[1F45] ]>
		||	<[ \x[1F48] .. \x[1F4D] ]>
		||	<[ \x[1F50] .. \x[1F57] ]>
		||	<[ \x[1F59] ]>
		||	<[ \x[1F5B] ]>
		||	<[ \x[1F5D] ]>
		||	<[ \x[1F5F] .. \x[1F7D] ]>
		||	<[ \x[1F80] .. \x[1FB4] ]>
		||	<[ \x[1FB6] .. \x[1FBC] ]>
		||	<[ \x[1FBE] ]>
		||	<[ \x[1FC2] .. \x[1FC4] ]>
		||	<[ \x[1FC6] .. \x[1FCC] ]>
		||	<[ \x[1FD0] .. \x[1FD3] ]>
		||	<[ \x[1FD6] .. \x[1FDB] ]>
		||	<[ \x[1FE0] .. \x[1FEC] ]>
		||	<[ \x[1FF2] .. \x[1FF4] ]>
		||	<[ \x[1FF6] .. \x[1FFC] ]>
		||	<[ \x[207F] ]>
		||	<[ \x[2102] ]>
		||	<[ \x[2107] ]>
		||	<[ \x[210A] .. \x[2113] ]>
		||	<[ \x[2115] ]>
		||	<[ \x[2119] .. \x[211D] ]>
		||	<[ \x[2124] ]>
		||	<[ \x[2126] ]>
		||	<[ \x[2128] ]>
		||	<[ \x[212A] .. \x[212D] ]>
		||	<[ \x[212F] .. \x[2131] ]>
		||	<[ \x[2133] .. \x[2139] ]>
		||	<[ \x[2160] .. \x[2183] ]>
		||	<[ \x[3005] .. \x[3007] ]>
		||	<[ \x[3021] .. \x[3029] ]>
		||	<[ \x[3031] .. \x[3035] ]>
		||	<[ \x[3038] .. \x[303A] ]>
		||	<[ \x[3041] .. \x[3094] ]>
		||	<[ \x[309D] .. \x[309E] ]>
		||	<[ \x[30A1] .. \x[30FA] ]>
		||	<[ \x[30FC] .. \x[30FE] ]>
		||	<[ \x[3105] .. \x[312C] ]>
		||	<[ \x[3131] .. \x[318E] ]>
		||	<[ \x[31A0] .. \x[31B7] ]>
		||	<[ \x[3400] ]>
		||	<[ \x[4DB5] ]>
		||	<[ \x[4E00] ]>
		||	<[ \x[9FA5] ]>
		||	<[ \x[A000] .. \x[A48C] ]>
		||	<[ \x[AC00] ]>
		||	<[ \x[D7A3] ]>
		||	<[ \x[F900] .. \x[FA2D] ]>
		||	<[ \x[FB00] .. \x[FB06] ]>
		||	<[ \x[FB13] .. \x[FB17] ]>
		||	<[ \x[FB1D] ]>
		||	<[ \x[FB1F] .. \x[FB28] ]>
		||	<[ \x[FB2A] .. \x[FB36] ]>
		||	<[ \x[FB38] .. \x[FB3C] ]>
		||	<[ \x[FB3E] ]>
		||	<[ \x[FB40] .. \x[FB41] ]>
		||	<[ \x[FB43] .. \x[FB44] ]>
		||	<[ \x[FB46] .. \x[FBB1] ]>
		||	<[ \x[FBD3] .. \x[FD3D] ]>
		||	<[ \x[FD50] .. \x[FD8F] ]>
		||	<[ \x[FD92] .. \x[FDC7] ]>
		||	<[ \x[FDF0] .. \x[FDFB] ]>
		||	<[ \x[FE70] .. \x[FE72] ]>
		||	<[ \x[FE74] ]>
		||	<[ \x[FE76] .. \x[FEFC] ]>
		||	<[ \x[FF21] .. \x[FF3A] ]>
		||	<[ \x[FF41] .. \x[FF5A] ]>
		||	<[ \x[FF66] .. \x[FFBE] ]>
		||	<[ \x[FFC2] .. \x[FFC7] ]>
		||	<[ \x[FFCA] .. \x[FFCF] ]>
		||	<[ \x[FFD2] .. \x[FFD7] ]>
		||	<[ \x[FFDA] .. \x[FFDC] ]>
	}
}