%token T_AND "&" T_AND_AND "&&" T_AND_EQ "&="
%token T_BREAK "break" T_CASE "case" T_CATCH "catch"
-%token T_COLON ":" T_COMMA ";" T_CONTINUE "continue"
+%token T_COLON ":" T_COMMA "," T_CONTINUE "continue"
%token T_DEFAULT "default" T_DELETE "delete" T_DIVIDE_ "/"
%token T_DIVIDE_EQ "/=" T_DO "do" T_DOT "."
%token T_ELSE "else" T_EQ "=" T_EQ_EQ "=="
%token T_AS "as"
%token T_ON "on"
+%token T_ERROR
+
--- feed tokens
%token T_FEED_UI_PROGRAM
%token T_FEED_UI_OBJECT_MEMBER
#include "qmljsengine_p.h"
#include "qmljslexer_p.h"
#include "qmljsast_p.h"
-#include "qmljsnodepool_p.h"
+#include "qmljsmemorypool_p.h"
./
namespace QmlJS {
class Engine;
-class NameId;
class QML_PARSER_EXPORT Parser: protected $table
{
union Value {
int ival;
double dval;
- NameId *sval;
AST::ArgumentList *ArgumentList;
AST::CaseBlock *CaseBlock;
AST::CaseClause *CaseClause;
inline Value &sym(int index)
{ return sym_stack [tos + index - 1]; }
+ inline QStringRef &stringRef(int index)
+ { return string_stack [tos + index - 1]; }
+
inline AST::SourceLocation &loc(int index)
{ return location_stack [tos + index - 1]; }
protected:
Engine *driver;
+ MemoryPool *pool;
int tos;
int stack_size;
Value *sym_stack;
int *state_stack;
AST::SourceLocation *location_stack;
+ QStringRef *string_stack;
AST::Node *program;
int token;
double dval;
AST::SourceLocation loc;
+ QStringRef spell;
};
double yylval;
+ QStringRef yytokenspell;
AST::SourceLocation yylloc;
AST::SourceLocation yyprevlloc;
sym_stack = reinterpret_cast<Value*> (qRealloc(sym_stack, stack_size * sizeof(Value)));
state_stack = reinterpret_cast<int*> (qRealloc(state_stack, stack_size * sizeof(int)));
location_stack = reinterpret_cast<AST::SourceLocation*> (qRealloc(location_stack, stack_size * sizeof(AST::SourceLocation)));
+ string_stack = reinterpret_cast<QStringRef*> (qRealloc(string_stack, stack_size * sizeof(QStringRef)));
}
inline static bool automatic(Engine *driver, int token)
Parser::Parser(Engine *engine):
driver(engine),
+ pool(engine->pool()),
tos(0),
stack_size(0),
sym_stack(0),
state_stack(0),
location_stack(0),
+ string_stack(0),
first_token(0),
last_token(0)
{
qFree(sym_stack);
qFree(state_stack);
qFree(location_stack);
+ qFree(string_stack);
}
}
AST::SourceLocation loc;
loc.offset = lexer->tokenOffset();
loc.length = lexer->tokenLength();
- loc.startLine = lexer->startLineNo();
- loc.startColumn = lexer->startColumnNo();
+ loc.startLine = lexer->tokenStartLine();
+ loc.startColumn = lexer->tokenStartColumn();
return loc;
}
AST::UiQualifiedId *Parser::reparseAsQualifiedId(AST::ExpressionNode *expr)
{
- QVarLengthArray<NameId *, 4> nameIds;
+ QVarLengthArray<QStringRef, 4> nameIds;
QVarLengthArray<AST::SourceLocation, 4> locations;
AST::ExpressionNode *it = expr;
}
if (AST::IdentifierExpression *idExpr = AST::cast<AST::IdentifierExpression *>(it)) {
- AST::UiQualifiedId *q = makeAstNode<AST::UiQualifiedId>(driver->nodePool(), idExpr->name);
+ AST::UiQualifiedId *q = new (pool) AST::UiQualifiedId(idExpr->name);
q->identifierToken = idExpr->identifierToken;
AST::UiQualifiedId *currentId = q;
for (int i = nameIds.size() - 1; i != -1; --i) {
- currentId = makeAstNode<AST::UiQualifiedId>(driver->nodePool(), currentId, nameIds[i]);
+ currentId = new (pool) AST::UiQualifiedId(currentId, nameIds[i]);
currentId->identifierToken = locations[i];
}
if (first_token == last_token) {
yytoken = lexer->lex();
- yylval = lexer->dval();
+ yylval = lexer->tokenValue();
+ yytokenspell = lexer->tokenSpell();
yylloc = location(lexer);
} else {
yytoken = first_token->token;
yylval = first_token->dval;
+ yytokenspell = first_token->spell;
yylloc = first_token->loc;
++first_token;
}
if (action != ACCEPT_STATE) {
yytoken = -1;
sym(1).dval = yylval;
+ stringRef(1) = yytokenspell;
loc(1) = yylloc;
} else {
--tos;
UiProgram: UiImportListOpt UiRootMember ;
/.
case $rule_number: {
- sym(1).UiProgram = makeAstNode<AST::UiProgram> (driver->nodePool(), sym(1).UiImportList,
+ sym(1).UiProgram = new (pool) AST::UiProgram(sym(1).UiImportList,
sym(2).UiObjectMemberList->finish());
} break;
./
UiImportList: UiImport ;
/.
case $rule_number: {
- sym(1).Node = makeAstNode<AST::UiImportList> (driver->nodePool(), sym(1).UiImport);
+ sym(1).Node = new (pool) AST::UiImportList(sym(1).UiImport);
} break;
./
UiImportList: UiImportList UiImport ;
/.
case $rule_number: {
- sym(1).Node = makeAstNode<AST::UiImportList> (driver->nodePool(),
- sym(1).UiImportList, sym(2).UiImport);
+ sym(1).Node = new (pool) AST::UiImportList(sym(1).UiImportList, sym(2).UiImport);
} break;
./
sym(1).UiImport->versionToken = loc(2);
sym(1).UiImport->asToken = loc(3);
sym(1).UiImport->importIdToken = loc(4);
- sym(1).UiImport->importId = sym(4).sval;
+ sym(1).UiImport->importId = stringRef(4);
sym(1).UiImport->semicolonToken = loc(5);
} break;
./
case $rule_number: {
sym(1).UiImport->asToken = loc(2);
sym(1).UiImport->importIdToken = loc(3);
- sym(1).UiImport->importId = sym(3).sval;
+ sym(1).UiImport->importId = stringRef(3);
sym(1).UiImport->semicolonToken = loc(4);
} break;
./
AST::UiImport *node = 0;
if (AST::StringLiteral *importIdLiteral = AST::cast<AST::StringLiteral *>(sym(2).Expression)) {
- node = makeAstNode<AST::UiImport>(driver->nodePool(), importIdLiteral->value);
+ node = new (pool) AST::UiImport(importIdLiteral->value);
node->fileNameToken = loc(2);
} else if (AST::UiQualifiedId *qualifiedId = reparseAsQualifiedId(sym(2).Expression)) {
- node = makeAstNode<AST::UiImport>(driver->nodePool(), qualifiedId);
+ node = new (pool) AST::UiImport(qualifiedId);
node->fileNameToken = loc(2);
}
UiRootMember: UiObjectDefinition ;
/.
case $rule_number: {
- sym(1).Node = makeAstNode<AST::UiObjectMemberList> (driver->nodePool(), sym(1).UiObjectMember);
+ sym(1).Node = new (pool) AST::UiObjectMemberList(sym(1).UiObjectMember);
} break;
./
UiObjectMemberList: UiObjectMember ;
/.
case $rule_number: {
- sym(1).Node = makeAstNode<AST::UiObjectMemberList> (driver->nodePool(), sym(1).UiObjectMember);
+ sym(1).Node = new (pool) AST::UiObjectMemberList(sym(1).UiObjectMember);
} break;
./
UiObjectMemberList: UiObjectMemberList UiObjectMember ;
/.
case $rule_number: {
- AST::UiObjectMemberList *node = makeAstNode<AST:: UiObjectMemberList> (driver->nodePool(),
+ AST::UiObjectMemberList *node = new (pool) AST:: UiObjectMemberList(
sym(1).UiObjectMemberList, sym(2).UiObjectMember);
sym(1).Node = node;
} break;
UiArrayMemberList: UiObjectDefinition ;
/.
case $rule_number: {
- sym(1).Node = makeAstNode<AST::UiArrayMemberList> (driver->nodePool(), sym(1).UiObjectMember);
+ sym(1).Node = new (pool) AST::UiArrayMemberList(sym(1).UiObjectMember);
} break;
./
UiArrayMemberList: UiArrayMemberList T_COMMA UiObjectDefinition ;
/.
case $rule_number: {
- AST::UiArrayMemberList *node = makeAstNode<AST::UiArrayMemberList> (driver->nodePool(),
+ AST::UiArrayMemberList *node = new (pool) AST::UiArrayMemberList(
sym(1).UiArrayMemberList, sym(3).UiObjectMember);
node->commaToken = loc(2);
sym(1).Node = node;
UiObjectInitializer: T_LBRACE T_RBRACE ;
/.
case $rule_number: {
- AST::UiObjectInitializer *node = makeAstNode<AST::UiObjectInitializer> (driver->nodePool(), (AST::UiObjectMemberList*)0);
+ AST::UiObjectInitializer *node = new (pool) AST::UiObjectInitializer((AST::UiObjectMemberList*)0);
node->lbraceToken = loc(1);
node->rbraceToken = loc(2);
sym(1).Node = node;
UiObjectInitializer: T_LBRACE UiObjectMemberList T_RBRACE ;
/.
case $rule_number: {
- AST::UiObjectInitializer *node = makeAstNode<AST::UiObjectInitializer> (driver->nodePool(), sym(2).UiObjectMemberList->finish());
+ AST::UiObjectInitializer *node = new (pool) AST::UiObjectInitializer(sym(2).UiObjectMemberList->finish());
node->lbraceToken = loc(1);
node->rbraceToken = loc(3);
sym(1).Node = node;
UiObjectDefinition: UiQualifiedId UiObjectInitializer ;
/.
case $rule_number: {
- AST::UiObjectDefinition *node = makeAstNode<AST::UiObjectDefinition> (driver->nodePool(), sym(1).UiQualifiedId,
+ AST::UiObjectDefinition *node = new (pool) AST::UiObjectDefinition(sym(1).UiQualifiedId,
sym(2).UiObjectInitializer);
sym(1).Node = node;
} break;
UiObjectMember: UiQualifiedId T_COLON T_LBRACKET UiArrayMemberList T_RBRACKET ;
/.
case $rule_number: {
- AST::UiArrayBinding *node = makeAstNode<AST::UiArrayBinding> (driver->nodePool(),
+ AST::UiArrayBinding *node = new (pool) AST::UiArrayBinding(
sym(1).UiQualifiedId, sym(4).UiArrayMemberList->finish());
node->colonToken = loc(2);
node->lbracketToken = loc(3);
UiObjectMember: UiQualifiedId T_COLON UiQualifiedId UiObjectInitializer ;
/.
case $rule_number: {
- AST::UiObjectBinding *node = makeAstNode<AST::UiObjectBinding> (driver->nodePool(),
+ AST::UiObjectBinding *node = new (pool) AST::UiObjectBinding(
sym(1).UiQualifiedId, sym(3).UiQualifiedId, sym(4).UiObjectInitializer);
node->colonToken = loc(2);
sym(1).Node = node;
UiObjectMember: UiQualifiedId T_ON UiQualifiedId UiObjectInitializer ;
/.
case $rule_number: {
- AST::UiObjectBinding *node = makeAstNode<AST::UiObjectBinding> (driver->nodePool(),
+ AST::UiObjectBinding *node = new (pool) AST::UiObjectBinding(
sym(3).UiQualifiedId, sym(1).UiQualifiedId, sym(4).UiObjectInitializer);
node->colonToken = loc(2);
node->hasOnToken = true;
/.
case $rule_number:
{
- AST::UiScriptBinding *node = makeAstNode<AST::UiScriptBinding> (driver->nodePool(),
+ AST::UiScriptBinding *node = new (pool) AST::UiScriptBinding(
sym(1).UiQualifiedId, sym(3).Statement);
node->colonToken = loc(2);
sym(1).Node = node;
./
UiPropertyType: T_VAR ;
-/.
-case $rule_number:
-./
UiPropertyType: T_RESERVED_WORD ;
-/.
-case $rule_number: {
- sym(1).sval = driver->intern(lexer->characterBuffer(), lexer->characterCount());
- break;
-}
-./
-
UiPropertyType: T_IDENTIFIER ;
UiParameterListOpt: ;
UiParameterList: UiPropertyType JsIdentifier ;
/.
case $rule_number: {
- AST::UiParameterList *node = makeAstNode<AST::UiParameterList> (driver->nodePool(), sym(1).sval, sym(2).sval);
+ AST::UiParameterList *node = new (pool) AST::UiParameterList(stringRef(1), stringRef(2));
node->identifierToken = loc(2);
sym(1).Node = node;
} break;
UiParameterList: UiParameterList T_COMMA UiPropertyType JsIdentifier ;
/.
case $rule_number: {
- AST::UiParameterList *node = makeAstNode<AST::UiParameterList> (driver->nodePool(), sym(1).UiParameterList, sym(3).sval, sym(4).sval);
+ AST::UiParameterList *node = new (pool) AST::UiParameterList(sym(1).UiParameterList, stringRef(3), stringRef(4));
node->commaToken = loc(2);
node->identifierToken = loc(4);
sym(1).Node = node;
UiObjectMember: T_SIGNAL T_IDENTIFIER T_LPAREN UiParameterListOpt T_RPAREN T_SEMICOLON ;
/.
case $rule_number: {
- AST::UiPublicMember *node = makeAstNode<AST::UiPublicMember> (driver->nodePool(), (NameId *)0, sym(2).sval);
+ AST::UiPublicMember *node = new (pool) AST::UiPublicMember(QStringRef(), stringRef(2));
node->type = AST::UiPublicMember::Signal;
node->propertyToken = loc(1);
node->typeToken = loc(2);
UiObjectMember: T_SIGNAL T_IDENTIFIER T_SEMICOLON ;
/.
case $rule_number: {
- AST::UiPublicMember *node = makeAstNode<AST::UiPublicMember> (driver->nodePool(), (NameId *)0, sym(2).sval);
+ AST::UiPublicMember *node = new (pool) AST::UiPublicMember(QStringRef(), stringRef(2));
node->type = AST::UiPublicMember::Signal;
node->propertyToken = loc(1);
node->typeToken = loc(2);
UiObjectMember: T_PROPERTY T_IDENTIFIER T_LT UiPropertyType T_GT JsIdentifier T_SEMICOLON ;
/.
case $rule_number: {
- AST::UiPublicMember *node = makeAstNode<AST::UiPublicMember> (driver->nodePool(), sym(4).sval, sym(6).sval);
- node->typeModifier = sym(2).sval;
+ AST::UiPublicMember *node = new (pool) AST::UiPublicMember(stringRef(4), stringRef(6));
+ node->typeModifier = stringRef(2);
node->propertyToken = loc(1);
node->typeModifierToken = loc(2);
node->typeToken = loc(4);
UiObjectMember: T_PROPERTY UiPropertyType JsIdentifier T_SEMICOLON ;
/.
case $rule_number: {
- AST::UiPublicMember *node = makeAstNode<AST::UiPublicMember> (driver->nodePool(), sym(2).sval, sym(3).sval);
+ AST::UiPublicMember *node = new (pool) AST::UiPublicMember(stringRef(2), stringRef(3));
node->propertyToken = loc(1);
node->typeToken = loc(2);
node->identifierToken = loc(3);
UiObjectMember: T_DEFAULT T_PROPERTY UiPropertyType JsIdentifier T_SEMICOLON ;
/.
case $rule_number: {
- AST::UiPublicMember *node = makeAstNode<AST::UiPublicMember> (driver->nodePool(), sym(3).sval, sym(4).sval);
+ AST::UiPublicMember *node = new (pool) AST::UiPublicMember(stringRef(3), stringRef(4));
node->isDefaultMember = true;
node->defaultToken = loc(1);
node->propertyToken = loc(2);
UiObjectMember: T_PROPERTY UiPropertyType JsIdentifier T_COLON UiScriptStatement ;
/.
case $rule_number: {
- AST::UiPublicMember *node = makeAstNode<AST::UiPublicMember> (driver->nodePool(), sym(2).sval, sym(3).sval,
+ AST::UiPublicMember *node = new (pool) AST::UiPublicMember(stringRef(2), stringRef(3),
sym(5).Statement);
node->propertyToken = loc(1);
node->typeToken = loc(2);
UiObjectMember: T_READONLY T_PROPERTY UiPropertyType JsIdentifier T_COLON UiScriptStatement ;
/.
case $rule_number: {
- AST::UiPublicMember *node = makeAstNode<AST::UiPublicMember> (driver->nodePool(), sym(3).sval, sym(4).sval,
+ AST::UiPublicMember *node = new (pool) AST::UiPublicMember(stringRef(3), stringRef(4),
sym(6).Statement);
node->isReadonlyMember = true;
node->readonlyToken = loc(1);
UiObjectMember: T_DEFAULT T_PROPERTY UiPropertyType JsIdentifier T_COLON UiScriptStatement ;
/.
case $rule_number: {
- AST::UiPublicMember *node = makeAstNode<AST::UiPublicMember> (driver->nodePool(), sym(3).sval, sym(4).sval,
+ AST::UiPublicMember *node = new (pool) AST::UiPublicMember(stringRef(3), stringRef(4),
sym(6).Statement);
node->isDefaultMember = true;
node->defaultToken = loc(1);
UiObjectMember: T_PROPERTY T_IDENTIFIER T_LT UiPropertyType T_GT JsIdentifier T_COLON T_LBRACKET UiArrayMemberList T_RBRACKET ;
/.
case $rule_number: {
- AST::UiPublicMember *node = makeAstNode<AST::UiPublicMember> (driver->nodePool(), sym(4).sval, sym(6).sval);
- node->typeModifier = sym(2).sval;
+ AST::UiPublicMember *node = new (pool) AST::UiPublicMember(stringRef(4), stringRef(6));
+ node->typeModifier = stringRef(2);
node->propertyToken = loc(1);
node->typeModifierToken = loc(2);
node->typeToken = loc(4);
node->identifierToken = loc(6);
node->semicolonToken = loc(7); // insert a fake ';' before ':'
- AST::UiQualifiedId *propertyName = makeAstNode<AST::UiQualifiedId>(driver->nodePool(), sym(6).sval);
+ AST::UiQualifiedId *propertyName = new (pool) AST::UiQualifiedId(stringRef(6));
propertyName->identifierToken = loc(6);
propertyName->next = 0;
- AST::UiArrayBinding *binding = makeAstNode<AST::UiArrayBinding> (driver->nodePool(),
+ AST::UiArrayBinding *binding = new (pool) AST::UiArrayBinding(
propertyName, sym(9).UiArrayMemberList->finish());
binding->colonToken = loc(7);
binding->lbracketToken = loc(8);
UiObjectMember: T_PROPERTY UiPropertyType JsIdentifier T_COLON UiQualifiedId UiObjectInitializer ;
/.
case $rule_number: {
- AST::UiPublicMember *node = makeAstNode<AST::UiPublicMember> (driver->nodePool(), sym(2).sval, sym(3).sval);
+ AST::UiPublicMember *node = new (pool) AST::UiPublicMember(stringRef(2), stringRef(3));
node->propertyToken = loc(1);
node->typeToken = loc(2);
node->identifierToken = loc(3);
node->semicolonToken = loc(4); // insert a fake ';' before ':'
- AST::UiQualifiedId *propertyName = makeAstNode<AST::UiQualifiedId>(driver->nodePool(), sym(3).sval);
+ AST::UiQualifiedId *propertyName = new (pool) AST::UiQualifiedId(stringRef(3));
propertyName->identifierToken = loc(3);
propertyName->next = 0;
- AST::UiObjectBinding *binding = makeAstNode<AST::UiObjectBinding> (driver->nodePool(),
+ AST::UiObjectBinding *binding = new (pool) AST::UiObjectBinding(
propertyName, sym(5).UiQualifiedId, sym(6).UiObjectInitializer);
binding->colonToken = loc(4);
UiObjectMember: FunctionDeclaration ;
/.
case $rule_number: {
- sym(1).Node = makeAstNode<AST::UiSourceElement>(driver->nodePool(), sym(1).Node);
+ sym(1).Node = new (pool) AST::UiSourceElement(sym(1).Node);
} break;
./
UiObjectMember: VariableStatement ;
/.
case $rule_number: {
- sym(1).Node = makeAstNode<AST::UiSourceElement>(driver->nodePool(), sym(1).Node);
+ sym(1).Node = new (pool) AST::UiSourceElement(sym(1).Node);
} break;
./
JsIdentifier: T_IDENTIFIER;
JsIdentifier: T_PROPERTY ;
-/.
-case $rule_number: {
- QString s = QLatin1String(QmlJSGrammar::spell[T_PROPERTY]);
- sym(1).sval = driver->intern(s.constData(), s.length());
- break;
-}
-./
-
JsIdentifier: T_SIGNAL ;
-/.
-case $rule_number: {
- QString s = QLatin1String(QmlJSGrammar::spell[T_SIGNAL]);
- sym(1).sval = driver->intern(s.constData(), s.length());
- break;
-}
-./
-
JsIdentifier: T_READONLY ;
-/.
-case $rule_number: {
- QString s = QLatin1String(QmlJSGrammar::spell[T_READONLY]);
- sym(1).sval = driver->intern(s.constData(), s.length());
- break;
-}
-./
-
JsIdentifier: T_ON ;
-/.
-case $rule_number: {
- QString s = QLatin1String(QmlJSGrammar::spell[T_ON]);
- sym(1).sval = driver->intern(s.constData(), s.length());
- break;
-}
-./
--------------------------------------------------------------------------------------------------------
-- Expressions
PrimaryExpression: T_THIS ;
/.
case $rule_number: {
- AST::ThisExpression *node = makeAstNode<AST::ThisExpression> (driver->nodePool());
+ AST::ThisExpression *node = new (pool) AST::ThisExpression();
node->thisToken = loc(1);
sym(1).Node = node;
} break;
PrimaryExpression: JsIdentifier ;
/.
case $rule_number: {
- AST::IdentifierExpression *node = makeAstNode<AST::IdentifierExpression> (driver->nodePool(), sym(1).sval);
+ AST::IdentifierExpression *node = new (pool) AST::IdentifierExpression(stringRef(1));
node->identifierToken = loc(1);
sym(1).Node = node;
} break;
PrimaryExpression: T_NULL ;
/.
case $rule_number: {
- AST::NullExpression *node = makeAstNode<AST::NullExpression> (driver->nodePool());
+ AST::NullExpression *node = new (pool) AST::NullExpression();
node->nullToken = loc(1);
sym(1).Node = node;
} break;
PrimaryExpression: T_TRUE ;
/.
case $rule_number: {
- AST::TrueLiteral *node = makeAstNode<AST::TrueLiteral> (driver->nodePool());
+ AST::TrueLiteral *node = new (pool) AST::TrueLiteral();
node->trueToken = loc(1);
sym(1).Node = node;
} break;
PrimaryExpression: T_FALSE ;
/.
case $rule_number: {
- AST::FalseLiteral *node = makeAstNode<AST::FalseLiteral> (driver->nodePool());
+ AST::FalseLiteral *node = new (pool) AST::FalseLiteral();
node->falseToken = loc(1);
sym(1).Node = node;
} break;
PrimaryExpression: T_NUMERIC_LITERAL ;
/.
case $rule_number: {
- AST::NumericLiteral *node = makeAstNode<AST::NumericLiteral> (driver->nodePool(), sym(1).dval);
+ AST::NumericLiteral *node = new (pool) AST::NumericLiteral(sym(1).dval);
node->literalToken = loc(1);
sym(1).Node = node;
} break;
PrimaryExpression: T_STRING_LITERAL ;
/.
case $rule_number: {
- AST::StringLiteral *node = makeAstNode<AST::StringLiteral> (driver->nodePool(), sym(1).sval);
+ AST::StringLiteral *node = new (pool) AST::StringLiteral(stringRef(1));
node->literalToken = loc(1);
sym(1).Node = node;
} break;
loc(1).length = lexer->tokenLength();
- AST::RegExpLiteral *node = makeAstNode<AST::RegExpLiteral> (driver->nodePool(), lexer->pattern, lexer->flags);
+ AST::RegExpLiteral *node = new (pool) AST::RegExpLiteral(
+ driver->newStringRef(lexer->regExpPattern()), lexer->regExpFlags());
node->literalToken = loc(1);
sym(1).Node = node;
} break;
loc(1).length = lexer->tokenLength();
- AST::RegExpLiteral *node = makeAstNode<AST::RegExpLiteral> (driver->nodePool(), lexer->pattern, lexer->flags);
+ AST::RegExpLiteral *node = new (pool) AST::RegExpLiteral(
+ driver->newStringRef(lexer->regExpPattern()), lexer->regExpFlags());
node->literalToken = loc(1);
sym(1).Node = node;
} break;
PrimaryExpression: T_LBRACKET T_RBRACKET ;
/.
case $rule_number: {
- AST::ArrayLiteral *node = makeAstNode<AST::ArrayLiteral> (driver->nodePool(), (AST::Elision *) 0);
+ AST::ArrayLiteral *node = new (pool) AST::ArrayLiteral((AST::Elision *) 0);
node->lbracketToken = loc(1);
node->rbracketToken = loc(2);
sym(1).Node = node;
PrimaryExpression: T_LBRACKET Elision T_RBRACKET ;
/.
case $rule_number: {
- AST::ArrayLiteral *node = makeAstNode<AST::ArrayLiteral> (driver->nodePool(), sym(2).Elision->finish());
+ AST::ArrayLiteral *node = new (pool) AST::ArrayLiteral(sym(2).Elision->finish());
node->lbracketToken = loc(1);
node->rbracketToken = loc(3);
sym(1).Node = node;
PrimaryExpression: T_LBRACKET ElementList T_RBRACKET ;
/.
case $rule_number: {
- AST::ArrayLiteral *node = makeAstNode<AST::ArrayLiteral> (driver->nodePool(), sym(2).ElementList->finish ());
+ AST::ArrayLiteral *node = new (pool) AST::ArrayLiteral(sym(2).ElementList->finish ());
node->lbracketToken = loc(1);
node->rbracketToken = loc(3);
sym(1).Node = node;
PrimaryExpression: T_LBRACKET ElementList T_COMMA T_RBRACKET ;
/.
case $rule_number: {
- AST::ArrayLiteral *node = makeAstNode<AST::ArrayLiteral> (driver->nodePool(), sym(2).ElementList->finish (),
+ AST::ArrayLiteral *node = new (pool) AST::ArrayLiteral(sym(2).ElementList->finish (),
(AST::Elision *) 0);
node->lbracketToken = loc(1);
node->commaToken = loc(3);
PrimaryExpression: T_LBRACKET ElementList T_COMMA Elision T_RBRACKET ;
/.
case $rule_number: {
- AST::ArrayLiteral *node = makeAstNode<AST::ArrayLiteral> (driver->nodePool(), sym(2).ElementList->finish (),
+ AST::ArrayLiteral *node = new (pool) AST::ArrayLiteral(sym(2).ElementList->finish (),
sym(4).Elision->finish());
node->lbracketToken = loc(1);
node->commaToken = loc(3);
-- PrimaryExpression: T_LBRACE T_RBRACE ;
-- /.
-- case $rule_number: {
--- sym(1).Node = makeAstNode<AST::ObjectLiteral> (driver->nodePool());
+-- sym(1).Node = new (pool) AST::ObjectLiteral();
-- } break;
-- ./
case $rule_number: {
AST::ObjectLiteral *node = 0;
if (sym(2).Node)
- node = makeAstNode<AST::ObjectLiteral> (driver->nodePool(),
+ node = new (pool) AST::ObjectLiteral(
sym(2).PropertyNameAndValueList->finish ());
else
- node = makeAstNode<AST::ObjectLiteral> (driver->nodePool());
+ node = new (pool) AST::ObjectLiteral();
node->lbraceToken = loc(1);
node->rbraceToken = loc(3);
sym(1).Node = node;
PrimaryExpression: T_LBRACE PropertyNameAndValueList T_COMMA T_RBRACE ;
/.
case $rule_number: {
- AST::ObjectLiteral *node = makeAstNode<AST::ObjectLiteral> (driver->nodePool(),
+ AST::ObjectLiteral *node = new (pool) AST::ObjectLiteral(
sym(2).PropertyNameAndValueList->finish ());
node->lbraceToken = loc(1);
node->rbraceToken = loc(4);
PrimaryExpression: T_LPAREN Expression T_RPAREN ;
/.
case $rule_number: {
- AST::NestedExpression *node = makeAstNode<AST::NestedExpression>(driver->nodePool(), sym(2).Expression);
+ AST::NestedExpression *node = new (pool) AST::NestedExpression(sym(2).Expression);
node->lparenToken = loc(1);
node->rparenToken = loc(3);
sym(1).Node = node;
ElementList: AssignmentExpression ;
/.
case $rule_number: {
- sym(1).Node = makeAstNode<AST::ElementList> (driver->nodePool(), (AST::Elision *) 0, sym(1).Expression);
+ sym(1).Node = new (pool) AST::ElementList((AST::Elision *) 0, sym(1).Expression);
} break;
./
ElementList: Elision AssignmentExpression ;
/.
case $rule_number: {
- sym(1).Node = makeAstNode<AST::ElementList> (driver->nodePool(), sym(1).Elision->finish(), sym(2).Expression);
+ sym(1).Node = new (pool) AST::ElementList(sym(1).Elision->finish(), sym(2).Expression);
} break;
./
ElementList: ElementList T_COMMA AssignmentExpression ;
/.
case $rule_number: {
- AST::ElementList *node = makeAstNode<AST::ElementList> (driver->nodePool(), sym(1).ElementList,
+ AST::ElementList *node = new (pool) AST::ElementList(sym(1).ElementList,
(AST::Elision *) 0, sym(3).Expression);
node->commaToken = loc(2);
sym(1).Node = node;
ElementList: ElementList T_COMMA Elision AssignmentExpression ;
/.
case $rule_number: {
- AST::ElementList *node = makeAstNode<AST::ElementList> (driver->nodePool(), sym(1).ElementList, sym(3).Elision->finish(),
+ AST::ElementList *node = new (pool) AST::ElementList(sym(1).ElementList, sym(3).Elision->finish(),
sym(4).Expression);
node->commaToken = loc(2);
sym(1).Node = node;
Elision: T_COMMA ;
/.
case $rule_number: {
- AST::Elision *node = makeAstNode<AST::Elision> (driver->nodePool());
+ AST::Elision *node = new (pool) AST::Elision();
node->commaToken = loc(1);
sym(1).Node = node;
} break;
Elision: Elision T_COMMA ;
/.
case $rule_number: {
- AST::Elision *node = makeAstNode<AST::Elision> (driver->nodePool(), sym(1).Elision);
+ AST::Elision *node = new (pool) AST::Elision(sym(1).Elision);
node->commaToken = loc(2);
sym(1).Node = node;
} break;
PropertyNameAndValueList: PropertyName T_COLON AssignmentExpression ;
/.
case $rule_number: {
- AST::PropertyNameAndValueList *node = makeAstNode<AST::PropertyNameAndValueList> (driver->nodePool(),
+ AST::PropertyNameAndValueList *node = new (pool) AST::PropertyNameAndValueList(
sym(1).PropertyName, sym(3).Expression);
node->colonToken = loc(2);
sym(1).Node = node;
PropertyNameAndValueList: PropertyNameAndValueList T_COMMA PropertyName T_COLON AssignmentExpression ;
/.
case $rule_number: {
- AST::PropertyNameAndValueList *node = makeAstNode<AST::PropertyNameAndValueList> (driver->nodePool(),
+ AST::PropertyNameAndValueList *node = new (pool) AST::PropertyNameAndValueList(
sym(1).PropertyNameAndValueList, sym(3).PropertyName, sym(5).Expression);
node->commaToken = loc(2);
node->colonToken = loc(4);
PropertyName: T_IDENTIFIER %prec SHIFT_THERE ;
/.
case $rule_number: {
- AST::IdentifierPropertyName *node = makeAstNode<AST::IdentifierPropertyName> (driver->nodePool(), sym(1).sval);
+ AST::IdentifierPropertyName *node = new (pool) AST::IdentifierPropertyName(stringRef(1));
node->propertyNameToken = loc(1);
sym(1).Node = node;
} break;
PropertyName: T_PROPERTY ;
/.
case $rule_number: {
- AST::IdentifierPropertyName *node = makeAstNode<AST::IdentifierPropertyName> (driver->nodePool(), driver->intern(lexer->characterBuffer(), lexer->characterCount()));
+ AST::IdentifierPropertyName *node = new (pool) AST::IdentifierPropertyName(stringRef(1));
node->propertyNameToken = loc(1);
sym(1).Node = node;
} break;
PropertyName: T_STRING_LITERAL ;
/.
case $rule_number: {
- AST::StringLiteralPropertyName *node = makeAstNode<AST::StringLiteralPropertyName> (driver->nodePool(), sym(1).sval);
+ AST::StringLiteralPropertyName *node = new (pool) AST::StringLiteralPropertyName(stringRef(1));
node->propertyNameToken = loc(1);
sym(1).Node = node;
} break;
PropertyName: T_NUMERIC_LITERAL ;
/.
case $rule_number: {
- AST::NumericLiteralPropertyName *node = makeAstNode<AST::NumericLiteralPropertyName> (driver->nodePool(), sym(1).dval);
+ AST::NumericLiteralPropertyName *node = new (pool) AST::NumericLiteralPropertyName(sym(1).dval);
node->propertyNameToken = loc(1);
sym(1).Node = node;
} break;
PropertyName: ReservedIdentifier ;
/.
case $rule_number: {
- AST::IdentifierPropertyName *node = makeAstNode<AST::IdentifierPropertyName> (driver->nodePool(), sym(1).sval);
+ AST::IdentifierPropertyName *node = new (pool) AST::IdentifierPropertyName(stringRef(1));
node->propertyNameToken = loc(1);
sym(1).Node = node;
} break;
./
ReservedIdentifier: T_BREAK ;
-/.
-case $rule_number:
-./
ReservedIdentifier: T_CASE ;
-/.
-case $rule_number:
-./
ReservedIdentifier: T_CATCH ;
-/.
-case $rule_number:
-./
ReservedIdentifier: T_CONTINUE ;
-/.
-case $rule_number:
-./
ReservedIdentifier: T_DEFAULT ;
-/.
-case $rule_number:
-./
ReservedIdentifier: T_DELETE ;
-/.
-case $rule_number:
-./
ReservedIdentifier: T_DO ;
-/.
-case $rule_number:
-./
ReservedIdentifier: T_ELSE ;
-/.
-case $rule_number:
-./
ReservedIdentifier: T_FALSE ;
-/.
-case $rule_number:
-./
ReservedIdentifier: T_FINALLY ;
-/.
-case $rule_number:
-./
ReservedIdentifier: T_FOR ;
-/.
-case $rule_number:
-./
ReservedIdentifier: T_FUNCTION ;
-/.
-case $rule_number:
-./
ReservedIdentifier: T_IF ;
-/.
-case $rule_number:
-./
ReservedIdentifier: T_IN ;
-/.
-case $rule_number:
-./
ReservedIdentifier: T_INSTANCEOF ;
-/.
-case $rule_number:
-./
ReservedIdentifier: T_NEW ;
-/.
-case $rule_number:
-./
ReservedIdentifier: T_NULL ;
-/.
-case $rule_number:
-./
ReservedIdentifier: T_RETURN ;
-/.
-case $rule_number:
-./
ReservedIdentifier: T_SWITCH ;
-/.
-case $rule_number:
-./
ReservedIdentifier: T_THIS ;
-/.
-case $rule_number:
-./
ReservedIdentifier: T_THROW ;
-/.
-case $rule_number:
-./
ReservedIdentifier: T_TRUE ;
-/.
-case $rule_number:
-./
ReservedIdentifier: T_TRY ;
-/.
-case $rule_number:
-./
ReservedIdentifier: T_TYPEOF ;
-/.
-case $rule_number:
-./
ReservedIdentifier: T_VAR ;
-/.
-case $rule_number:
-./
ReservedIdentifier: T_VOID ;
-/.
-case $rule_number:
-./
ReservedIdentifier: T_WHILE ;
-/.
-case $rule_number:
-./
ReservedIdentifier: T_CONST ;
-/.
-case $rule_number:
-./
ReservedIdentifier: T_DEBUGGER ;
-/.
-case $rule_number:
-./
ReservedIdentifier: T_RESERVED_WORD ;
-/.
-case $rule_number:
-./
ReservedIdentifier: T_WITH ;
-/.
-case $rule_number:
-{
- sym(1).sval = driver->intern(lexer->characterBuffer(), lexer->characterCount());
-} break;
-./
PropertyIdentifier: JsIdentifier ;
PropertyIdentifier: ReservedIdentifier ;
MemberExpression: MemberExpression T_LBRACKET Expression T_RBRACKET ;
/.
case $rule_number: {
- AST::ArrayMemberExpression *node = makeAstNode<AST::ArrayMemberExpression> (driver->nodePool(), sym(1).Expression, sym(3).Expression);
+ AST::ArrayMemberExpression *node = new (pool) AST::ArrayMemberExpression(sym(1).Expression, sym(3).Expression);
node->lbracketToken = loc(2);
node->rbracketToken = loc(4);
sym(1).Node = node;
MemberExpression: MemberExpression T_DOT PropertyIdentifier ;
/.
case $rule_number: {
- AST::FieldMemberExpression *node = makeAstNode<AST::FieldMemberExpression> (driver->nodePool(), sym(1).Expression, sym(3).sval);
+ AST::FieldMemberExpression *node = new (pool) AST::FieldMemberExpression(sym(1).Expression, stringRef(3));
node->dotToken = loc(2);
node->identifierToken = loc(3);
sym(1).Node = node;
MemberExpression: T_NEW MemberExpression T_LPAREN ArgumentListOpt T_RPAREN ;
/.
case $rule_number: {
- AST::NewMemberExpression *node = makeAstNode<AST::NewMemberExpression> (driver->nodePool(), sym(2).Expression, sym(4).ArgumentList);
+ AST::NewMemberExpression *node = new (pool) AST::NewMemberExpression(sym(2).Expression, sym(4).ArgumentList);
node->newToken = loc(1);
node->lparenToken = loc(3);
node->rparenToken = loc(5);
NewExpression: T_NEW NewExpression ;
/.
case $rule_number: {
- AST::NewExpression *node = makeAstNode<AST::NewExpression> (driver->nodePool(), sym(2).Expression);
+ AST::NewExpression *node = new (pool) AST::NewExpression(sym(2).Expression);
node->newToken = loc(1);
sym(1).Node = node;
} break;
CallExpression: MemberExpression T_LPAREN ArgumentListOpt T_RPAREN ;
/.
case $rule_number: {
- AST::CallExpression *node = makeAstNode<AST::CallExpression> (driver->nodePool(), sym(1).Expression, sym(3).ArgumentList);
+ AST::CallExpression *node = new (pool) AST::CallExpression(sym(1).Expression, sym(3).ArgumentList);
node->lparenToken = loc(2);
node->rparenToken = loc(4);
sym(1).Node = node;
CallExpression: CallExpression T_LPAREN ArgumentListOpt T_RPAREN ;
/.
case $rule_number: {
- AST::CallExpression *node = makeAstNode<AST::CallExpression> (driver->nodePool(), sym(1).Expression, sym(3).ArgumentList);
+ AST::CallExpression *node = new (pool) AST::CallExpression(sym(1).Expression, sym(3).ArgumentList);
node->lparenToken = loc(2);
node->rparenToken = loc(4);
sym(1).Node = node;
CallExpression: CallExpression T_LBRACKET Expression T_RBRACKET ;
/.
case $rule_number: {
- AST::ArrayMemberExpression *node = makeAstNode<AST::ArrayMemberExpression> (driver->nodePool(), sym(1).Expression, sym(3).Expression);
+ AST::ArrayMemberExpression *node = new (pool) AST::ArrayMemberExpression(sym(1).Expression, sym(3).Expression);
node->lbracketToken = loc(2);
node->rbracketToken = loc(4);
sym(1).Node = node;
CallExpression: CallExpression T_DOT PropertyIdentifier ;
/.
case $rule_number: {
- AST::FieldMemberExpression *node = makeAstNode<AST::FieldMemberExpression> (driver->nodePool(), sym(1).Expression, sym(3).sval);
+ AST::FieldMemberExpression *node = new (pool) AST::FieldMemberExpression(sym(1).Expression, stringRef(3));
node->dotToken = loc(2);
node->identifierToken = loc(3);
sym(1).Node = node;
ArgumentList: AssignmentExpression ;
/.
case $rule_number: {
- sym(1).Node = makeAstNode<AST::ArgumentList> (driver->nodePool(), sym(1).Expression);
+ sym(1).Node = new (pool) AST::ArgumentList(sym(1).Expression);
} break;
./
ArgumentList: ArgumentList T_COMMA AssignmentExpression ;
/.
case $rule_number: {
- AST::ArgumentList *node = makeAstNode<AST::ArgumentList> (driver->nodePool(), sym(1).ArgumentList, sym(3).Expression);
+ AST::ArgumentList *node = new (pool) AST::ArgumentList(sym(1).ArgumentList, sym(3).Expression);
node->commaToken = loc(2);
sym(1).Node = node;
} break;
PostfixExpression: LeftHandSideExpression T_PLUS_PLUS ;
/.
case $rule_number: {
- AST::PostIncrementExpression *node = makeAstNode<AST::PostIncrementExpression> (driver->nodePool(), sym(1).Expression);
+ AST::PostIncrementExpression *node = new (pool) AST::PostIncrementExpression(sym(1).Expression);
node->incrementToken = loc(2);
sym(1).Node = node;
} break;
PostfixExpression: LeftHandSideExpression T_MINUS_MINUS ;
/.
case $rule_number: {
- AST::PostDecrementExpression *node = makeAstNode<AST::PostDecrementExpression> (driver->nodePool(), sym(1).Expression);
+ AST::PostDecrementExpression *node = new (pool) AST::PostDecrementExpression(sym(1).Expression);
node->decrementToken = loc(2);
sym(1).Node = node;
} break;
UnaryExpression: T_DELETE UnaryExpression ;
/.
case $rule_number: {
- AST::DeleteExpression *node = makeAstNode<AST::DeleteExpression> (driver->nodePool(), sym(2).Expression);
+ AST::DeleteExpression *node = new (pool) AST::DeleteExpression(sym(2).Expression);
node->deleteToken = loc(1);
sym(1).Node = node;
} break;
UnaryExpression: T_VOID UnaryExpression ;
/.
case $rule_number: {
- AST::VoidExpression *node = makeAstNode<AST::VoidExpression> (driver->nodePool(), sym(2).Expression);
+ AST::VoidExpression *node = new (pool) AST::VoidExpression(sym(2).Expression);
node->voidToken = loc(1);
sym(1).Node = node;
} break;
UnaryExpression: T_TYPEOF UnaryExpression ;
/.
case $rule_number: {
- AST::TypeOfExpression *node = makeAstNode<AST::TypeOfExpression> (driver->nodePool(), sym(2).Expression);
+ AST::TypeOfExpression *node = new (pool) AST::TypeOfExpression(sym(2).Expression);
node->typeofToken = loc(1);
sym(1).Node = node;
} break;
UnaryExpression: T_PLUS_PLUS UnaryExpression ;
/.
case $rule_number: {
- AST::PreIncrementExpression *node = makeAstNode<AST::PreIncrementExpression> (driver->nodePool(), sym(2).Expression);
+ AST::PreIncrementExpression *node = new (pool) AST::PreIncrementExpression(sym(2).Expression);
node->incrementToken = loc(1);
sym(1).Node = node;
} break;
UnaryExpression: T_MINUS_MINUS UnaryExpression ;
/.
case $rule_number: {
- AST::PreDecrementExpression *node = makeAstNode<AST::PreDecrementExpression> (driver->nodePool(), sym(2).Expression);
+ AST::PreDecrementExpression *node = new (pool) AST::PreDecrementExpression(sym(2).Expression);
node->decrementToken = loc(1);
sym(1).Node = node;
} break;
UnaryExpression: T_PLUS UnaryExpression ;
/.
case $rule_number: {
- AST::UnaryPlusExpression *node = makeAstNode<AST::UnaryPlusExpression> (driver->nodePool(), sym(2).Expression);
+ AST::UnaryPlusExpression *node = new (pool) AST::UnaryPlusExpression(sym(2).Expression);
node->plusToken = loc(1);
sym(1).Node = node;
} break;
UnaryExpression: T_MINUS UnaryExpression ;
/.
case $rule_number: {
- AST::UnaryMinusExpression *node = makeAstNode<AST::UnaryMinusExpression> (driver->nodePool(), sym(2).Expression);
+ AST::UnaryMinusExpression *node = new (pool) AST::UnaryMinusExpression(sym(2).Expression);
node->minusToken = loc(1);
sym(1).Node = node;
} break;
UnaryExpression: T_TILDE UnaryExpression ;
/.
case $rule_number: {
- AST::TildeExpression *node = makeAstNode<AST::TildeExpression> (driver->nodePool(), sym(2).Expression);
+ AST::TildeExpression *node = new (pool) AST::TildeExpression(sym(2).Expression);
node->tildeToken = loc(1);
sym(1).Node = node;
} break;
UnaryExpression: T_NOT UnaryExpression ;
/.
case $rule_number: {
- AST::NotExpression *node = makeAstNode<AST::NotExpression> (driver->nodePool(), sym(2).Expression);
+ AST::NotExpression *node = new (pool) AST::NotExpression(sym(2).Expression);
node->notToken = loc(1);
sym(1).Node = node;
} break;
MultiplicativeExpression: MultiplicativeExpression T_STAR UnaryExpression ;
/.
case $rule_number: {
- AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+ AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
QSOperator::Mul, sym(3).Expression);
node->operatorToken = loc(2);
sym(1).Node = node;
MultiplicativeExpression: MultiplicativeExpression T_DIVIDE_ UnaryExpression ;
/.
case $rule_number: {
- AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+ AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
QSOperator::Div, sym(3).Expression);
node->operatorToken = loc(2);
sym(1).Node = node;
MultiplicativeExpression: MultiplicativeExpression T_REMAINDER UnaryExpression ;
/.
case $rule_number: {
- AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+ AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
QSOperator::Mod, sym(3).Expression);
node->operatorToken = loc(2);
sym(1).Node = node;
AdditiveExpression: AdditiveExpression T_PLUS MultiplicativeExpression ;
/.
case $rule_number: {
- AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+ AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
QSOperator::Add, sym(3).Expression);
node->operatorToken = loc(2);
sym(1).Node = node;
AdditiveExpression: AdditiveExpression T_MINUS MultiplicativeExpression ;
/.
case $rule_number: {
- AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+ AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
QSOperator::Sub, sym(3).Expression);
node->operatorToken = loc(2);
sym(1).Node = node;
ShiftExpression: ShiftExpression T_LT_LT AdditiveExpression ;
/.
case $rule_number: {
- AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+ AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
QSOperator::LShift, sym(3).Expression);
node->operatorToken = loc(2);
sym(1).Node = node;
ShiftExpression: ShiftExpression T_GT_GT AdditiveExpression ;
/.
case $rule_number: {
- AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+ AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
QSOperator::RShift, sym(3).Expression);
node->operatorToken = loc(2);
sym(1).Node = node;
ShiftExpression: ShiftExpression T_GT_GT_GT AdditiveExpression ;
/.
case $rule_number: {
- AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+ AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
QSOperator::URShift, sym(3).Expression);
node->operatorToken = loc(2);
sym(1).Node = node;
RelationalExpression: RelationalExpression T_LT ShiftExpression ;
/.
case $rule_number: {
- AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+ AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
QSOperator::Lt, sym(3).Expression);
node->operatorToken = loc(2);
sym(1).Node = node;
RelationalExpression: RelationalExpression T_GT ShiftExpression ;
/.
case $rule_number: {
- AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+ AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
QSOperator::Gt, sym(3).Expression);
node->operatorToken = loc(2);
sym(1).Node = node;
RelationalExpression: RelationalExpression T_LE ShiftExpression ;
/.
case $rule_number: {
- AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+ AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
QSOperator::Le, sym(3).Expression);
node->operatorToken = loc(2);
sym(1).Node = node;
RelationalExpression: RelationalExpression T_GE ShiftExpression ;
/.
case $rule_number: {
- AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+ AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
QSOperator::Ge, sym(3).Expression);
node->operatorToken = loc(2);
sym(1).Node = node;
RelationalExpression: RelationalExpression T_INSTANCEOF ShiftExpression ;
/.
case $rule_number: {
- AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+ AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
QSOperator::InstanceOf, sym(3).Expression);
node->operatorToken = loc(2);
sym(1).Node = node;
RelationalExpression: RelationalExpression T_IN ShiftExpression ;
/.
case $rule_number: {
- AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+ AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
QSOperator::In, sym(3).Expression);
node->operatorToken = loc(2);
sym(1).Node = node;
RelationalExpressionNotIn: RelationalExpressionNotIn T_LT ShiftExpression ;
/.
case $rule_number: {
- AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+ AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
QSOperator::Lt, sym(3).Expression);
node->operatorToken = loc(2);
sym(1).Node = node;
RelationalExpressionNotIn: RelationalExpressionNotIn T_GT ShiftExpression ;
/.
case $rule_number: {
- AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+ AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
QSOperator::Gt, sym(3).Expression);
node->operatorToken = loc(2);
sym(1).Node = node;
RelationalExpressionNotIn: RelationalExpressionNotIn T_LE ShiftExpression ;
/.
case $rule_number: {
- AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+ AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
QSOperator::Le, sym(3).Expression);
node->operatorToken = loc(2);
sym(1).Node = node;
RelationalExpressionNotIn: RelationalExpressionNotIn T_GE ShiftExpression ;
/.
case $rule_number: {
- AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+ AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
QSOperator::Ge, sym(3).Expression);
node->operatorToken = loc(2);
sym(1).Node = node;
RelationalExpressionNotIn: RelationalExpressionNotIn T_INSTANCEOF ShiftExpression ;
/.
case $rule_number: {
- AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+ AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
QSOperator::InstanceOf, sym(3).Expression);
node->operatorToken = loc(2);
sym(1).Node = node;
EqualityExpression: EqualityExpression T_EQ_EQ RelationalExpression ;
/.
case $rule_number: {
- AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+ AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
QSOperator::Equal, sym(3).Expression);
node->operatorToken = loc(2);
sym(1).Node = node;
EqualityExpression: EqualityExpression T_NOT_EQ RelationalExpression ;
/.
case $rule_number: {
- AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+ AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
QSOperator::NotEqual, sym(3).Expression);
node->operatorToken = loc(2);
sym(1).Node = node;
EqualityExpression: EqualityExpression T_EQ_EQ_EQ RelationalExpression ;
/.
case $rule_number: {
- AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+ AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
QSOperator::StrictEqual, sym(3).Expression);
node->operatorToken = loc(2);
sym(1).Node = node;
EqualityExpression: EqualityExpression T_NOT_EQ_EQ RelationalExpression ;
/.
case $rule_number: {
- AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+ AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
QSOperator::StrictNotEqual, sym(3).Expression);
node->operatorToken = loc(2);
sym(1).Node = node;
EqualityExpressionNotIn: EqualityExpressionNotIn T_EQ_EQ RelationalExpressionNotIn ;
/.
case $rule_number: {
- AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+ AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
QSOperator::Equal, sym(3).Expression);
node->operatorToken = loc(2);
sym(1).Node = node;
EqualityExpressionNotIn: EqualityExpressionNotIn T_NOT_EQ RelationalExpressionNotIn;
/.
case $rule_number: {
- AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+ AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
QSOperator::NotEqual, sym(3).Expression);
node->operatorToken = loc(2);
sym(1).Node = node;
EqualityExpressionNotIn: EqualityExpressionNotIn T_EQ_EQ_EQ RelationalExpressionNotIn ;
/.
case $rule_number: {
- AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+ AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
QSOperator::StrictEqual, sym(3).Expression);
node->operatorToken = loc(2);
sym(1).Node = node;
EqualityExpressionNotIn: EqualityExpressionNotIn T_NOT_EQ_EQ RelationalExpressionNotIn ;
/.
case $rule_number: {
- AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+ AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
QSOperator::StrictNotEqual, sym(3).Expression);
node->operatorToken = loc(2);
sym(1).Node = node;
BitwiseANDExpression: BitwiseANDExpression T_AND EqualityExpression ;
/.
case $rule_number: {
- AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+ AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
QSOperator::BitAnd, sym(3).Expression);
node->operatorToken = loc(2);
sym(1).Node = node;
BitwiseANDExpressionNotIn: BitwiseANDExpressionNotIn T_AND EqualityExpressionNotIn ;
/.
case $rule_number: {
- AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+ AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
QSOperator::BitAnd, sym(3).Expression);
node->operatorToken = loc(2);
sym(1).Node = node;
BitwiseXORExpression: BitwiseXORExpression T_XOR BitwiseANDExpression ;
/.
case $rule_number: {
- AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+ AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
QSOperator::BitXor, sym(3).Expression);
node->operatorToken = loc(2);
sym(1).Node = node;
BitwiseXORExpressionNotIn: BitwiseXORExpressionNotIn T_XOR BitwiseANDExpressionNotIn ;
/.
case $rule_number: {
- AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+ AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
QSOperator::BitXor, sym(3).Expression);
node->operatorToken = loc(2);
sym(1).Node = node;
BitwiseORExpression: BitwiseORExpression T_OR BitwiseXORExpression ;
/.
case $rule_number: {
- AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+ AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
QSOperator::BitOr, sym(3).Expression);
node->operatorToken = loc(2);
sym(1).Node = node;
BitwiseORExpressionNotIn: BitwiseORExpressionNotIn T_OR BitwiseXORExpressionNotIn ;
/.
case $rule_number: {
- AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+ AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
QSOperator::BitOr, sym(3).Expression);
node->operatorToken = loc(2);
sym(1).Node = node;
LogicalANDExpression: LogicalANDExpression T_AND_AND BitwiseORExpression ;
/.
case $rule_number: {
- AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+ AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
QSOperator::And, sym(3).Expression);
node->operatorToken = loc(2);
sym(1).Node = node;
LogicalANDExpressionNotIn: LogicalANDExpressionNotIn T_AND_AND BitwiseORExpressionNotIn ;
/.
case $rule_number: {
- AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+ AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
QSOperator::And, sym(3).Expression);
node->operatorToken = loc(2);
sym(1).Node = node;
LogicalORExpression: LogicalORExpression T_OR_OR LogicalANDExpression ;
/.
case $rule_number: {
- AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+ AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
QSOperator::Or, sym(3).Expression);
node->operatorToken = loc(2);
sym(1).Node = node;
LogicalORExpressionNotIn: LogicalORExpressionNotIn T_OR_OR LogicalANDExpressionNotIn ;
/.
case $rule_number: {
- AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+ AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
QSOperator::Or, sym(3).Expression);
node->operatorToken = loc(2);
sym(1).Node = node;
ConditionalExpression: LogicalORExpression T_QUESTION AssignmentExpression T_COLON AssignmentExpression ;
/.
case $rule_number: {
- AST::ConditionalExpression *node = makeAstNode<AST::ConditionalExpression> (driver->nodePool(), sym(1).Expression,
+ AST::ConditionalExpression *node = new (pool) AST::ConditionalExpression(sym(1).Expression,
sym(3).Expression, sym(5).Expression);
node->questionToken = loc(2);
node->colonToken = loc(4);
ConditionalExpressionNotIn: LogicalORExpressionNotIn T_QUESTION AssignmentExpressionNotIn T_COLON AssignmentExpressionNotIn ;
/.
case $rule_number: {
- AST::ConditionalExpression *node = makeAstNode<AST::ConditionalExpression> (driver->nodePool(), sym(1).Expression,
+ AST::ConditionalExpression *node = new (pool) AST::ConditionalExpression(sym(1).Expression,
sym(3).Expression, sym(5).Expression);
node->questionToken = loc(2);
node->colonToken = loc(4);
AssignmentExpression: LeftHandSideExpression AssignmentOperator AssignmentExpression ;
/.
case $rule_number: {
- AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+ AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
sym(2).ival, sym(3).Expression);
node->operatorToken = loc(2);
sym(1).Node = node;
AssignmentExpressionNotIn: LeftHandSideExpression AssignmentOperator AssignmentExpressionNotIn ;
/.
case $rule_number: {
- AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+ AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
sym(2).ival, sym(3).Expression);
node->operatorToken = loc(2);
sym(1).Node = node;
Expression: Expression T_COMMA AssignmentExpression ;
/.
case $rule_number: {
- AST::Expression *node = makeAstNode<AST::Expression> (driver->nodePool(), sym(1).Expression, sym(3).Expression);
+ AST::Expression *node = new (pool) AST::Expression(sym(1).Expression, sym(3).Expression);
node->commaToken = loc(2);
sym(1).Node = node;
} break;
ExpressionNotIn: ExpressionNotIn T_COMMA AssignmentExpressionNotIn ;
/.
case $rule_number: {
- AST::Expression *node = makeAstNode<AST::Expression> (driver->nodePool(), sym(1).Expression, sym(3).Expression);
+ AST::Expression *node = new (pool) AST::Expression(sym(1).Expression, sym(3).Expression);
node->commaToken = loc(2);
sym(1).Node = node;
} break;
Block: T_LBRACE StatementListOpt T_RBRACE ;
/.
case $rule_number: {
- AST::Block *node = makeAstNode<AST::Block> (driver->nodePool(), sym(2).StatementList);
+ AST::Block *node = new (pool) AST::Block(sym(2).StatementList);
node->lbraceToken = loc(1);
node->rbraceToken = loc(3);
sym(1).Node = node;
StatementList: Statement ;
/.
case $rule_number: {
- sym(1).Node = makeAstNode<AST::StatementList> (driver->nodePool(), sym(1).Statement);
+ sym(1).Node = new (pool) AST::StatementList(sym(1).Statement);
} break;
./
StatementList: StatementList Statement ;
/.
case $rule_number: {
- sym(1).Node = makeAstNode<AST::StatementList> (driver->nodePool(), sym(1).StatementList, sym(2).Statement);
+ sym(1).Node = new (pool) AST::StatementList(sym(1).StatementList, sym(2).Statement);
} break;
./
VariableStatement: VariableDeclarationKind VariableDeclarationList T_SEMICOLON ;
/.
case $rule_number: {
- AST::VariableStatement *node = makeAstNode<AST::VariableStatement> (driver->nodePool(),
+ AST::VariableStatement *node = new (pool) AST::VariableStatement(
sym(2).VariableDeclarationList->finish (/*readOnly=*/sym(1).ival == T_CONST));
node->declarationKindToken = loc(1);
node->semicolonToken = loc(3);
VariableDeclarationList: VariableDeclaration ;
/.
case $rule_number: {
- sym(1).Node = makeAstNode<AST::VariableDeclarationList> (driver->nodePool(), sym(1).VariableDeclaration);
+ sym(1).Node = new (pool) AST::VariableDeclarationList(sym(1).VariableDeclaration);
} break;
./
VariableDeclarationList: VariableDeclarationList T_COMMA VariableDeclaration ;
/.
case $rule_number: {
- AST::VariableDeclarationList *node = makeAstNode<AST::VariableDeclarationList> (driver->nodePool(),
+ AST::VariableDeclarationList *node = new (pool) AST::VariableDeclarationList(
sym(1).VariableDeclarationList, sym(3).VariableDeclaration);
node->commaToken = loc(2);
sym(1).Node = node;
VariableDeclarationListNotIn: VariableDeclarationNotIn ;
/.
case $rule_number: {
- sym(1).Node = makeAstNode<AST::VariableDeclarationList> (driver->nodePool(), sym(1).VariableDeclaration);
+ sym(1).Node = new (pool) AST::VariableDeclarationList(sym(1).VariableDeclaration);
} break;
./
VariableDeclarationListNotIn: VariableDeclarationListNotIn T_COMMA VariableDeclarationNotIn ;
/.
case $rule_number: {
- sym(1).Node = makeAstNode<AST::VariableDeclarationList> (driver->nodePool(), sym(1).VariableDeclarationList, sym(3).VariableDeclaration);
+ sym(1).Node = new (pool) AST::VariableDeclarationList(sym(1).VariableDeclarationList, sym(3).VariableDeclaration);
} break;
./
VariableDeclaration: JsIdentifier InitialiserOpt ;
/.
case $rule_number: {
- AST::VariableDeclaration *node = makeAstNode<AST::VariableDeclaration> (driver->nodePool(), sym(1).sval, sym(2).Expression);
+ AST::VariableDeclaration *node = new (pool) AST::VariableDeclaration(stringRef(1), sym(2).Expression);
node->identifierToken = loc(1);
sym(1).Node = node;
} break;
VariableDeclarationNotIn: JsIdentifier InitialiserNotInOpt ;
/.
case $rule_number: {
- AST::VariableDeclaration *node = makeAstNode<AST::VariableDeclaration> (driver->nodePool(), sym(1).sval, sym(2).Expression);
+ AST::VariableDeclaration *node = new (pool) AST::VariableDeclaration(stringRef(1), sym(2).Expression);
node->identifierToken = loc(1);
sym(1).Node = node;
} break;
EmptyStatement: T_SEMICOLON ;
/.
case $rule_number: {
- AST::EmptyStatement *node = makeAstNode<AST::EmptyStatement> (driver->nodePool());
+ AST::EmptyStatement *node = new (pool) AST::EmptyStatement();
node->semicolonToken = loc(1);
sym(1).Node = node;
} break;
ExpressionStatement: Expression T_SEMICOLON ;
/.
case $rule_number: {
- AST::ExpressionStatement *node = makeAstNode<AST::ExpressionStatement> (driver->nodePool(), sym(1).Expression);
+ AST::ExpressionStatement *node = new (pool) AST::ExpressionStatement(sym(1).Expression);
node->semicolonToken = loc(2);
sym(1).Node = node;
} break;
IfStatement: T_IF T_LPAREN Expression T_RPAREN Statement T_ELSE Statement ;
/.
case $rule_number: {
- AST::IfStatement *node = makeAstNode<AST::IfStatement> (driver->nodePool(), sym(3).Expression, sym(5).Statement, sym(7).Statement);
+ AST::IfStatement *node = new (pool) AST::IfStatement(sym(3).Expression, sym(5).Statement, sym(7).Statement);
node->ifToken = loc(1);
node->lparenToken = loc(2);
node->rparenToken = loc(4);
IfStatement: T_IF T_LPAREN Expression T_RPAREN Statement ;
/.
case $rule_number: {
- AST::IfStatement *node = makeAstNode<AST::IfStatement> (driver->nodePool(), sym(3).Expression, sym(5).Statement);
+ AST::IfStatement *node = new (pool) AST::IfStatement(sym(3).Expression, sym(5).Statement);
node->ifToken = loc(1);
node->lparenToken = loc(2);
node->rparenToken = loc(4);
IterationStatement: T_DO Statement T_WHILE T_LPAREN Expression T_RPAREN T_SEMICOLON ;
/.
case $rule_number: {
- AST::DoWhileStatement *node = makeAstNode<AST::DoWhileStatement> (driver->nodePool(), sym(2).Statement, sym(5).Expression);
+ AST::DoWhileStatement *node = new (pool) AST::DoWhileStatement(sym(2).Statement, sym(5).Expression);
node->doToken = loc(1);
node->whileToken = loc(3);
node->lparenToken = loc(4);
IterationStatement: T_WHILE T_LPAREN Expression T_RPAREN Statement ;
/.
case $rule_number: {
- AST::WhileStatement *node = makeAstNode<AST::WhileStatement> (driver->nodePool(), sym(3).Expression, sym(5).Statement);
+ AST::WhileStatement *node = new (pool) AST::WhileStatement(sym(3).Expression, sym(5).Statement);
node->whileToken = loc(1);
node->lparenToken = loc(2);
node->rparenToken = loc(4);
IterationStatement: T_FOR T_LPAREN ExpressionNotInOpt T_SEMICOLON ExpressionOpt T_SEMICOLON ExpressionOpt T_RPAREN Statement ;
/.
case $rule_number: {
- AST::ForStatement *node = makeAstNode<AST::ForStatement> (driver->nodePool(), sym(3).Expression,
+ AST::ForStatement *node = new (pool) AST::ForStatement(sym(3).Expression,
sym(5).Expression, sym(7).Expression, sym(9).Statement);
node->forToken = loc(1);
node->lparenToken = loc(2);
IterationStatement: T_FOR T_LPAREN T_VAR VariableDeclarationListNotIn T_SEMICOLON ExpressionOpt T_SEMICOLON ExpressionOpt T_RPAREN Statement ;
/.
case $rule_number: {
- AST::LocalForStatement *node = makeAstNode<AST::LocalForStatement> (driver->nodePool(),
+ AST::LocalForStatement *node = new (pool) AST::LocalForStatement(
sym(4).VariableDeclarationList->finish (/*readOnly=*/false), sym(6).Expression,
sym(8).Expression, sym(10).Statement);
node->forToken = loc(1);
IterationStatement: T_FOR T_LPAREN LeftHandSideExpression T_IN Expression T_RPAREN Statement ;
/.
case $rule_number: {
- AST:: ForEachStatement *node = makeAstNode<AST::ForEachStatement> (driver->nodePool(), sym(3).Expression,
+ AST:: ForEachStatement *node = new (pool) AST::ForEachStatement(sym(3).Expression,
sym(5).Expression, sym(7).Statement);
node->forToken = loc(1);
node->lparenToken = loc(2);
IterationStatement: T_FOR T_LPAREN T_VAR VariableDeclarationNotIn T_IN Expression T_RPAREN Statement ;
/.
case $rule_number: {
- AST::LocalForEachStatement *node = makeAstNode<AST::LocalForEachStatement> (driver->nodePool(),
+ AST::LocalForEachStatement *node = new (pool) AST::LocalForEachStatement(
sym(4).VariableDeclaration, sym(6).Expression, sym(8).Statement);
node->forToken = loc(1);
node->lparenToken = loc(2);
ContinueStatement: T_CONTINUE T_SEMICOLON ;
/.
case $rule_number: {
- AST::ContinueStatement *node = makeAstNode<AST::ContinueStatement> (driver->nodePool());
+ AST::ContinueStatement *node = new (pool) AST::ContinueStatement();
node->continueToken = loc(1);
node->semicolonToken = loc(2);
sym(1).Node = node;
ContinueStatement: T_CONTINUE JsIdentifier T_SEMICOLON ;
/.
case $rule_number: {
- AST::ContinueStatement *node = makeAstNode<AST::ContinueStatement> (driver->nodePool(), sym(2).sval);
+ AST::ContinueStatement *node = new (pool) AST::ContinueStatement(stringRef(2));
node->continueToken = loc(1);
node->identifierToken = loc(2);
node->semicolonToken = loc(3);
BreakStatement: T_BREAK T_SEMICOLON ;
/.
case $rule_number: {
- AST::BreakStatement *node = makeAstNode<AST::BreakStatement> (driver->nodePool());
+ AST::BreakStatement *node = new (pool) AST::BreakStatement(QStringRef());
node->breakToken = loc(1);
node->semicolonToken = loc(2);
sym(1).Node = node;
BreakStatement: T_BREAK JsIdentifier T_SEMICOLON ;
/.
case $rule_number: {
- AST::BreakStatement *node = makeAstNode<AST::BreakStatement> (driver->nodePool(), sym(2).sval);
+ AST::BreakStatement *node = new (pool) AST::BreakStatement(stringRef(2));
node->breakToken = loc(1);
node->identifierToken = loc(2);
node->semicolonToken = loc(3);
ReturnStatement: T_RETURN ExpressionOpt T_SEMICOLON ;
/.
case $rule_number: {
- AST::ReturnStatement *node = makeAstNode<AST::ReturnStatement> (driver->nodePool(), sym(2).Expression);
+ AST::ReturnStatement *node = new (pool) AST::ReturnStatement(sym(2).Expression);
node->returnToken = loc(1);
node->semicolonToken = loc(3);
sym(1).Node = node;
WithStatement: T_WITH T_LPAREN Expression T_RPAREN Statement ;
/.
case $rule_number: {
- AST::WithStatement *node = makeAstNode<AST::WithStatement> (driver->nodePool(), sym(3).Expression, sym(5).Statement);
+ AST::WithStatement *node = new (pool) AST::WithStatement(sym(3).Expression, sym(5).Statement);
node->withToken = loc(1);
node->lparenToken = loc(2);
node->rparenToken = loc(4);
SwitchStatement: T_SWITCH T_LPAREN Expression T_RPAREN CaseBlock ;
/.
case $rule_number: {
- AST::SwitchStatement *node = makeAstNode<AST::SwitchStatement> (driver->nodePool(), sym(3).Expression, sym(5).CaseBlock);
+ AST::SwitchStatement *node = new (pool) AST::SwitchStatement(sym(3).Expression, sym(5).CaseBlock);
node->switchToken = loc(1);
node->lparenToken = loc(2);
node->rparenToken = loc(4);
CaseBlock: T_LBRACE CaseClausesOpt T_RBRACE ;
/.
case $rule_number: {
- AST::CaseBlock *node = makeAstNode<AST::CaseBlock> (driver->nodePool(), sym(2).CaseClauses);
+ AST::CaseBlock *node = new (pool) AST::CaseBlock(sym(2).CaseClauses);
node->lbraceToken = loc(1);
node->rbraceToken = loc(3);
sym(1).Node = node;
CaseBlock: T_LBRACE CaseClausesOpt DefaultClause CaseClausesOpt T_RBRACE ;
/.
case $rule_number: {
- AST::CaseBlock *node = makeAstNode<AST::CaseBlock> (driver->nodePool(), sym(2).CaseClauses, sym(3).DefaultClause, sym(4).CaseClauses);
+ AST::CaseBlock *node = new (pool) AST::CaseBlock(sym(2).CaseClauses, sym(3).DefaultClause, sym(4).CaseClauses);
node->lbraceToken = loc(1);
node->rbraceToken = loc(5);
sym(1).Node = node;
CaseClauses: CaseClause ;
/.
case $rule_number: {
- sym(1).Node = makeAstNode<AST::CaseClauses> (driver->nodePool(), sym(1).CaseClause);
+ sym(1).Node = new (pool) AST::CaseClauses(sym(1).CaseClause);
} break;
./
CaseClauses: CaseClauses CaseClause ;
/.
case $rule_number: {
- sym(1).Node = makeAstNode<AST::CaseClauses> (driver->nodePool(), sym(1).CaseClauses, sym(2).CaseClause);
+ sym(1).Node = new (pool) AST::CaseClauses(sym(1).CaseClauses, sym(2).CaseClause);
} break;
./
CaseClause: T_CASE Expression T_COLON StatementListOpt ;
/.
case $rule_number: {
- AST::CaseClause *node = makeAstNode<AST::CaseClause> (driver->nodePool(), sym(2).Expression, sym(4).StatementList);
+ AST::CaseClause *node = new (pool) AST::CaseClause(sym(2).Expression, sym(4).StatementList);
node->caseToken = loc(1);
node->colonToken = loc(3);
sym(1).Node = node;
DefaultClause: T_DEFAULT T_COLON StatementListOpt ;
/.
case $rule_number: {
- AST::DefaultClause *node = makeAstNode<AST::DefaultClause> (driver->nodePool(), sym(3).StatementList);
+ AST::DefaultClause *node = new (pool) AST::DefaultClause(sym(3).StatementList);
node->defaultToken = loc(1);
node->colonToken = loc(2);
sym(1).Node = node;
LabelledStatement: T_PROPERTY T_COLON Statement ;
/.
case $rule_number: {
- AST::LabelledStatement *node = makeAstNode<AST::LabelledStatement> (driver->nodePool(), driver->intern(lexer->characterBuffer(), lexer->characterCount()), sym(3).Statement);
+ AST::LabelledStatement *node = new (pool) AST::LabelledStatement(stringRef(1), sym(3).Statement);
node->identifierToken = loc(1);
node->colonToken = loc(2);
sym(1).Node = node;
LabelledStatement: T_IDENTIFIER T_COLON Statement ;
/.
case $rule_number: {
- AST::LabelledStatement *node = makeAstNode<AST::LabelledStatement> (driver->nodePool(), sym(1).sval, sym(3).Statement);
+ AST::LabelledStatement *node = new (pool) AST::LabelledStatement(stringRef(1), sym(3).Statement);
node->identifierToken = loc(1);
node->colonToken = loc(2);
sym(1).Node = node;
ThrowStatement: T_THROW Expression T_SEMICOLON ;
/.
case $rule_number: {
- AST::ThrowStatement *node = makeAstNode<AST::ThrowStatement> (driver->nodePool(), sym(2).Expression);
+ AST::ThrowStatement *node = new (pool) AST::ThrowStatement(sym(2).Expression);
node->throwToken = loc(1);
node->semicolonToken = loc(3);
sym(1).Node = node;
TryStatement: T_TRY Block Catch ;
/.
case $rule_number: {
- AST::TryStatement *node = makeAstNode<AST::TryStatement> (driver->nodePool(), sym(2).Statement, sym(3).Catch);
+ AST::TryStatement *node = new (pool) AST::TryStatement(sym(2).Statement, sym(3).Catch);
node->tryToken = loc(1);
sym(1).Node = node;
} break;
TryStatement: T_TRY Block Finally ;
/.
case $rule_number: {
- AST::TryStatement *node = makeAstNode<AST::TryStatement> (driver->nodePool(), sym(2).Statement, sym(3).Finally);
+ AST::TryStatement *node = new (pool) AST::TryStatement(sym(2).Statement, sym(3).Finally);
node->tryToken = loc(1);
sym(1).Node = node;
} break;
TryStatement: T_TRY Block Catch Finally ;
/.
case $rule_number: {
- AST::TryStatement *node = makeAstNode<AST::TryStatement> (driver->nodePool(), sym(2).Statement, sym(3).Catch, sym(4).Finally);
+ AST::TryStatement *node = new (pool) AST::TryStatement(sym(2).Statement, sym(3).Catch, sym(4).Finally);
node->tryToken = loc(1);
sym(1).Node = node;
} break;
Catch: T_CATCH T_LPAREN JsIdentifier T_RPAREN Block ;
/.
case $rule_number: {
- AST::Catch *node = makeAstNode<AST::Catch> (driver->nodePool(), sym(3).sval, sym(5).Block);
+ AST::Catch *node = new (pool) AST::Catch(stringRef(3), sym(5).Block);
node->catchToken = loc(1);
node->lparenToken = loc(2);
node->identifierToken = loc(3);
Finally: T_FINALLY Block ;
/.
case $rule_number: {
- AST::Finally *node = makeAstNode<AST::Finally> (driver->nodePool(), sym(2).Block);
+ AST::Finally *node = new (pool) AST::Finally(sym(2).Block);
node->finallyToken = loc(1);
sym(1).Node = node;
} break;
DebuggerStatement: T_DEBUGGER T_SEMICOLON ;
/.
case $rule_number: {
- AST::DebuggerStatement *node = makeAstNode<AST::DebuggerStatement> (driver->nodePool());
+ AST::DebuggerStatement *node = new (pool) AST::DebuggerStatement();
node->debuggerToken = loc(1);
node->semicolonToken = loc(2);
sym(1).Node = node;
FunctionDeclaration: T_FUNCTION JsIdentifier T_LPAREN FormalParameterListOpt T_RPAREN T_LBRACE FunctionBodyOpt T_RBRACE ;
/.
case $rule_number: {
- AST::FunctionDeclaration *node = makeAstNode<AST::FunctionDeclaration> (driver->nodePool(), sym(2).sval, sym(4).FormalParameterList, sym(7).FunctionBody);
+ AST::FunctionDeclaration *node = new (pool) AST::FunctionDeclaration(stringRef(2), sym(4).FormalParameterList, sym(7).FunctionBody);
node->functionToken = loc(1);
node->identifierToken = loc(2);
node->lparenToken = loc(3);
FunctionExpression: T_FUNCTION IdentifierOpt T_LPAREN FormalParameterListOpt T_RPAREN T_LBRACE FunctionBodyOpt T_RBRACE ;
/.
case $rule_number: {
- AST::FunctionExpression *node = makeAstNode<AST::FunctionExpression> (driver->nodePool(), sym(2).sval, sym(4).FormalParameterList, sym(7).FunctionBody);
+ AST::FunctionExpression *node = new (pool) AST::FunctionExpression(stringRef(2), sym(4).FormalParameterList, sym(7).FunctionBody);
node->functionToken = loc(1);
- if (sym(2).sval)
+ if (! stringRef(2).isNull())
node->identifierToken = loc(2);
node->lparenToken = loc(3);
node->rparenToken = loc(5);
FormalParameterList: JsIdentifier ;
/.
case $rule_number: {
- AST::FormalParameterList *node = makeAstNode<AST::FormalParameterList> (driver->nodePool(), sym(1).sval);
+ AST::FormalParameterList *node = new (pool) AST::FormalParameterList(stringRef(1));
node->identifierToken = loc(1);
sym(1).Node = node;
} break;
FormalParameterList: FormalParameterList T_COMMA JsIdentifier ;
/.
case $rule_number: {
- AST::FormalParameterList *node = makeAstNode<AST::FormalParameterList> (driver->nodePool(), sym(1).FormalParameterList, sym(3).sval);
+ AST::FormalParameterList *node = new (pool) AST::FormalParameterList(sym(1).FormalParameterList, stringRef(3));
node->commaToken = loc(2);
node->identifierToken = loc(3);
sym(1).Node = node;
FunctionBody: SourceElements ;
/.
case $rule_number: {
- sym(1).Node = makeAstNode<AST::FunctionBody> (driver->nodePool(), sym(1).SourceElements->finish ());
+ sym(1).Node = new (pool) AST::FunctionBody(sym(1).SourceElements->finish ());
} break;
./
Program: SourceElements ;
/.
case $rule_number: {
- sym(1).Node = makeAstNode<AST::Program> (driver->nodePool(), sym(1).SourceElements->finish ());
+ sym(1).Node = new (pool) AST::Program(sym(1).SourceElements->finish ());
} break;
./
SourceElements: SourceElement ;
/.
case $rule_number: {
- sym(1).Node = makeAstNode<AST::SourceElements> (driver->nodePool(), sym(1).SourceElement);
+ sym(1).Node = new (pool) AST::SourceElements(sym(1).SourceElement);
} break;
./
SourceElements: SourceElements SourceElement ;
/.
case $rule_number: {
- sym(1).Node = makeAstNode<AST::SourceElements> (driver->nodePool(), sym(1).SourceElements, sym(2).SourceElement);
+ sym(1).Node = new (pool) AST::SourceElements(sym(1).SourceElements, sym(2).SourceElement);
} break;
./
SourceElement: Statement ;
/.
case $rule_number: {
- sym(1).Node = makeAstNode<AST::StatementSourceElement> (driver->nodePool(), sym(1).Statement);
+ sym(1).Node = new (pool) AST::StatementSourceElement(sym(1).Statement);
} break;
./
SourceElement: FunctionDeclaration ;
/.
case $rule_number: {
- sym(1).Node = makeAstNode<AST::FunctionSourceElement> (driver->nodePool(), sym(1).FunctionDeclaration);
+ sym(1).Node = new (pool) AST::FunctionSourceElement(sym(1).FunctionDeclaration);
} break;
./
IdentifierOpt: ;
/.
case $rule_number: {
- sym(1).sval = 0;
+ stringRef(1) = QStringRef();
} break;
./
SavedToken &tk = token_buffer[0];
tk.token = yytoken;
tk.dval = yylval;
+ tk.spell = yytokenspell;
tk.loc = yylloc;
yylloc = yyprevlloc;
token_buffer[0].token = yytoken;
token_buffer[0].dval = yylval;
+ token_buffer[0].spell = yytokenspell;
token_buffer[0].loc = yylloc;
- token_buffer[1].token = yytoken = lexer->lex();
- token_buffer[1].dval = yylval = lexer->dval();
- token_buffer[1].loc = yylloc = location(lexer);
+ token_buffer[1].token = yytoken = lexer->lex();
+ token_buffer[1].dval = yylval = lexer->tokenValue();
+ token_buffer[1].spell = yytokenspell = lexer->tokenSpell();
+ token_buffer[1].loc = yylloc = location(lexer);
if (t_action(errorState, yytoken)) {
QString msg;
QT_BEGIN_NAMESPACE
const char *const QmlJSGrammar::spell [] = {
- "end of file", "&", "&&", "&=", "break", "case", "catch", ":", ";", "continue",
+ "end of file", "&", "&&", "&=", "break", "case", "catch", ":", ",", "continue",
"default", "delete", "/", "/=", "do", ".", "else", "=", "==", "===",
"finally", "for", "function", ">=", ">", ">>", ">>=", ">>>", ">>>=", "identifier",
"if", "in", "instanceof", "{", "[", "<=", "(", "<", "<<", "<<=",
"this", "throw", "~", "try", "typeof", "var", "void", "while", "with", "^",
"^=", "null", "true", "false", "const", "debugger", "reserved word", "multiline string literal", "comment", "public",
"import", "as", "on", 0, 0, 0, 0, 0, 0, 0,
- 0};
+ 0, 0};
const short QmlJSGrammar::lhs [] = {
- 101, 101, 101, 101, 101, 101, 102, 108, 108, 111,
- 111, 113, 112, 112, 112, 112, 112, 112, 112, 112,
- 115, 110, 109, 118, 118, 119, 119, 120, 120, 117,
- 106, 106, 106, 106, 122, 122, 122, 122, 106, 127,
- 127, 127, 128, 128, 129, 129, 106, 106, 106, 106,
- 106, 106, 106, 106, 106, 106, 106, 106, 106, 106,
- 106, 106, 106, 116, 116, 116, 116, 116, 132, 132,
- 132, 132, 132, 132, 132, 132, 132, 132, 132, 132,
- 132, 132, 132, 132, 132, 132, 121, 134, 134, 134,
- 134, 133, 133, 136, 136, 138, 138, 138, 138, 138,
- 138, 139, 139, 139, 139, 139, 139, 139, 139, 139,
- 139, 139, 139, 139, 139, 139, 139, 139, 139, 139,
- 139, 139, 139, 139, 139, 139, 139, 139, 139, 139,
- 139, 139, 140, 140, 114, 114, 114, 114, 114, 143,
- 143, 144, 144, 144, 144, 142, 142, 145, 145, 146,
- 146, 147, 147, 147, 148, 148, 148, 148, 148, 148,
- 148, 148, 148, 148, 149, 149, 149, 149, 150, 150,
- 150, 151, 151, 151, 151, 152, 152, 152, 152, 152,
- 152, 152, 153, 153, 153, 153, 153, 153, 154, 154,
- 154, 154, 154, 155, 155, 155, 155, 155, 156, 156,
- 157, 157, 158, 158, 159, 159, 160, 160, 161, 161,
- 162, 162, 163, 163, 164, 164, 165, 165, 166, 166,
- 167, 167, 137, 137, 168, 168, 169, 169, 169, 169,
- 169, 169, 169, 169, 169, 169, 169, 169, 104, 104,
- 170, 170, 171, 171, 172, 172, 103, 103, 103, 103,
- 103, 103, 103, 103, 103, 103, 103, 103, 103, 103,
- 103, 123, 184, 184, 183, 183, 131, 131, 185, 185,
- 186, 186, 188, 188, 187, 189, 192, 190, 190, 193,
- 191, 191, 124, 125, 125, 126, 126, 173, 173, 173,
- 173, 173, 173, 173, 174, 174, 174, 174, 175, 175,
- 175, 175, 176, 176, 177, 179, 194, 194, 197, 197,
- 195, 195, 198, 196, 178, 178, 178, 180, 180, 181,
- 181, 181, 199, 200, 182, 182, 130, 141, 204, 204,
- 201, 201, 202, 202, 205, 107, 206, 206, 105, 105,
- 203, 203, 135, 135, 207};
+ 102, 102, 102, 102, 102, 102, 103, 109, 109, 112,
+ 112, 114, 113, 113, 113, 113, 113, 113, 113, 113,
+ 116, 111, 110, 119, 119, 120, 120, 121, 121, 118,
+ 107, 107, 107, 107, 123, 123, 123, 123, 107, 128,
+ 128, 128, 129, 129, 130, 130, 107, 107, 107, 107,
+ 107, 107, 107, 107, 107, 107, 107, 107, 107, 107,
+ 107, 107, 107, 117, 117, 117, 117, 117, 133, 133,
+ 133, 133, 133, 133, 133, 133, 133, 133, 133, 133,
+ 133, 133, 133, 133, 133, 133, 122, 135, 135, 135,
+ 135, 134, 134, 137, 137, 139, 139, 139, 139, 139,
+ 139, 140, 140, 140, 140, 140, 140, 140, 140, 140,
+ 140, 140, 140, 140, 140, 140, 140, 140, 140, 140,
+ 140, 140, 140, 140, 140, 140, 140, 140, 140, 140,
+ 140, 140, 141, 141, 115, 115, 115, 115, 115, 144,
+ 144, 145, 145, 145, 145, 143, 143, 146, 146, 147,
+ 147, 148, 148, 148, 149, 149, 149, 149, 149, 149,
+ 149, 149, 149, 149, 150, 150, 150, 150, 151, 151,
+ 151, 152, 152, 152, 152, 153, 153, 153, 153, 153,
+ 153, 153, 154, 154, 154, 154, 154, 154, 155, 155,
+ 155, 155, 155, 156, 156, 156, 156, 156, 157, 157,
+ 158, 158, 159, 159, 160, 160, 161, 161, 162, 162,
+ 163, 163, 164, 164, 165, 165, 166, 166, 167, 167,
+ 168, 168, 138, 138, 169, 169, 170, 170, 170, 170,
+ 170, 170, 170, 170, 170, 170, 170, 170, 105, 105,
+ 171, 171, 172, 172, 173, 173, 104, 104, 104, 104,
+ 104, 104, 104, 104, 104, 104, 104, 104, 104, 104,
+ 104, 124, 185, 185, 184, 184, 132, 132, 186, 186,
+ 187, 187, 189, 189, 188, 190, 193, 191, 191, 194,
+ 192, 192, 125, 126, 126, 127, 127, 174, 174, 174,
+ 174, 174, 174, 174, 175, 175, 175, 175, 176, 176,
+ 176, 176, 177, 177, 178, 180, 195, 195, 198, 198,
+ 196, 196, 199, 197, 179, 179, 179, 181, 181, 182,
+ 182, 182, 200, 201, 183, 183, 131, 142, 205, 205,
+ 202, 202, 203, 203, 206, 108, 207, 207, 106, 106,
+ 204, 204, 136, 136, 208};
const short QmlJSGrammar::rhs [] = {
2, 2, 2, 2, 2, 2, 2, 1, 1, 1,
185, 199, 181, 184, 198, 206, 0};
const short QmlJSGrammar::action_index [] = {
- 350, 1271, 2492, 2492, 2395, 999, 52, 93, 137, -101,
- 104, 72, 66, 177, -101, 285, 80, -101, -101, 641,
- 71, 130, 167, 178, -101, -101, -101, 431, 321, 1271,
- -101, -101, -101, 393, -101, 2201, 2007, 1271, 1271, 1271,
- -101, 811, 1271, -101, -101, -101, 1271, 1271, -101, -101,
- -101, -101, -101, 1271, -101, 1271, 1271, -101, 1271, 1271,
- 87, 188, -101, -101, 1271, 1271, 1271, -101, -101, -101,
- 179, 1271, 263, 1271, 1271, 1271, 1271, 456, 1271, 1271,
- 1271, 1271, 1271, 1271, 321, 1271, 1271, 1271, 128, 114,
- 120, 193, 181, 172, 321, 321, 446, 395, 405, 1271,
- -8, 1271, 76, 2104, 1271, 1271, -101, -101, -101, -101,
- -101, -101, -101, -101, -101, -101, -101, -101, -101, -101,
- -101, -101, -101, -101, -101, -101, -101, -101, -101, -101,
- -101, -101, -101, -101, -101, -101, -101, -101, -101, -101,
- 110, 1271, -101, -101, 68, 38, -101, 1271, -101, -101,
- 1271, -101, -101, -101, -101, -101, -101, -101, -101, -101,
- -101, -101, -101, -101, 1271, 32, 1271, 1271, 85, 83,
- 1271, -101, 2104, 1271, 1271, -101, 108, -101, 53, -101,
- -101, 64, -101, 393, 89, 62, -101, 297, -101, 63,
- 2492, -101, -101, -101, -101, -101, 154, -101, -101, 47,
- -101, -101, -101, -101, -101, -101, 2492, -101, -101, 461,
- -101, 470, 74, 2395, 59, 393, 92, 67, 2686, 152,
- 1271, -101, 65, 43, 1271, 41, -101, 39, 34, -101,
- -101, 393, -101, -101, -101, -101, -101, -101, 86, -101,
- -101, -101, -101, 90, -101, -101, -101, -101, -101, -101,
- -11, 50, 1271, 103, 82, -101, -101, 1455, -101, 84,
- 44, 5, -101, 267, 70, 33, 575, 79, 69, 471,
- 235, 393, 1271, 275, 1271, 1271, 1271, 1271, 305, 1271,
- 1271, 1271, 1271, 1271, 229, 201, 225, 202, 321, 355,
- 374, 380, 1271, 35, 1271, 81, 1271, -101, 641, 1271,
- -101, 1271, 61, 1, 1271, 29, 2395, -101, 1271, 133,
- 2395, -101, 1271, 73, 1271, 1271, 99, 97, 1271, -101,
- 51, 153, 60, -101, -101, 1271, -101, 393, 1271, -101,
- 56, 1271, -25, 2395, -101, 1271, 129, 2395, -101, -35,
- 309, -56, -31, 2492, -39, -101, 2395, -101, 1271, 245,
- 2395, -5, 2395, -101, 6, 0, -33, -101, -101, 2395,
- -43, 543, 7, 488, 112, 1271, 2395, -1, -27, 453,
- 8, -18, 630, 14, 16, -101, 1365, -101, 12, -19,
- 3, 1271, 58, -30, 1271, -2, 1271, -29, -36, 1271,
- -101, 2298, 18, -101, -101, -101, -101, -101, -101, 1271,
- -101, -101, -101, -101, 223, -101, 1271, -10, -101, 2395,
- -101, 95, -101, -101, 2395, -101, 1271, 107, 20, -101,
- 40, -101, 46, 100, 1271, -101, 55, 57, -101, 28,
- -101, 2395, -101, 118, 2395, -101, 161, -101, -101, 126,
- 2395, 37, -101, -12, -4, -101, 393, -34, -6, -101,
- -101, -101, -101, 1271, 98, 2395, -101, 1271, 116, 2395,
- -101, 19, -101, 186, -101, -101, 1271, -101, -101, 303,
- -101, -101, -101, 119, 1638, -101, -101, 1821, -101, -101,
- 1914, -101, -101, -101, -101, -101, -101, 123, -101, -101,
- -101, -101, -101, -101, -101, -101, 2492, -101, -101, -101,
- 94, -26, 819, 158, -28, 4, -101, -101, 210, -101,
- 203, -101, -101, -101, 393, 230, -101, 1545, -101, -101,
- -101, -101, -101, -101, 234, 2, 393, 232, 17, 393,
- 163, -101, 10, -101, 908, 125, -101, 13, 908, -101,
- -101, 1090, -101, -101, -101, 1181, -101, -101, 214, -101,
- 1545, -101, 262, 9, -101, -101, 180, 318, 30, 1545,
- -101, 238, -101, 236, -101, 26, -32, 315, 183, 288,
- -101, 77, -101, -101, -101, 1728, 908, 291, 2589, 2007,
- -3, -101, 443, 25, 497, 88, 1271, 2395, 24, 11,
- 384, 36, 27, 702, 48, 49, -101, 1365, -101, 54,
- 31, 45, 1271, 58, 15, 1271, 42, 1271, 23, 22,
- 122, -101, -101, 21, -101, -101, 730, -101, 254, -70,
- 908, -101, -101, 138, 393, -101, 143, -101, 134, -101,
- -101, 268, -101, -101, 124, -101, -101, -101, -101, -101,
- -101,
+ 360, 1286, 2520, 2520, 2422, 1011, 52, 96, 132, -102,
+ 104, 69, 66, 177, -102, 283, 80, -102, -102, 649,
+ 71, 120, 160, 169, -102, -102, -102, 444, 325, 1286,
+ -102, -102, -102, 324, -102, 2226, 2030, 1286, 1286, 1286,
+ -102, 801, 1286, -102, -102, -102, 1286, 1286, -102, -102,
+ -102, -102, -102, 1286, -102, 1286, 1286, -102, 1286, 1286,
+ 87, 190, -102, -102, 1286, 1286, 1286, -102, -102, -102,
+ 187, 1286, 251, 1286, 1286, 1286, 1286, 471, 1286, 1286,
+ 1286, 1286, 1286, 1286, 325, 1286, 1286, 1286, 128, 113,
+ 127, 182, 168, 159, 325, 325, 454, 406, 416, 1286,
+ -7, 1286, 76, 2128, 1286, 1286, -102, -102, -102, -102,
+ -102, -102, -102, -102, -102, -102, -102, -102, -102, -102,
+ -102, -102, -102, -102, -102, -102, -102, -102, -102, -102,
+ -102, -102, -102, -102, -102, -102, -102, -102, -102, -102,
+ 107, 1286, -102, -102, 68, 44, -102, 1286, -102, -102,
+ 1286, -102, -102, -102, -102, -102, -102, -102, -102, -102,
+ -102, -102, -102, -102, 1286, 32, 1286, 1286, 88, 86,
+ 1286, -102, 2128, 1286, 1286, -102, 103, -102, 56, -102,
+ -102, 65, -102, 398, 89, 63, -102, 274, -102, 62,
+ 2520, -102, -102, -102, -102, -102, 248, -102, -102, 47,
+ -102, -102, -102, -102, -102, -102, 2520, -102, -102, 467,
+ -102, 470, 73, 2422, 53, 398, 91, 67, 2716, 154,
+ 1286, -102, 64, 43, 1286, 41, -102, 39, 34, -102,
+ -102, 398, -102, -102, -102, -102, -102, -102, 82, -102,
+ -102, -102, -102, 90, -102, -102, -102, -102, -102, -102,
+ -8, 51, 1286, 100, 77, -102, -102, 1472, -102, 84,
+ 38, 5, -102, 266, 70, 33, 555, 79, 74, 477,
+ 234, 320, 1286, 281, 1286, 1286, 1286, 1286, 311, 1286,
+ 1286, 1286, 1286, 1286, 230, 189, 213, 208, 325, 371,
+ 386, 396, 1286, 35, 1286, 81, 1286, -102, 649, 1286,
+ -102, 1286, 60, 1, 1286, 31, 2422, -102, 1286, 140,
+ 2422, -102, 1286, 72, 1286, 1286, 97, 93, 1286, -102,
+ 50, 149, 61, -102, -102, 1286, -102, 310, 1286, -102,
+ 58, 1286, -25, 2422, -102, 1286, 125, 2422, -102, -35,
+ 292, -56, -31, 2520, -39, -102, 2422, -102, 1286, 141,
+ 2422, -5, 2422, -102, 6, 0, -33, -102, -102, 2422,
+ -43, 550, 7, 478, 115, 1286, 2422, -1, -27, 451,
+ 8, -18, 627, 14, 16, -102, 1381, -102, 12, -19,
+ 3, 1286, 59, -30, 1286, -2, 1286, -29, -36, 1286,
+ -102, 2324, 18, -102, -102, -102, -102, -102, -102, 1286,
+ -102, -102, -102, -102, 203, -102, 1286, -10, -102, 2422,
+ -102, 94, -102, -102, 2422, -102, 1286, 102, 20, -102,
+ 40, -102, 46, 99, 1286, -102, 55, 57, -102, 28,
+ -102, 2422, -102, 114, 2422, -102, 161, -102, -102, 121,
+ 2422, 37, -102, -12, -4, -102, 398, -34, -6, -102,
+ -102, -102, -102, 1286, 98, 2422, -102, 1286, 105, 2422,
+ -102, 19, -102, 181, -102, -102, 1286, -102, -102, 288,
+ -102, -102, -102, 110, 1657, -102, -102, 1842, -102, -102,
+ 1936, -102, -102, -102, -102, -102, -102, 122, -102, -102,
+ -102, -102, -102, -102, -102, -102, 2520, -102, -102, -102,
+ 92, -26, 829, 142, -28, 4, -102, -102, 191, -102,
+ 202, -102, -102, -102, 398, 218, -102, 1563, -102, -102,
+ -102, -102, -102, -102, 237, 2, 368, 207, 17, 398,
+ 205, -102, 10, -102, 919, 124, -102, 13, 919, -102,
+ -102, 1103, -102, -102, -102, 1195, -102, -102, 214, -102,
+ 1563, -102, 271, 9, -102, -102, 174, 307, 30, 1563,
+ -102, 228, -102, 212, -102, 26, -32, 301, 179, 265,
+ -102, 75, -102, -102, -102, 1748, 919, 280, 2618, 2030,
+ -3, -102, 459, 25, 486, 85, 1286, 2422, 24, 11,
+ 378, 36, 27, 711, 48, 49, -102, 1381, -102, 54,
+ 29, 45, 1286, 59, 15, 1286, 42, 1286, 23, 22,
+ 117, -102, -102, 21, -102, -102, 739, -102, 201, -70,
+ 919, -102, -102, 116, 398, -102, 143, -102, 129, -102,
+ -102, 252, -102, -102, 126, -102, -102, -102, -102, -102,
+ -102,
-107, 25, -75, 27, 30, 272, -107, -107, -107, -107,
-107, -107, -107, -107, -107, -107, -107, -107, -107, -42,
541, -110, -129, 561, 568, 333, 466, 559, 556, 527,
510, 529, 541, 346, 534, 424, 541, 257, 440, -126,
408, 424, -121, 420, 541, -118, -100, 444, 457, 453,
- 424, -99, 304, 348, 431, -123, 251, 416, 325, 141,
- 457, 101, 414, 164, 440, 453, 147, 71, 296, 416,
- 99, 312, 272, 430, 294, 272, 252, 164, 141, 306,
- 170, 335, 292, 640, 301, 257, 190, 187, 149, 346,
- 183, 312, 236, 348, 318, 71, 141, 0, 0, 172,
- 427, 141, 0, 179, 294, 141, 141, 331, 141, 314,
- 99, 292, 189, 315, 141, 434, 141, 477, 173, 62,
- 538, 141, 443, 538, 0, 249, 248, 141, 573, 572,
- 63, 141, 616, 256, 255, 101, 444, 242, 241, 249,
- 248, 247, 246, 172, 58, 428, 413, 412, 455, 409,
- 58, 327, 141, 254, 177, 59, 142, 418, 58, 141,
- 532, 59, 173, 249, 248, 478, 459, 58, 611, 59,
- 166, 539, 172, 488, 167, 636, 635, 525, 59, 337,
- 64, 64, 103, 310, 469, 630, 629, 85, 0, 86,
- 64, 173, 0, 174, 633, 632, 85, 0, 86, 511,
- 87, 104, 511, 105, 328, 235, 234, 575, 85, 87,
- 86, 550, 438, 437, 533, 531, 85, 85, 86, 86,
- 0, 87, 511, 513, 631, 65, 65, 517, 172, 87,
- 87, 66, 66, 541, 512, 65, 0, 470, 468, 172,
- 85, 66, 86, 141, 85, 513, 86, 173, 513, 406,
- 85, 511, 86, 87, 0, 511, 512, 87, 173, 512,
- 406, 0, 0, 87, 563, 551, 549, 172, 513, 0,
- 0, 73, 74, 0, 0, 274, 275, 0, 0, 512,
- 0, 518, 516, 274, 275, -87, 173, 34, 174, 564,
- 562, 626, 576, 73, 74, 350, 172, 513, 75, 76,
- 0, 513, 276, 277, 0, 627, 625, 34, 512, 0,
- 276, 277, 512, 0, -87, 173, 34, 174, 279, 280,
- 75, 76, 34, 0, 48, 50, 49, 281, 34, 0,
- 282, 0, 283, 0, 34, 624, 85, 34, 86, 0,
- 0, 0, 0, 0, 48, 50, 49, 0, 0, 87,
- 45, 0, 0, 48, 50, 49, 0, 0, 0, 48,
- 50, 49, 0, 0, 0, 48, 50, 49, 279, 280,
- 45, 48, 50, 49, 48, 50, 49, 281, 0, 45,
- 282, 0, 283, 0, 0, 45, 0, 279, 280, 0,
- 0, 45, 0, 279, 280, 0, 281, 45, 0, 282,
- 45, 283, 281, 34, 0, 282, 0, 283, 78, 79,
- -341, 0, 34, 0, 0, 0, 80, 81, 78, 79,
- 82, 0, 83, 0, 0, 0, 80, 81, 0, 0,
- 82, 0, 83, 6, 5, 4, 1, 3, 2, 0,
- 48, 50, 49, 0, 78, 79, 0, 0, 0, 48,
- 50, 49, 80, 81, 0, 0, 82, 0, 83, 78,
- 79, 0, 34, 0, 0, 0, 45, 80, 81, 78,
- 79, 82, 34, 83, 0, 45, 0, 80, 81, -341,
- 34, 82, 0, 83, 279, 280, 0, 0, 0, 34,
- 0, 0, 0, 281, 240, 239, 282, 0, 283, 48,
- 50, 49, 0, 0, 0, 0, 0, 34, 0, 48,
- 50, 49, 240, 239, 0, 0, 34, 48, 50, 49,
- 0, 245, 244, 0, 0, 45, 48, 50, 49, 0,
- 0, 0, 0, 0, 0, 45, 0, 0, 0, 245,
- 244, 0, 0, 45, 48, 50, 49, 0, 245, 244,
- 0, 0, 45, 48, 50, 49, 0, 0, 0, 0,
- 0, 0, 34, 0, 0, 0, 0, 0, 151, 0,
- 45, 0, 0, 0, 0, 0, 0, 0, 152, 45,
- 0, 0, 153, 0, 0, 0, 0, 0, 0, 0,
- 0, 154, 0, 155, 240, 239, 308, 0, 0, 48,
- 50, 49, 0, 0, 156, 0, 157, 62, 0, 0,
+ 424, -99, 304, 348, 431, 416, -123, 325, 141, 251,
+ 457, 414, 101, 164, 440, 453, 147, 71, 296, 416,
+ 99, 312, 272, 430, 294, 272, 292, 252, 141, 257,
+ 164, 306, 335, 170, 301, 190, 640, 187, 346, 312,
+ 318, 183, 236, 348, 149, 71, 141, 172, 141, 427,
+ 141, 141, 0, 141, 294, 141, 179, 99, 477, 331,
+ 292, 434, 141, 189, 314, 538, 173, 443, 315, 62,
+ 141, 172, 538, 141, 249, 248, 573, 572, 256, 255,
+ 63, 444, 616, 242, 241, 101, 249, 248, 141, 141,
+ 173, 247, 246, 58, 428, 413, 412, 327, 455, 177,
+ 254, 409, 418, 142, 59, 459, 478, 58, 58, 141,
+ 166, 525, 58, 611, 167, 172, 249, 248, 59, 59,
+ 539, 64, 488, 59, 85, 337, 86, 636, 635, 469,
+ 630, 629, 103, 85, 173, 86, 174, 87, 575, 64,
+ 310, 350, 64, 511, 633, 632, 87, 85, 511, 86,
+ 328, 104, 532, 105, 85, 0, 86, 513, 172, 0,
+ 87, 550, 438, 437, 541, 517, 65, 87, 512, 0,
+ 0, 511, 66, 85, 631, 86, 511, 173, 85, 406,
+ 86, 511, 470, 468, 65, 0, 87, 65, 626, 513,
+ 66, 87, 172, 66, 513, 85, 141, 86, 0, 85,
+ 512, 86, 627, 625, 563, 512, 533, 531, 87, 73,
+ 74, 173, 87, 406, 0, 551, 549, 513, 0, 518,
+ 516, 34, 513, 576, 274, 275, 172, 513, 512, 564,
+ 562, 0, 624, 512, 34, 172, 75, 76, 512, 274,
+ 275, 73, 74, 34, -87, 173, 0, 174, 0, 235,
+ 234, 276, 277, -87, 173, 0, 174, 34, 48, 50,
+ 49, 34, 0, 0, 0, 0, 276, 277, 75, 76,
+ 34, 48, 50, 49, 279, 280, 34, 0, 0, 34,
+ 48, 50, 49, 281, 45, 0, 282, 0, 283, 34,
+ 85, 0, 86, 34, 48, 50, 49, 45, 48, 50,
+ 49, 0, 0, 87, 0, 0, 45, 48, 50, 49,
+ 0, 0, 0, 48, 50, 49, 48, 50, 49, 0,
+ 45, 0, 0, 0, 45, 0, 48, 50, 49, 0,
+ 48, 50, 49, 45, 279, 280, 0, 34, 0, 45,
+ 0, 0, 45, 281, 0, 0, 282, 34, 283, 279,
+ 280, 0, 45, 0, -341, 0, 45, 0, 281, 279,
+ 280, 282, 0, 283, 0, 0, 0, 34, 281, 78,
+ 79, 282, 0, 283, 48, 50, 49, 80, 81, 78,
+ 79, 82, 0, 83, 48, 50, 49, 80, 81, 0,
+ 0, 82, 0, 83, 6, 5, 4, 1, 3, 2,
+ 45, 0, 0, 0, 48, 50, 49, 78, 79, 0,
+ 45, 0, 0, 0, 0, 80, 81, 78, 79, 82,
+ 34, 83, 0, 0, 0, 80, 81, -341, 34, 82,
+ 45, 83, 0, 0, 78, 79, 34, 0, 0, 34,
+ 279, 280, 80, 81, 0, 0, 82, 34, 83, 281,
+ 0, 0, 282, 0, 283, 34, 0, 48, 50, 49,
+ 240, 239, 0, 0, 0, 48, 50, 49, 240, 239,
+ 0, 245, 244, 48, 50, 49, 48, 50, 49, 245,
+ 244, 0, 0, 45, 48, 50, 49, 245, 244, 0,
+ 0, 45, 48, 50, 49, 0, 0, 0, 151, 45,
+ 0, 0, 45, 0, 0, 0, 0, 0, 152, 0,
+ 45, 0, 153, 0, 0, 0, 0, 0, 45, 34,
+ 0, 154, 0, 155, 0, 0, 308, 0, 0, 0,
+ 0, 0, 0, 0, 156, 0, 157, 62, 0, 0,
0, 0, 0, 0, 158, 0, 0, 159, 63, 0,
- 0, 0, 0, 160, 0, 45, 0, 0, 0, 161,
- 0, 0, 30, 31, 151, 0, 0, 0, 0, 0,
- 0, 0, 33, 0, 152, 162, 0, 0, 153, 34,
- 0, 0, 0, 35, 36, 0, 37, 154, 0, 155,
- 0, 0, 0, 41, 0, 0, 0, 44, 0, 0,
- 156, 0, 157, 62, 0, 0, 0, 0, 0, 0,
- 158, 0, 0, 159, 63, 51, 48, 50, 49, 160,
- 52, 0, 0, 0, 0, 161, 0, 0, 0, 0,
- 0, 43, 54, 32, 30, 31, 0, 40, 0, 0,
- 0, 162, 45, 0, 33, 0, 0, 0, 0, 0,
- 0, 34, 0, 0, 0, 35, 36, 0, 37, 0,
- 0, 0, 30, 31, 0, 41, 0, 0, 0, 44,
- 0, 0, 33, 0, 0, 0, 0, 0, 0, 34,
- 0, 0, 0, 35, 36, 0, 37, 51, 48, 50,
- 49, 0, 52, 502, 0, 0, 0, 44, 0, 0,
- 0, 0, 0, 43, 54, 32, 0, 0, 0, 40,
- 0, 0, 0, 0, 45, 51, 48, 50, 49, 0,
- 52, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 43, 54, 32, 0, 0, 0, 40, 0, 0,
- 0, 0, 45, 30, 31, 0, 0, 0, 0, 0,
- 0, 30, 31, 33, 0, 0, 0, 0, 0, 0,
- 34, 33, 0, 0, 35, 36, 0, 37, 34, 0,
- 0, 0, 35, 36, 41, 37, 0, 0, 44, 0,
- 0, 0, 502, 0, 0, 0, 44, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 51, 48, 50, 49,
- 0, 52, 0, 0, 51, 48, 50, 49, 0, 52,
+ 0, 240, 239, 160, 0, 0, 48, 50, 49, 161,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 162, 0, 0, 0, 30,
+ 31, 0, 45, 0, 0, 0, 0, 0, 0, 33,
+ 0, 0, 151, 0, 0, 0, 34, 0, 0, 0,
+ 35, 36, 152, 37, 0, 0, 153, 0, 0, 0,
+ 41, 0, 0, 0, 44, 154, 0, 155, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 156, 0,
+ 157, 62, 51, 48, 50, 49, 0, 52, 158, 0,
+ 0, 159, 63, 0, 0, 0, 0, 160, 43, 54,
+ 32, 0, 0, 161, 40, 0, 0, 0, 0, 45,
+ 0, 0, 0, 30, 31, 0, 0, 0, 0, 162,
+ 0, 0, 0, 33, 0, 0, 0, 0, 0, 0,
+ 34, 0, 0, 0, 35, 36, 0, 37, 0, 0,
+ 0, 30, 31, 0, 41, 0, 0, 0, 44, 0,
+ 0, 33, 0, 0, 0, 0, 0, 0, 34, 0,
+ 0, 0, 35, 36, 0, 37, 51, 48, 50, 49,
+ 0, 52, 502, 0, 0, 0, 44, 0, 0, 0,
0, 0, 43, 54, 32, 0, 0, 0, 40, 0,
- 43, 54, 32, 45, 0, 0, 40, 0, 0, 0,
- 0, 45, 0, 0, 0, 0, 0, 0, 0, 0,
- 30, 31, 0, 0, 0, 0, 0, 0, 0, 0,
- 33, 0, 0, 0, 0, 0, 0, 34, 0, 0,
- 0, 35, 36, 0, 37, 0, 0, 0, 0, 0,
- 0, 502, 0, 0, 0, 44, 0, 0, 0, 0,
+ 0, 0, 0, 45, 51, 48, 50, 49, 0, 52,
+ 0, 0, 0, 30, 31, 0, 0, 0, 0, 0,
+ 43, 54, 32, 33, 0, 0, 40, 0, 0, 0,
+ 34, 45, 0, 0, 35, 36, 0, 37, 0, 0,
+ 0, 30, 31, 0, 41, 0, 0, 0, 44, 0,
+ 0, 33, 0, 0, 0, 0, 0, 0, 34, 0,
+ 0, 0, 35, 36, 0, 37, 51, 48, 50, 49,
+ 0, 52, 502, 0, 0, 0, 44, 0, 0, 0,
+ 0, 0, 43, 54, 32, 0, 0, 0, 40, 0,
+ 0, 0, 0, 45, 51, 48, 50, 49, 0, 52,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 51, 48, 50, 49, 0, 52, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 43,
- 54, 32, 0, 0, 0, 40, 0, 0, 0, 0,
- 45, 0, 0, 0, 0, 0, 0, 0, 0, 501,
+ 43, 54, 32, 0, 0, 0, 40, 0, 0, 0,
+ 0, 45, 0, 0, 0, 0, 0, 0, 0, 0,
0, 30, 31, 0, 0, 0, 0, 0, 0, 0,
- 0, 215, 0, 0, 0, 0, 0, 0, 34, 0,
+ 0, 33, 0, 0, 0, 0, 0, 0, 34, 0,
0, 0, 35, 36, 0, 37, 0, 0, 0, 0,
0, 0, 502, 0, 0, 0, 44, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 51, 503, 505, 504, 0, 52,
- 0, 0, 0, 0, 226, 0, 0, 0, 0, 0,
- 43, 54, 32, 210, 0, 0, 40, 0, 0, 0,
+ 0, 0, 0, 0, 51, 48, 50, 49, 0, 52,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 43, 54, 32, 0, 0, 0, 40, 0, 0, 0,
0, 45, 0, 0, 0, 0, 0, 0, 0, 0,
- 501, 0, 30, 31, 0, 0, 0, 0, 0, 0,
- 0, 0, 215, 0, 0, 0, 0, 0, 0, 34,
- 0, 0, 0, 35, 36, 0, 37, 0, 0, 0,
- 0, 0, 0, 502, 0, 0, 0, 44, 0, 0,
- 0, 0, 0, 0, 0, 543, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 51, 503, 505, 504, 0,
- 52, 0, 0, 0, 0, 226, 0, 0, 0, 0,
- 0, 43, 54, 32, 210, 0, 0, 40, 0, 0,
- 0, 0, 45, 0, 0, 0, 0, 0, 0, 0,
0, 501, 0, 30, 31, 0, 0, 0, 0, 0,
0, 0, 0, 215, 0, 0, 0, 0, 0, 0,
34, 0, 0, 0, 35, 36, 0, 37, 0, 0,
0, 0, 0, 0, 502, 0, 0, 0, 44, 0,
- 0, 0, 0, 0, 0, 0, 546, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 51, 503, 505, 504,
0, 52, 0, 0, 0, 0, 226, 0, 0, 0,
0, 0, 43, 54, 32, 210, 0, 0, 40, 0,
0, 0, 0, 45, 0, 0, 0, 0, 0, 0,
- 0, 0, 29, 30, 31, 0, 0, 0, 0, 0,
- 0, 0, 0, 33, 0, 0, 0, 0, 0, 0,
- 34, 0, 0, 0, 35, 36, 0, 37, 0, 0,
- 0, 38, 0, 39, 41, 42, 0, 0, 44, 0,
- 0, 0, 46, 0, 47, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 51, 48, 50, 49,
- 0, 52, 0, 53, 0, 55, 0, 56, 0, 0,
- 0, 0, 43, 54, 32, 0, 0, 0, 40, 0,
- 0, 0, 0, 45, 0, 0, 0, 0, 0, 0,
- 0, 0, -119, 0, 0, 0, 29, 30, 31, 0,
- 0, 0, 0, 0, 0, 0, 0, 33, 0, 0,
+ 0, 0, 0, 501, 0, 30, 31, 0, 0, 0,
+ 0, 0, 0, 0, 0, 215, 0, 0, 0, 0,
+ 0, 0, 34, 0, 0, 0, 35, 36, 0, 37,
+ 0, 0, 0, 0, 0, 0, 502, 0, 0, 0,
+ 44, 0, 0, 0, 0, 0, 0, 0, 543, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 51, 503,
+ 505, 504, 0, 52, 0, 0, 0, 0, 226, 0,
+ 0, 0, 0, 0, 43, 54, 32, 210, 0, 0,
+ 40, 0, 0, 0, 0, 45, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 501, 0, 30, 31, 0,
+ 0, 0, 0, 0, 0, 0, 0, 215, 0, 0,
0, 0, 0, 0, 34, 0, 0, 0, 35, 36,
- 0, 37, 0, 0, 0, 38, 0, 39, 41, 42,
- 0, 0, 44, 0, 0, 0, 46, 0, 47, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 51, 48, 50, 49, 0, 52, 0, 53, 0, 55,
- 0, 56, 0, 0, 0, 0, 43, 54, 32, 0,
+ 0, 37, 0, 0, 0, 0, 0, 0, 502, 0,
+ 0, 0, 44, 0, 0, 0, 0, 0, 0, 0,
+ 546, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 51, 503, 505, 504, 0, 52, 0, 0, 0, 0,
+ 226, 0, 0, 0, 0, 0, 43, 54, 32, 210,
0, 0, 40, 0, 0, 0, 0, 45, 0, 0,
- 0, 0, 0, 0, 0, 0, 29, 30, 31, 0,
- 0, 0, 0, 0, 0, 0, 0, 33, 0, 0,
- 0, 0, 0, 0, 34, 0, 0, 0, 35, 36,
- 0, 37, 0, 0, 0, 38, 0, 39, 41, 42,
- 0, 0, 44, 0, 0, 0, 46, 0, 47, 0,
+ 0, 0, 0, 0, 0, 0, 0, 29, 30, 31,
+ 0, 0, 0, 0, 0, 0, 0, 0, 33, 0,
+ 0, 0, 0, 0, 0, 34, 0, 0, 0, 35,
+ 36, 0, 37, 0, 0, 0, 38, 0, 39, 41,
+ 42, 0, 0, 44, 0, 0, 0, 46, 0, 47,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 51, 48, 50, 49, 0, 52, 0, 53, 0, 55,
- 271, 56, 0, 0, 0, 0, 43, 54, 32, 0,
- 0, 0, 40, 0, 0, 0, 0, 45, 0, 0,
- 0, 0, 0, 0, 0, 0, 29, 30, 31, 0,
- 0, 0, 0, 0, 0, 0, 0, 33, 0, 0,
- 0, 0, 0, 0, 34, 217, 0, 0, 218, 36,
- 0, 37, 0, 0, 0, 38, 0, 39, 41, 42,
- 0, 0, 44, 0, 0, 0, 46, 0, 47, 0,
- 0, 0, 0, 0, 0, 0, 221, 0, 0, 0,
- 51, 48, 50, 49, 0, 52, 0, 53, 0, 55,
- 0, 56, 0, 0, 0, 0, 43, 54, 32, 0,
- 0, 0, 40, 0, 0, 0, 0, 45, 0, 0,
- 0, 0, 0, 0, 0, 0, 483, 0, 0, 29,
- 30, 31, 0, 0, 0, 0, 0, 0, 0, 0,
- 33, 0, 0, 0, 0, 0, 0, 34, 0, 0,
- 0, 35, 36, 0, 37, 0, 0, 0, 38, 0,
- 39, 41, 42, 0, 0, 44, 0, 0, 0, 46,
- 0, 47, 0, 0, 486, 0, 0, 0, 0, 0,
- 0, 0, 0, 51, 48, 50, 49, 0, 52, 0,
- 53, 0, 55, 0, 56, 0, 0, 0, 0, 43,
- 54, 32, 0, 0, 0, 40, 0, 0, 0, 0,
- 45, 0, 0, 0, 0, 0, 0, 0, 0, 29,
- 30, 31, 0, 0, 0, 0, 0, 0, 0, 0,
- 33, 0, 0, 0, 0, 0, 0, 34, 217, 0,
- 0, 578, 579, 0, 37, 0, 0, 0, 38, 0,
- 39, 41, 42, 0, 0, 44, 0, 0, 0, 46,
- 0, 47, 0, 0, 0, 0, 0, 0, 0, 221,
- 0, 0, 0, 51, 48, 50, 49, 0, 52, 0,
- 53, 0, 55, 0, 56, 0, 0, 0, 0, 43,
- 54, 32, 0, 0, 0, 40, 0, 0, 0, 0,
- 45, 0, 0, 0, 0, 0, 0, 0, 0, 475,
+ 0, 51, 48, 50, 49, 0, 52, 0, 53, 0,
+ 55, 0, 56, 0, 0, 0, 0, 43, 54, 32,
+ 0, 0, 0, 40, 0, 0, 0, 0, 45, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, -119, 0,
0, 0, 29, 30, 31, 0, 0, 0, 0, 0,
0, 0, 0, 33, 0, 0, 0, 0, 0, 0,
34, 0, 0, 0, 35, 36, 0, 37, 0, 0,
0, 38, 0, 39, 41, 42, 0, 0, 44, 0,
- 0, 0, 46, 0, 47, 0, 0, 481, 0, 0,
+ 0, 0, 46, 0, 47, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 51, 48, 50, 49,
0, 52, 0, 53, 0, 55, 0, 56, 0, 0,
0, 0, 43, 54, 32, 0, 0, 0, 40, 0,
0, 0, 0, 45, 0, 0, 0, 0, 0, 0,
- 0, 0, 483, 0, 0, 29, 30, 31, 0, 0,
- 0, 0, 0, 0, 0, 0, 33, 0, 0, 0,
- 0, 0, 0, 34, 0, 0, 0, 35, 36, 0,
- 37, 0, 0, 0, 38, 0, 39, 41, 42, 0,
- 0, 44, 0, 0, 0, 46, 0, 47, 0, 0,
- 484, 0, 0, 0, 0, 0, 0, 0, 0, 51,
- 48, 50, 49, 0, 52, 0, 53, 0, 55, 0,
- 56, 0, 0, 0, 0, 43, 54, 32, 0, 0,
- 0, 40, 0, 0, 0, 0, 45, 0, 0, 0,
- 0, 0, 0, 0, 0, 475, 0, 0, 29, 30,
+ 0, 0, 0, 29, 30, 31, 0, 0, 0, 0,
+ 0, 0, 0, 0, 33, 0, 0, 0, 0, 0,
+ 0, 34, 0, 0, 0, 35, 36, 0, 37, 0,
+ 0, 0, 38, 0, 39, 41, 42, 0, 0, 44,
+ 0, 0, 0, 46, 0, 47, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 51, 48, 50,
+ 49, 0, 52, 0, 53, 0, 55, 271, 56, 0,
+ 0, 0, 0, 43, 54, 32, 0, 0, 0, 40,
+ 0, 0, 0, 0, 45, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 29, 30, 31, 0, 0, 0,
+ 0, 0, 0, 0, 0, 33, 0, 0, 0, 0,
+ 0, 0, 34, 217, 0, 0, 218, 36, 0, 37,
+ 0, 0, 0, 38, 0, 39, 41, 42, 0, 0,
+ 44, 0, 0, 0, 46, 0, 47, 0, 0, 0,
+ 0, 0, 0, 0, 221, 0, 0, 0, 51, 48,
+ 50, 49, 0, 52, 0, 53, 0, 55, 0, 56,
+ 0, 0, 0, 0, 43, 54, 32, 0, 0, 0,
+ 40, 0, 0, 0, 0, 45, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 483, 0, 0, 29, 30,
31, 0, 0, 0, 0, 0, 0, 0, 0, 33,
0, 0, 0, 0, 0, 0, 34, 0, 0, 0,
35, 36, 0, 37, 0, 0, 0, 38, 0, 39,
41, 42, 0, 0, 44, 0, 0, 0, 46, 0,
- 47, 0, 0, 476, 0, 0, 0, 0, 0, 0,
+ 47, 0, 0, 486, 0, 0, 0, 0, 0, 0,
0, 0, 51, 48, 50, 49, 0, 52, 0, 53,
0, 55, 0, 56, 0, 0, 0, 0, 43, 54,
32, 0, 0, 0, 40, 0, 0, 0, 0, 45,
- 0, 0, 0, 0, 0, 0, 0, 0, 109, 110,
- 111, 0, 0, 113, 115, 116, 0, 0, 117, 0,
- 118, 0, 0, 0, 120, 121, 122, 0, 0, 0,
- 0, 0, 0, 34, 123, 124, 125, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 126, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 129, 0, 0, 0, 0, 0, 0,
- 48, 50, 49, 130, 131, 132, 0, 134, 135, 136,
- 137, 138, 139, 0, 0, 127, 133, 119, 112, 114,
- 128, 0, 0, 0, 0, 0, 45, 0, 0, 0,
- 0, 0, 0, 0, 0, 109, 110, 111, 0, 0,
- 113, 115, 116, 0, 0, 117, 0, 118, 0, 0,
- 0, 120, 121, 122, 0, 0, 0, 0, 0, 0,
- 393, 123, 124, 125, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 126, 0, 0, 0, 394, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 129, 0, 0, 0, 0, 0, 398, 395, 397, 0,
- 130, 131, 132, 0, 134, 135, 136, 137, 138, 139,
- 0, 0, 127, 133, 119, 112, 114, 128, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 29,
+ 30, 31, 0, 0, 0, 0, 0, 0, 0, 0,
+ 33, 0, 0, 0, 0, 0, 0, 34, 217, 0,
+ 0, 578, 579, 0, 37, 0, 0, 0, 38, 0,
+ 39, 41, 42, 0, 0, 44, 0, 0, 0, 46,
+ 0, 47, 0, 0, 0, 0, 0, 0, 0, 221,
+ 0, 0, 0, 51, 48, 50, 49, 0, 52, 0,
+ 53, 0, 55, 0, 56, 0, 0, 0, 0, 43,
+ 54, 32, 0, 0, 0, 40, 0, 0, 0, 0,
+ 45, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 475, 0, 0, 29, 30, 31, 0, 0, 0, 0,
+ 0, 0, 0, 0, 33, 0, 0, 0, 0, 0,
+ 0, 34, 0, 0, 0, 35, 36, 0, 37, 0,
+ 0, 0, 38, 0, 39, 41, 42, 0, 0, 44,
+ 0, 0, 0, 46, 0, 47, 0, 0, 481, 0,
+ 0, 0, 0, 0, 0, 0, 0, 51, 48, 50,
+ 49, 0, 52, 0, 53, 0, 55, 0, 56, 0,
+ 0, 0, 0, 43, 54, 32, 0, 0, 0, 40,
+ 0, 0, 0, 0, 45, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 483, 0, 0, 29, 30, 31,
+ 0, 0, 0, 0, 0, 0, 0, 0, 33, 0,
+ 0, 0, 0, 0, 0, 34, 0, 0, 0, 35,
+ 36, 0, 37, 0, 0, 0, 38, 0, 39, 41,
+ 42, 0, 0, 44, 0, 0, 0, 46, 0, 47,
+ 0, 0, 484, 0, 0, 0, 0, 0, 0, 0,
+ 0, 51, 48, 50, 49, 0, 52, 0, 53, 0,
+ 55, 0, 56, 0, 0, 0, 0, 43, 54, 32,
+ 0, 0, 0, 40, 0, 0, 0, 0, 45, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 475, 0,
+ 0, 29, 30, 31, 0, 0, 0, 0, 0, 0,
+ 0, 0, 33, 0, 0, 0, 0, 0, 0, 34,
+ 0, 0, 0, 35, 36, 0, 37, 0, 0, 0,
+ 38, 0, 39, 41, 42, 0, 0, 44, 0, 0,
+ 0, 46, 0, 47, 0, 0, 476, 0, 0, 0,
+ 0, 0, 0, 0, 0, 51, 48, 50, 49, 0,
+ 52, 0, 53, 0, 55, 0, 56, 0, 0, 0,
+ 0, 43, 54, 32, 0, 0, 0, 40, 0, 0,
+ 0, 0, 45, 0, 0, 0, 0, 0, 0, 0,
0, 0, 109, 110, 111, 0, 0, 113, 115, 116,
0, 0, 117, 0, 118, 0, 0, 0, 120, 121,
- 122, 0, 0, 0, 0, 0, 0, 393, 123, 124,
+ 122, 0, 0, 0, 0, 0, 0, 34, 123, 124,
125, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 126, 0, 0, 0, 394, 0, 0, 0, 0,
- 0, 0, 0, 396, 0, 0, 0, 129, 0, 0,
- 0, 0, 0, 398, 395, 397, 0, 130, 131, 132,
+ 0, 126, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 129, 0, 0,
+ 0, 0, 0, 0, 48, 50, 49, 130, 131, 132,
0, 134, 135, 136, 137, 138, 139, 0, 0, 127,
133, 119, 112, 114, 128, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 209,
- 0, 0, 0, 0, 211, 0, 29, 30, 31, 213,
- 0, 0, 0, 0, 0, 0, 214, 33, 0, 0,
- 0, 0, 0, 0, 216, 217, 0, 0, 218, 36,
- 0, 37, 0, 0, 0, 38, 0, 39, 41, 42,
- 0, 0, 44, 0, 0, 0, 46, 0, 47, 0,
- 0, 0, 0, 0, 220, 0, 221, 0, 0, 0,
- 51, 219, 222, 49, 223, 52, 224, 53, 225, 55,
- 226, 56, 227, 228, 0, 0, 43, 54, 32, 210,
- 212, 0, 40, 0, 0, 0, 0, 45, 0, 0,
+ 45, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 109, 110, 111, 0, 0, 113, 115, 116, 0, 0,
+ 117, 0, 118, 0, 0, 0, 120, 121, 122, 0,
+ 0, 0, 0, 0, 0, 393, 123, 124, 125, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 126,
+ 0, 0, 0, 394, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 129, 0, 0, 0, 0,
+ 0, 398, 395, 397, 0, 130, 131, 132, 0, 134,
+ 135, 136, 137, 138, 139, 0, 0, 127, 133, 119,
+ 112, 114, 128, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 109, 110,
+ 111, 0, 0, 113, 115, 116, 0, 0, 117, 0,
+ 118, 0, 0, 0, 120, 121, 122, 0, 0, 0,
+ 0, 0, 0, 393, 123, 124, 125, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 126, 0, 0,
+ 0, 394, 0, 0, 0, 0, 0, 0, 0, 396,
+ 0, 0, 0, 129, 0, 0, 0, 0, 0, 398,
+ 395, 397, 0, 130, 131, 132, 0, 134, 135, 136,
+ 137, 138, 139, 0, 0, 127, 133, 119, 112, 114,
+ 128, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 209, 0, 0, 0,
0, 211, 0, 29, 30, 31, 213, 0, 0, 0,
- 0, 0, 0, 214, 215, 0, 0, 0, 0, 0,
+ 0, 0, 0, 214, 33, 0, 0, 0, 0, 0,
0, 216, 217, 0, 0, 218, 36, 0, 37, 0,
0, 0, 38, 0, 39, 41, 42, 0, 0, 44,
0, 0, 0, 46, 0, 47, 0, 0, 0, 0,
49, 223, 52, 224, 53, 225, 55, 226, 56, 227,
228, 0, 0, 43, 54, 32, 210, 212, 0, 40,
0, 0, 0, 0, 45, 0, 0, 0, 0, 0,
- 0, 0, 0, 582, 110, 111, 0, 0, 584, 115,
- 586, 30, 31, 587, 0, 118, 0, 0, 0, 120,
- 589, 590, 0, 0, 0, 0, 0, 0, 591, 592,
- 124, 125, 218, 36, 0, 37, 0, 0, 0, 38,
- 0, 39, 593, 42, 0, 0, 595, 0, 0, 0,
- 46, 0, 47, 0, 0, 0, 0, 0, 597, 0,
- 221, 0, 0, 0, 599, 596, 598, 49, 600, 601,
- 602, 53, 604, 605, 606, 607, 608, 609, 0, 0,
- 594, 603, 588, 583, 585, 128, 40, 0, 0, 0,
- 0, 45, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 209, 0, 0, 0, 0, 211,
+ 0, 29, 30, 31, 213, 0, 0, 0, 0, 0,
+ 0, 214, 215, 0, 0, 0, 0, 0, 0, 216,
+ 217, 0, 0, 218, 36, 0, 37, 0, 0, 0,
+ 38, 0, 39, 41, 42, 0, 0, 44, 0, 0,
+ 0, 46, 0, 47, 0, 0, 0, 0, 0, 220,
+ 0, 221, 0, 0, 0, 51, 219, 222, 49, 223,
+ 52, 224, 53, 225, 55, 226, 56, 227, 228, 0,
+ 0, 43, 54, 32, 210, 212, 0, 40, 0, 0,
+ 0, 0, 45, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 582, 110, 111, 0, 0, 584, 115, 586,
+ 30, 31, 587, 0, 118, 0, 0, 0, 120, 589,
+ 590, 0, 0, 0, 0, 0, 0, 591, 592, 124,
+ 125, 218, 36, 0, 37, 0, 0, 0, 38, 0,
+ 39, 593, 42, 0, 0, 595, 0, 0, 0, 46,
+ 0, 47, 0, 0, 0, 0, 0, 597, 0, 221,
+ 0, 0, 0, 599, 596, 598, 49, 600, 601, 602,
+ 53, 604, 605, 606, 607, 608, 609, 0, 0, 594,
+ 603, 588, 583, 585, 128, 40, 0, 0, 0, 0,
+ 45, 0, 0, 0, 0, 0, 0, 0, 0, 0,
361, 110, 111, 0, 0, 363, 115, 365, 30, 31,
366, 0, 118, 0, 0, 0, 120, 368, 369, 0,
0, 0, 0, 0, 0, 370, 371, 124, 125, 218,
0, 378, 375, 377, 49, 379, 380, 381, 53, 383,
384, 385, 386, 387, 388, 0, 0, 373, 382, 367,
362, 364, 128, 40, 0, 0, 0, 0, 45, 0,
- 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
567, 169, 558, 570, 574, 515, 569, 557, 309, 548,
461, 528, 311, 530, 417, 555, 307, 188, 415, 358,
33, 7, 7, 29, 8, 60, 17, 7, 66, 37,
66, 24, 33, 7, 34, 5, 33, 36, 33, 7,
60, 5, 7, 33, 33, 7, 7, 20, 36, 36,
- 5, 7, 61, 36, 7, 7, 77, 36, 17, 8,
- 36, 79, 7, 2, 33, 36, 8, 1, 8, 36,
- 48, 2, 1, 55, 79, 1, 36, 2, 8, 60,
- 7, 31, 48, 0, 61, 36, 33, 8, 60, 7,
- 36, 2, 55, 36, 7, 1, 8, -1, -1, 15,
- 10, 8, -1, 60, 79, 8, 8, 61, 8, 50,
- 48, 48, 60, 54, 8, 7, 8, 8, 34, 42,
- 8, 8, 6, 8, -1, 61, 62, 8, 61, 62,
- 53, 8, 90, 61, 62, 79, 20, 61, 62, 61,
- 62, 61, 62, 15, 40, 55, 61, 62, 60, 7,
- 40, 8, 8, 60, 56, 51, 56, 60, 40, 8,
- 7, 51, 34, 61, 62, 56, 60, 40, 56, 51,
- 50, 56, 15, 60, 54, 61, 62, 29, 51, 60,
- 12, 12, 15, 60, 8, 61, 62, 25, -1, 27,
- 12, 34, -1, 36, 61, 62, 25, -1, 27, 29,
- 38, 34, 29, 36, 61, 61, 62, 7, 25, 38,
- 27, 7, 61, 62, 61, 62, 25, 25, 27, 27,
- -1, 38, 29, 75, 91, 57, 57, 7, 15, 38,
- 38, 63, 63, 33, 86, 57, -1, 61, 62, 15,
- 25, 63, 27, 8, 25, 75, 27, 34, 75, 36,
- 25, 29, 27, 38, -1, 29, 86, 38, 34, 86,
- 36, -1, -1, 38, 36, 61, 62, 15, 75, -1,
- -1, 18, 19, -1, -1, 18, 19, -1, -1, 86,
- -1, 61, 62, 18, 19, 33, 34, 29, 36, 61,
- 62, 47, 92, 18, 19, 60, 15, 75, 45, 46,
- -1, 75, 45, 46, -1, 61, 62, 29, 86, -1,
- 45, 46, 86, -1, 33, 34, 29, 36, 23, 24,
- 45, 46, 29, -1, 66, 67, 68, 32, 29, -1,
- 35, -1, 37, -1, 29, 91, 25, 29, 27, -1,
- -1, -1, -1, -1, 66, 67, 68, -1, -1, 38,
- 92, -1, -1, 66, 67, 68, -1, -1, -1, 66,
- 67, 68, -1, -1, -1, 66, 67, 68, 23, 24,
- 92, 66, 67, 68, 66, 67, 68, 32, -1, 92,
- 35, -1, 37, -1, -1, 92, -1, 23, 24, -1,
- -1, 92, -1, 23, 24, -1, 32, 92, -1, 35,
- 92, 37, 32, 29, -1, 35, -1, 37, 23, 24,
- 36, -1, 29, -1, -1, -1, 31, 32, 23, 24,
- 35, -1, 37, -1, -1, -1, 31, 32, -1, -1,
- 35, -1, 37, 93, 94, 95, 96, 97, 98, -1,
- 66, 67, 68, -1, 23, 24, -1, -1, -1, 66,
- 67, 68, 31, 32, -1, -1, 35, -1, 37, 23,
- 24, -1, 29, -1, -1, -1, 92, 31, 32, 23,
- 24, 35, 29, 37, -1, 92, -1, 31, 32, 36,
- 29, 35, -1, 37, 23, 24, -1, -1, -1, 29,
- -1, -1, -1, 32, 61, 62, 35, -1, 37, 66,
- 67, 68, -1, -1, -1, -1, -1, 29, -1, 66,
- 67, 68, 61, 62, -1, -1, 29, 66, 67, 68,
- -1, 61, 62, -1, -1, 92, 66, 67, 68, -1,
- -1, -1, -1, -1, -1, 92, -1, -1, -1, 61,
- 62, -1, -1, 92, 66, 67, 68, -1, 61, 62,
- -1, -1, 92, 66, 67, 68, -1, -1, -1, -1,
- -1, -1, 29, -1, -1, -1, -1, -1, 3, -1,
- 92, -1, -1, -1, -1, -1, -1, -1, 13, 92,
- -1, -1, 17, -1, -1, -1, -1, -1, -1, -1,
- -1, 26, -1, 28, 61, 62, 31, -1, -1, 66,
- 67, 68, -1, -1, 39, -1, 41, 42, -1, -1,
+ 5, 7, 61, 36, 7, 36, 7, 17, 8, 77,
+ 36, 7, 79, 2, 33, 36, 8, 1, 8, 36,
+ 48, 2, 1, 55, 79, 1, 48, 36, 8, 36,
+ 2, 60, 31, 7, 61, 33, 0, 8, 7, 2,
+ 7, 36, 55, 36, 60, 1, 8, 15, 8, 10,
+ 8, 8, -1, 8, 79, 8, 60, 48, 8, 61,
+ 48, 7, 8, 60, 50, 8, 34, 6, 54, 42,
+ 8, 15, 8, 8, 61, 62, 61, 62, 61, 62,
+ 53, 20, 90, 61, 62, 79, 61, 62, 8, 8,
+ 34, 61, 62, 40, 55, 61, 62, 8, 60, 56,
+ 60, 7, 60, 56, 51, 60, 56, 40, 40, 8,
+ 50, 29, 40, 56, 54, 15, 61, 62, 51, 51,
+ 56, 12, 60, 51, 25, 60, 27, 61, 62, 8,
+ 61, 62, 15, 25, 34, 27, 36, 38, 7, 12,
+ 60, 60, 12, 29, 61, 62, 38, 25, 29, 27,
+ 61, 34, 7, 36, 25, -1, 27, 75, 15, -1,
+ 38, 7, 61, 62, 33, 7, 57, 38, 86, -1,
+ -1, 29, 63, 25, 91, 27, 29, 34, 25, 36,
+ 27, 29, 61, 62, 57, -1, 38, 57, 47, 75,
+ 63, 38, 15, 63, 75, 25, 8, 27, -1, 25,
+ 86, 27, 61, 62, 36, 86, 61, 62, 38, 18,
+ 19, 34, 38, 36, -1, 61, 62, 75, -1, 61,
+ 62, 29, 75, 92, 18, 19, 15, 75, 86, 61,
+ 62, -1, 91, 86, 29, 15, 45, 46, 86, 18,
+ 19, 18, 19, 29, 33, 34, -1, 36, -1, 61,
+ 62, 45, 46, 33, 34, -1, 36, 29, 66, 67,
+ 68, 29, -1, -1, -1, -1, 45, 46, 45, 46,
+ 29, 66, 67, 68, 23, 24, 29, -1, -1, 29,
+ 66, 67, 68, 32, 92, -1, 35, -1, 37, 29,
+ 25, -1, 27, 29, 66, 67, 68, 92, 66, 67,
+ 68, -1, -1, 38, -1, -1, 92, 66, 67, 68,
+ -1, -1, -1, 66, 67, 68, 66, 67, 68, -1,
+ 92, -1, -1, -1, 92, -1, 66, 67, 68, -1,
+ 66, 67, 68, 92, 23, 24, -1, 29, -1, 92,
+ -1, -1, 92, 32, -1, -1, 35, 29, 37, 23,
+ 24, -1, 92, -1, 36, -1, 92, -1, 32, 23,
+ 24, 35, -1, 37, -1, -1, -1, 29, 32, 23,
+ 24, 35, -1, 37, 66, 67, 68, 31, 32, 23,
+ 24, 35, -1, 37, 66, 67, 68, 31, 32, -1,
+ -1, 35, -1, 37, 94, 95, 96, 97, 98, 99,
+ 92, -1, -1, -1, 66, 67, 68, 23, 24, -1,
+ 92, -1, -1, -1, -1, 31, 32, 23, 24, 35,
+ 29, 37, -1, -1, -1, 31, 32, 36, 29, 35,
+ 92, 37, -1, -1, 23, 24, 29, -1, -1, 29,
+ 23, 24, 31, 32, -1, -1, 35, 29, 37, 32,
+ -1, -1, 35, -1, 37, 29, -1, 66, 67, 68,
+ 61, 62, -1, -1, -1, 66, 67, 68, 61, 62,
+ -1, 61, 62, 66, 67, 68, 66, 67, 68, 61,
+ 62, -1, -1, 92, 66, 67, 68, 61, 62, -1,
+ -1, 92, 66, 67, 68, -1, -1, -1, 3, 92,
+ -1, -1, 92, -1, -1, -1, -1, -1, 13, -1,
+ 92, -1, 17, -1, -1, -1, -1, -1, 92, 29,
+ -1, 26, -1, 28, -1, -1, 31, -1, -1, -1,
+ -1, -1, -1, -1, 39, -1, 41, 42, -1, -1,
-1, -1, -1, -1, 49, -1, -1, 52, 53, -1,
- -1, -1, -1, 58, -1, 92, -1, -1, -1, 64,
- -1, -1, 12, 13, 3, -1, -1, -1, -1, -1,
- -1, -1, 22, -1, 13, 80, -1, -1, 17, 29,
- -1, -1, -1, 33, 34, -1, 36, 26, -1, 28,
- -1, -1, -1, 43, -1, -1, -1, 47, -1, -1,
- 39, -1, 41, 42, -1, -1, -1, -1, -1, -1,
- 49, -1, -1, 52, 53, 65, 66, 67, 68, 58,
- 70, -1, -1, -1, -1, 64, -1, -1, -1, -1,
- -1, 81, 82, 83, 12, 13, -1, 87, -1, -1,
- -1, 80, 92, -1, 22, -1, -1, -1, -1, -1,
- -1, 29, -1, -1, -1, 33, 34, -1, 36, -1,
- -1, -1, 12, 13, -1, 43, -1, -1, -1, 47,
- -1, -1, 22, -1, -1, -1, -1, -1, -1, 29,
- -1, -1, -1, 33, 34, -1, 36, 65, 66, 67,
- 68, -1, 70, 43, -1, -1, -1, 47, -1, -1,
- -1, -1, -1, 81, 82, 83, -1, -1, -1, 87,
- -1, -1, -1, -1, 92, 65, 66, 67, 68, -1,
- 70, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, 81, 82, 83, -1, -1, -1, 87, -1, -1,
- -1, -1, 92, 12, 13, -1, -1, -1, -1, -1,
- -1, 12, 13, 22, -1, -1, -1, -1, -1, -1,
- 29, 22, -1, -1, 33, 34, -1, 36, 29, -1,
- -1, -1, 33, 34, 43, 36, -1, -1, 47, -1,
- -1, -1, 43, -1, -1, -1, 47, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, 65, 66, 67, 68,
- -1, 70, -1, -1, 65, 66, 67, 68, -1, 70,
+ -1, 61, 62, 58, -1, -1, 66, 67, 68, 64,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, 80, -1, -1, -1, 12,
+ 13, -1, 92, -1, -1, -1, -1, -1, -1, 22,
+ -1, -1, 3, -1, -1, -1, 29, -1, -1, -1,
+ 33, 34, 13, 36, -1, -1, 17, -1, -1, -1,
+ 43, -1, -1, -1, 47, 26, -1, 28, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, 39, -1,
+ 41, 42, 65, 66, 67, 68, -1, 70, 49, -1,
+ -1, 52, 53, -1, -1, -1, -1, 58, 81, 82,
+ 83, -1, -1, 64, 87, -1, -1, -1, -1, 92,
+ -1, -1, -1, 12, 13, -1, -1, -1, -1, 80,
+ -1, -1, -1, 22, -1, -1, -1, -1, -1, -1,
+ 29, -1, -1, -1, 33, 34, -1, 36, -1, -1,
+ -1, 12, 13, -1, 43, -1, -1, -1, 47, -1,
+ -1, 22, -1, -1, -1, -1, -1, -1, 29, -1,
+ -1, -1, 33, 34, -1, 36, 65, 66, 67, 68,
+ -1, 70, 43, -1, -1, -1, 47, -1, -1, -1,
-1, -1, 81, 82, 83, -1, -1, -1, 87, -1,
- 81, 82, 83, 92, -1, -1, 87, -1, -1, -1,
- -1, 92, -1, -1, -1, -1, -1, -1, -1, -1,
- 12, 13, -1, -1, -1, -1, -1, -1, -1, -1,
- 22, -1, -1, -1, -1, -1, -1, 29, -1, -1,
- -1, 33, 34, -1, 36, -1, -1, -1, -1, -1,
- -1, 43, -1, -1, -1, 47, -1, -1, -1, -1,
+ -1, -1, -1, 92, 65, 66, 67, 68, -1, 70,
+ -1, -1, -1, 12, 13, -1, -1, -1, -1, -1,
+ 81, 82, 83, 22, -1, -1, 87, -1, -1, -1,
+ 29, 92, -1, -1, 33, 34, -1, 36, -1, -1,
+ -1, 12, 13, -1, 43, -1, -1, -1, 47, -1,
+ -1, 22, -1, -1, -1, -1, -1, -1, 29, -1,
+ -1, -1, 33, 34, -1, 36, 65, 66, 67, 68,
+ -1, 70, 43, -1, -1, -1, 47, -1, -1, -1,
+ -1, -1, 81, 82, 83, -1, -1, -1, 87, -1,
+ -1, -1, -1, 92, 65, 66, 67, 68, -1, 70,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, 65, 66, 67, 68, -1, 70, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, 81,
- 82, 83, -1, -1, -1, 87, -1, -1, -1, -1,
- 92, -1, -1, -1, -1, -1, -1, -1, -1, 10,
+ 81, 82, 83, -1, -1, -1, 87, -1, -1, -1,
+ -1, 92, -1, -1, -1, -1, -1, -1, -1, -1,
-1, 12, 13, -1, -1, -1, -1, -1, -1, -1,
-1, 22, -1, -1, -1, -1, -1, -1, 29, -1,
-1, -1, 33, 34, -1, 36, -1, -1, -1, -1,
-1, -1, 43, -1, -1, -1, 47, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, 65, 66, 67, 68, -1, 70,
- -1, -1, -1, -1, 75, -1, -1, -1, -1, -1,
- 81, 82, 83, 84, -1, -1, 87, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ 81, 82, 83, -1, -1, -1, 87, -1, -1, -1,
-1, 92, -1, -1, -1, -1, -1, -1, -1, -1,
- 10, -1, 12, 13, -1, -1, -1, -1, -1, -1,
- -1, -1, 22, -1, -1, -1, -1, -1, -1, 29,
- -1, -1, -1, 33, 34, -1, 36, -1, -1, -1,
- -1, -1, -1, 43, -1, -1, -1, 47, -1, -1,
- -1, -1, -1, -1, -1, 55, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, 65, 66, 67, 68, -1,
- 70, -1, -1, -1, -1, 75, -1, -1, -1, -1,
- -1, 81, 82, 83, 84, -1, -1, 87, -1, -1,
- -1, -1, 92, -1, -1, -1, -1, -1, -1, -1,
-1, 10, -1, 12, 13, -1, -1, -1, -1, -1,
-1, -1, -1, 22, -1, -1, -1, -1, -1, -1,
29, -1, -1, -1, 33, 34, -1, 36, -1, -1,
-1, -1, -1, -1, 43, -1, -1, -1, 47, -1,
- -1, -1, -1, -1, -1, -1, 55, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, 65, 66, 67, 68,
-1, 70, -1, -1, -1, -1, 75, -1, -1, -1,
-1, -1, 81, 82, 83, 84, -1, -1, 87, -1,
-1, -1, -1, 92, -1, -1, -1, -1, -1, -1,
- -1, -1, 11, 12, 13, -1, -1, -1, -1, -1,
- -1, -1, -1, 22, -1, -1, -1, -1, -1, -1,
- 29, -1, -1, -1, 33, 34, -1, 36, -1, -1,
- -1, 40, -1, 42, 43, 44, -1, -1, 47, -1,
- -1, -1, 51, -1, 53, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, 65, 66, 67, 68,
- -1, 70, -1, 72, -1, 74, -1, 76, -1, -1,
- -1, -1, 81, 82, 83, -1, -1, -1, 87, -1,
- -1, -1, -1, 92, -1, -1, -1, -1, -1, -1,
- -1, -1, 7, -1, -1, -1, 11, 12, 13, -1,
+ -1, -1, -1, 10, -1, 12, 13, -1, -1, -1,
+ -1, -1, -1, -1, -1, 22, -1, -1, -1, -1,
+ -1, -1, 29, -1, -1, -1, 33, 34, -1, 36,
+ -1, -1, -1, -1, -1, -1, 43, -1, -1, -1,
+ 47, -1, -1, -1, -1, -1, -1, -1, 55, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, 65, 66,
+ 67, 68, -1, 70, -1, -1, -1, -1, 75, -1,
+ -1, -1, -1, -1, 81, 82, 83, 84, -1, -1,
+ 87, -1, -1, -1, -1, 92, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, 10, -1, 12, 13, -1,
-1, -1, -1, -1, -1, -1, -1, 22, -1, -1,
-1, -1, -1, -1, 29, -1, -1, -1, 33, 34,
- -1, 36, -1, -1, -1, 40, -1, 42, 43, 44,
- -1, -1, 47, -1, -1, -1, 51, -1, 53, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- 65, 66, 67, 68, -1, 70, -1, 72, -1, 74,
- -1, 76, -1, -1, -1, -1, 81, 82, 83, -1,
+ -1, 36, -1, -1, -1, -1, -1, -1, 43, -1,
+ -1, -1, 47, -1, -1, -1, -1, -1, -1, -1,
+ 55, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ 65, 66, 67, 68, -1, 70, -1, -1, -1, -1,
+ 75, -1, -1, -1, -1, -1, 81, 82, 83, 84,
-1, -1, 87, -1, -1, -1, -1, 92, -1, -1,
- -1, -1, -1, -1, -1, -1, 11, 12, 13, -1,
- -1, -1, -1, -1, -1, -1, -1, 22, -1, -1,
- -1, -1, -1, -1, 29, -1, -1, -1, 33, 34,
- -1, 36, -1, -1, -1, 40, -1, 42, 43, 44,
- -1, -1, 47, -1, -1, -1, 51, -1, 53, -1,
+ -1, -1, -1, -1, -1, -1, -1, 11, 12, 13,
+ -1, -1, -1, -1, -1, -1, -1, -1, 22, -1,
+ -1, -1, -1, -1, -1, 29, -1, -1, -1, 33,
+ 34, -1, 36, -1, -1, -1, 40, -1, 42, 43,
+ 44, -1, -1, 47, -1, -1, -1, 51, -1, 53,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- 65, 66, 67, 68, -1, 70, -1, 72, -1, 74,
- 75, 76, -1, -1, -1, -1, 81, 82, 83, -1,
- -1, -1, 87, -1, -1, -1, -1, 92, -1, -1,
- -1, -1, -1, -1, -1, -1, 11, 12, 13, -1,
- -1, -1, -1, -1, -1, -1, -1, 22, -1, -1,
- -1, -1, -1, -1, 29, 30, -1, -1, 33, 34,
- -1, 36, -1, -1, -1, 40, -1, 42, 43, 44,
- -1, -1, 47, -1, -1, -1, 51, -1, 53, -1,
- -1, -1, -1, -1, -1, -1, 61, -1, -1, -1,
- 65, 66, 67, 68, -1, 70, -1, 72, -1, 74,
- -1, 76, -1, -1, -1, -1, 81, 82, 83, -1,
- -1, -1, 87, -1, -1, -1, -1, 92, -1, -1,
- -1, -1, -1, -1, -1, -1, 8, -1, -1, 11,
- 12, 13, -1, -1, -1, -1, -1, -1, -1, -1,
- 22, -1, -1, -1, -1, -1, -1, 29, -1, -1,
- -1, 33, 34, -1, 36, -1, -1, -1, 40, -1,
- 42, 43, 44, -1, -1, 47, -1, -1, -1, 51,
- -1, 53, -1, -1, 56, -1, -1, -1, -1, -1,
- -1, -1, -1, 65, 66, 67, 68, -1, 70, -1,
- 72, -1, 74, -1, 76, -1, -1, -1, -1, 81,
- 82, 83, -1, -1, -1, 87, -1, -1, -1, -1,
- 92, -1, -1, -1, -1, -1, -1, -1, -1, 11,
- 12, 13, -1, -1, -1, -1, -1, -1, -1, -1,
- 22, -1, -1, -1, -1, -1, -1, 29, 30, -1,
- -1, 33, 34, -1, 36, -1, -1, -1, 40, -1,
- 42, 43, 44, -1, -1, 47, -1, -1, -1, 51,
- -1, 53, -1, -1, -1, -1, -1, -1, -1, 61,
- -1, -1, -1, 65, 66, 67, 68, -1, 70, -1,
- 72, -1, 74, -1, 76, -1, -1, -1, -1, 81,
- 82, 83, -1, -1, -1, 87, -1, -1, -1, -1,
- 92, -1, -1, -1, -1, -1, -1, -1, -1, 8,
+ -1, 65, 66, 67, 68, -1, 70, -1, 72, -1,
+ 74, -1, 76, -1, -1, -1, -1, 81, 82, 83,
+ -1, -1, -1, 87, -1, -1, -1, -1, 92, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, 7, -1,
-1, -1, 11, 12, 13, -1, -1, -1, -1, -1,
-1, -1, -1, 22, -1, -1, -1, -1, -1, -1,
29, -1, -1, -1, 33, 34, -1, 36, -1, -1,
-1, 40, -1, 42, 43, 44, -1, -1, 47, -1,
- -1, -1, 51, -1, 53, -1, -1, 56, -1, -1,
+ -1, -1, 51, -1, 53, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, 65, 66, 67, 68,
-1, 70, -1, 72, -1, 74, -1, 76, -1, -1,
-1, -1, 81, 82, 83, -1, -1, -1, 87, -1,
-1, -1, -1, 92, -1, -1, -1, -1, -1, -1,
- -1, -1, 8, -1, -1, 11, 12, 13, -1, -1,
- -1, -1, -1, -1, -1, -1, 22, -1, -1, -1,
- -1, -1, -1, 29, -1, -1, -1, 33, 34, -1,
- 36, -1, -1, -1, 40, -1, 42, 43, 44, -1,
- -1, 47, -1, -1, -1, 51, -1, 53, -1, -1,
- 56, -1, -1, -1, -1, -1, -1, -1, -1, 65,
- 66, 67, 68, -1, 70, -1, 72, -1, 74, -1,
- 76, -1, -1, -1, -1, 81, 82, 83, -1, -1,
- -1, 87, -1, -1, -1, -1, 92, -1, -1, -1,
+ -1, -1, -1, 11, 12, 13, -1, -1, -1, -1,
+ -1, -1, -1, -1, 22, -1, -1, -1, -1, -1,
+ -1, 29, -1, -1, -1, 33, 34, -1, 36, -1,
+ -1, -1, 40, -1, 42, 43, 44, -1, -1, 47,
+ -1, -1, -1, 51, -1, 53, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, 65, 66, 67,
+ 68, -1, 70, -1, 72, -1, 74, 75, 76, -1,
+ -1, -1, -1, 81, 82, 83, -1, -1, -1, 87,
+ -1, -1, -1, -1, 92, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, 11, 12, 13, -1, -1, -1,
+ -1, -1, -1, -1, -1, 22, -1, -1, -1, -1,
+ -1, -1, 29, 30, -1, -1, 33, 34, -1, 36,
+ -1, -1, -1, 40, -1, 42, 43, 44, -1, -1,
+ 47, -1, -1, -1, 51, -1, 53, -1, -1, -1,
+ -1, -1, -1, -1, 61, -1, -1, -1, 65, 66,
+ 67, 68, -1, 70, -1, 72, -1, 74, -1, 76,
+ -1, -1, -1, -1, 81, 82, 83, -1, -1, -1,
+ 87, -1, -1, -1, -1, 92, -1, -1, -1, -1,
-1, -1, -1, -1, -1, 8, -1, -1, 11, 12,
13, -1, -1, -1, -1, -1, -1, -1, -1, 22,
-1, -1, -1, -1, -1, -1, 29, -1, -1, -1,
-1, -1, 65, 66, 67, 68, -1, 70, -1, 72,
-1, 74, -1, 76, -1, -1, -1, -1, 81, 82,
83, -1, -1, -1, 87, -1, -1, -1, -1, 92,
- -1, -1, -1, -1, -1, -1, -1, -1, 4, 5,
- 6, -1, -1, 9, 10, 11, -1, -1, 14, -1,
- 16, -1, -1, -1, 20, 21, 22, -1, -1, -1,
- -1, -1, -1, 29, 30, 31, 32, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, 43, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, 59, -1, -1, -1, -1, -1, -1,
- 66, 67, 68, 69, 70, 71, -1, 73, 74, 75,
- 76, 77, 78, -1, -1, 81, 82, 83, 84, 85,
- 86, -1, -1, -1, -1, -1, 92, -1, -1, -1,
- -1, -1, -1, -1, -1, 4, 5, 6, -1, -1,
- 9, 10, 11, -1, -1, 14, -1, 16, -1, -1,
- -1, 20, 21, 22, -1, -1, -1, -1, -1, -1,
- 29, 30, 31, 32, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, 43, -1, -1, -1, 47, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- 59, -1, -1, -1, -1, -1, 65, 66, 67, -1,
- 69, 70, 71, -1, 73, 74, 75, 76, 77, 78,
- -1, -1, 81, 82, 83, 84, 85, 86, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, 11,
+ 12, 13, -1, -1, -1, -1, -1, -1, -1, -1,
+ 22, -1, -1, -1, -1, -1, -1, 29, 30, -1,
+ -1, 33, 34, -1, 36, -1, -1, -1, 40, -1,
+ 42, 43, 44, -1, -1, 47, -1, -1, -1, 51,
+ -1, 53, -1, -1, -1, -1, -1, -1, -1, 61,
+ -1, -1, -1, 65, 66, 67, 68, -1, 70, -1,
+ 72, -1, 74, -1, 76, -1, -1, -1, -1, 81,
+ 82, 83, -1, -1, -1, 87, -1, -1, -1, -1,
+ 92, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ 8, -1, -1, 11, 12, 13, -1, -1, -1, -1,
+ -1, -1, -1, -1, 22, -1, -1, -1, -1, -1,
+ -1, 29, -1, -1, -1, 33, 34, -1, 36, -1,
+ -1, -1, 40, -1, 42, 43, 44, -1, -1, 47,
+ -1, -1, -1, 51, -1, 53, -1, -1, 56, -1,
+ -1, -1, -1, -1, -1, -1, -1, 65, 66, 67,
+ 68, -1, 70, -1, 72, -1, 74, -1, 76, -1,
+ -1, -1, -1, 81, 82, 83, -1, -1, -1, 87,
+ -1, -1, -1, -1, 92, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, 8, -1, -1, 11, 12, 13,
+ -1, -1, -1, -1, -1, -1, -1, -1, 22, -1,
+ -1, -1, -1, -1, -1, 29, -1, -1, -1, 33,
+ 34, -1, 36, -1, -1, -1, 40, -1, 42, 43,
+ 44, -1, -1, 47, -1, -1, -1, 51, -1, 53,
+ -1, -1, 56, -1, -1, -1, -1, -1, -1, -1,
+ -1, 65, 66, 67, 68, -1, 70, -1, 72, -1,
+ 74, -1, 76, -1, -1, -1, -1, 81, 82, 83,
+ -1, -1, -1, 87, -1, -1, -1, -1, 92, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, 8, -1,
+ -1, 11, 12, 13, -1, -1, -1, -1, -1, -1,
+ -1, -1, 22, -1, -1, -1, -1, -1, -1, 29,
+ -1, -1, -1, 33, 34, -1, 36, -1, -1, -1,
+ 40, -1, 42, 43, 44, -1, -1, 47, -1, -1,
+ -1, 51, -1, 53, -1, -1, 56, -1, -1, -1,
+ -1, -1, -1, -1, -1, 65, 66, 67, 68, -1,
+ 70, -1, 72, -1, 74, -1, 76, -1, -1, -1,
+ -1, 81, 82, 83, -1, -1, -1, 87, -1, -1,
+ -1, -1, 92, -1, -1, -1, -1, -1, -1, -1,
-1, -1, 4, 5, 6, -1, -1, 9, 10, 11,
-1, -1, 14, -1, 16, -1, -1, -1, 20, 21,
22, -1, -1, -1, -1, -1, -1, 29, 30, 31,
32, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, 43, -1, -1, -1, 47, -1, -1, -1, -1,
- -1, -1, -1, 55, -1, -1, -1, 59, -1, -1,
- -1, -1, -1, 65, 66, 67, -1, 69, 70, 71,
+ -1, 43, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, 59, -1, -1,
+ -1, -1, -1, -1, 66, 67, 68, 69, 70, 71,
-1, 73, 74, 75, 76, 77, 78, -1, -1, 81,
82, 83, 84, 85, 86, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, 4,
- -1, -1, -1, -1, 9, -1, 11, 12, 13, 14,
- -1, -1, -1, -1, -1, -1, 21, 22, -1, -1,
- -1, -1, -1, -1, 29, 30, -1, -1, 33, 34,
- -1, 36, -1, -1, -1, 40, -1, 42, 43, 44,
- -1, -1, 47, -1, -1, -1, 51, -1, 53, -1,
- -1, -1, -1, -1, 59, -1, 61, -1, -1, -1,
- 65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
- 75, 76, 77, 78, -1, -1, 81, 82, 83, 84,
- 85, -1, 87, -1, -1, -1, -1, 92, -1, -1,
+ 92, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ 4, 5, 6, -1, -1, 9, 10, 11, -1, -1,
+ 14, -1, 16, -1, -1, -1, 20, 21, 22, -1,
+ -1, -1, -1, -1, -1, 29, 30, 31, 32, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, 43,
+ -1, -1, -1, 47, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, 59, -1, -1, -1, -1,
+ -1, 65, 66, 67, -1, 69, 70, 71, -1, 73,
+ 74, 75, 76, 77, 78, -1, -1, 81, 82, 83,
+ 84, 85, 86, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, 4, 5,
+ 6, -1, -1, 9, 10, 11, -1, -1, 14, -1,
+ 16, -1, -1, -1, 20, 21, 22, -1, -1, -1,
+ -1, -1, -1, 29, 30, 31, 32, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, 43, -1, -1,
+ -1, 47, -1, -1, -1, -1, -1, -1, -1, 55,
+ -1, -1, -1, 59, -1, -1, -1, -1, -1, 65,
+ 66, 67, -1, 69, 70, 71, -1, 73, 74, 75,
+ 76, 77, 78, -1, -1, 81, 82, 83, 84, 85,
+ 86, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, 4, -1, -1, -1,
-1, 9, -1, 11, 12, 13, 14, -1, -1, -1,
-1, -1, -1, 21, 22, -1, -1, -1, -1, -1,
68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
78, -1, -1, 81, 82, 83, 84, 85, -1, 87,
-1, -1, -1, -1, 92, -1, -1, -1, -1, -1,
- -1, -1, -1, 4, 5, 6, -1, -1, 9, 10,
- 11, 12, 13, 14, -1, 16, -1, -1, -1, 20,
- 21, 22, -1, -1, -1, -1, -1, -1, 29, 30,
- 31, 32, 33, 34, -1, 36, -1, -1, -1, 40,
- -1, 42, 43, 44, -1, -1, 47, -1, -1, -1,
- 51, -1, 53, -1, -1, -1, -1, -1, 59, -1,
- 61, -1, -1, -1, 65, 66, 67, 68, 69, 70,
- 71, 72, 73, 74, 75, 76, 77, 78, -1, -1,
- 81, 82, 83, 84, 85, 86, 87, -1, -1, -1,
- -1, 92, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, 4, -1, -1, -1, -1, 9,
+ -1, 11, 12, 13, 14, -1, -1, -1, -1, -1,
+ -1, 21, 22, -1, -1, -1, -1, -1, -1, 29,
+ 30, -1, -1, 33, 34, -1, 36, -1, -1, -1,
+ 40, -1, 42, 43, 44, -1, -1, 47, -1, -1,
+ -1, 51, -1, 53, -1, -1, -1, -1, -1, 59,
+ -1, 61, -1, -1, -1, 65, 66, 67, 68, 69,
+ 70, 71, 72, 73, 74, 75, 76, 77, 78, -1,
+ -1, 81, 82, 83, 84, 85, -1, 87, -1, -1,
+ -1, -1, 92, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, 4, 5, 6, -1, -1, 9, 10, 11,
+ 12, 13, 14, -1, 16, -1, -1, -1, 20, 21,
+ 22, -1, -1, -1, -1, -1, -1, 29, 30, 31,
+ 32, 33, 34, -1, 36, -1, -1, -1, 40, -1,
+ 42, 43, 44, -1, -1, 47, -1, -1, -1, 51,
+ -1, 53, -1, -1, -1, -1, -1, 59, -1, 61,
+ -1, -1, -1, 65, 66, 67, 68, 69, 70, 71,
+ 72, 73, 74, 75, 76, 77, 78, -1, -1, 81,
+ 82, 83, 84, 85, 86, 87, -1, -1, -1, -1,
+ 92, -1, -1, -1, -1, -1, -1, -1, -1, -1,
4, 5, 6, -1, -1, 9, 10, 11, 12, 13,
14, -1, 16, -1, -1, -1, 20, 21, 22, -1,
-1, -1, -1, -1, -1, 29, 30, 31, 32, 33,
-1, 65, 66, 67, 68, 69, 70, 71, 72, 73,
74, 75, 76, 77, 78, -1, -1, 81, 82, 83,
84, 85, 86, 87, -1, -1, -1, -1, 92, -1,
- -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1,
26, 36, 15, 15, 15, 15, 26, 26, 3, 15,
15, 26, 2, 15, 3, 19, 2, 15, 2, 2,
OSDN Git Service
