diff --git a/CHANGELOG.md b/CHANGELOG.md index 3c4783b1058e..a71e8fc799b6 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -11,6 +11,7 @@ Compatibility: * Fix `Hash#shift` when Hash is empty but has initial default value or initial default proc (@itarato). * Make `Array#shuffle` produce the same results as CRuby (@rwstauner). * Add `Process.argv0` method (@andrykonchin). +* Add support for array pattern matching. This is opt-in via `--pattern-matching` since pattern matching is not fully supported yet. (#2683, @razetime). Performance: diff --git a/spec/ruby/language/pattern_matching_spec.rb b/spec/ruby/language/pattern_matching_spec.rb index f3cc86fa0b79..e4b7a5105e9e 100644 --- a/spec/ruby/language/pattern_matching_spec.rb +++ b/spec/ruby/language/pattern_matching_spec.rb @@ -205,7 +205,7 @@ in [] end RUBY - }.should raise_error(SyntaxError, /syntax error, unexpected `in'/) + }.should raise_error(SyntaxError, /syntax error, unexpected `in'|\(eval\):3: syntax error, unexpected keyword_in/) -> { eval <<~RUBY @@ -214,7 +214,7 @@ when 1 == 1 end RUBY - }.should raise_error(SyntaxError, /syntax error, unexpected `when'/) + }.should raise_error(SyntaxError, /syntax error, unexpected `when'|\(eval\):3: syntax error, unexpected keyword_when/) end it "checks patterns until the first matching" do @@ -251,6 +251,18 @@ }.should raise_error(NoMatchingPatternError, /\[0, 1\]/) end + it "raises NoMatchingPatternError if no pattern matches and evaluates the expression only once" do + evals = 0 + -> { + eval <<~RUBY + case (evals += 1; [0, 1]) + in [0] + end + RUBY + }.should raise_error(NoMatchingPatternError, /\[0, 1\]/) + evals.should == 1 + end + it "does not allow calculation or method calls in a pattern" do -> { eval <<~RUBY diff --git a/spec/tags/language/pattern_matching_tags.txt b/spec/tags/language/pattern_matching_tags.txt index f807e5b3c2b5..d31a73fab187 100644 --- a/spec/tags/language/pattern_matching_tags.txt +++ b/spec/tags/language/pattern_matching_tags.txt @@ -1,20 +1,4 @@ -fails:Pattern matching binds variables -fails:Pattern matching cannot mix in and when operators -fails:Pattern matching raises NoMatchingPatternError if no pattern matches and no else clause -fails:Pattern matching guards supports if guard -fails:Pattern matching guards supports unless guard -fails:Pattern matching guards makes bound variables visible in guard -fails:Pattern matching guards does not evaluate guard if pattern does not match -fails:Pattern matching guards takes guards into account when there are several matching patterns -fails:Pattern matching guards executes else clause if no guarded pattern matches -fails:Pattern matching guards raises NoMatchingPatternError if no guarded pattern matches and no else clause -fails:Pattern matching variable pattern matches a value and binds variable name to this value -fails:Pattern matching variable pattern makes bounded variable visible outside a case statement scope -fails:Pattern matching variable pattern create local variables even if a pattern doesn't match -fails:Pattern matching variable pattern allow using _ name to drop values -fails:Pattern matching variable pattern supports using _ in a pattern several times fails:Pattern matching variable pattern supports using any name with _ at the beginning in a pattern several times -fails:Pattern matching variable pattern does not support using variable name (except _) several times fails:Pattern matching variable pattern supports existing variables in a pattern specified with ^ operator fails:Pattern matching variable pattern allows applying ^ operator to bound variables fails:Pattern matching variable pattern requires bound variable to be specified in a pattern before ^ operator when it relies on a bound variable @@ -24,20 +8,9 @@ fails:Pattern matching alternative pattern support underscore prefixed variables fails:Pattern matching AS pattern binds a variable to a value if pattern matches fails:Pattern matching AS pattern can be used as a nested pattern fails:Pattern matching Array pattern supports form Constant(pat, pat, ...) -fails:Pattern matching Array pattern supports form pat, pat, ... -fails:Pattern matching Array pattern does not match object if Constant === object returns false -fails:Pattern matching Array pattern does not match object without #deconstruct method -fails:Pattern matching Array pattern raises TypeError if #deconstruct method does not return array -fails:Pattern matching Array pattern does not match object if elements of array returned by #deconstruct method does not match elements in pattern -fails:Pattern matching Array pattern binds variables -fails:Pattern matching Array pattern supports splat operator *rest -fails:Pattern matching Array pattern does match partially from the array beginning if list + , syntax used -fails:Pattern matching Array pattern matches anything with * fails:Pattern matching Hash pattern supports form id: pat, id: pat, ... fails:Pattern matching Hash pattern supports a: which means a: a fails:Pattern matching Hash pattern can mix key (a:) and key-value (a: b) declarations -fails:Pattern matching Hash pattern does not support string interpolation in keys -fails:Pattern matching Hash pattern raise SyntaxError when keys duplicate in pattern fails:Pattern matching Hash pattern does not match object if Constant === object returns false fails:Pattern matching Hash pattern does not match object without #deconstruct_keys method fails:Pattern matching Hash pattern does not match object if #deconstruct_keys method does not return Hash @@ -51,17 +24,10 @@ fails:Pattern matching Hash pattern supports double splat operator **rest fails:Pattern matching Hash pattern treats **nil like there should not be any other keys in a matched Hash fails:Pattern matching Hash pattern matches anything with ** fails:Pattern matching refinements are used for #deconstruct_keys -fails:Pattern matching does not allow calculation or method calls in a pattern -fails:Pattern matching Hash pattern does not support non-symbol keys fails:Pattern matching Array pattern accepts a subclass of Array from #deconstruct fails:Pattern matching can be standalone assoc operator that deconstructs value fails:Pattern matching Array pattern calls #deconstruct once for multiple patterns, caching the result -fails:Pattern matching find pattern captures preceding elements to the pattern -fails:Pattern matching find pattern captures following elements to the pattern fails:Pattern matching find pattern captures both preceding and following elements to the pattern -fails:Pattern matching find pattern can capture the entirety of the pattern -fails:Pattern matching find pattern will match an empty Array-like structure -fails:Pattern matching warning when regular form does not warn about pattern matching is experimental feature fails:Pattern matching warning when one-line form warns about pattern matching is experimental feature fails:Pattern matching alternative pattern can be used as a nested pattern fails:Pattern matching Array pattern can be used as a nested pattern @@ -76,3 +42,12 @@ fails:Pattern matching supports pinning class variables fails:Pattern matching supports pinning global variables fails:Pattern matching supports pinning expressions fails:Pattern matching warning when one-line form does not warn about pattern matching is experimental feature +fails:Pattern matching Hash pattern supports form Constant(id: pat, id: pat, ...) +fails:Pattern matching Hash pattern supports form Constant[id: pat, id: pat, ...] +fails:Pattern matching Hash pattern supports form {id: pat, id: pat, ...} +fails:Pattern matching Hash pattern supports 'string': key literal +fails:Pattern matching Hash pattern matches an object with #deconstruct_keys method which returns a Hash with equal keys and each value in Hash matches value in pattern +fails:Pattern matching Hash pattern calls #deconstruct_keys per pattern +fails:Pattern matching Hash pattern can match partially +fails:Pattern matching Hash pattern matches {} with {} +fails:Pattern matching refinements are used for #deconstruct diff --git a/src/main/java/org/truffleruby/core/CoreLibrary.java b/src/main/java/org/truffleruby/core/CoreLibrary.java index 65d7cdcb53aa..83c0e54ce8e8 100644 --- a/src/main/java/org/truffleruby/core/CoreLibrary.java +++ b/src/main/java/org/truffleruby/core/CoreLibrary.java @@ -233,6 +233,7 @@ public class CoreLibrary { public final GlobalVariables globalVariables; public final BindingLocalVariablesObject interactiveBindingLocalVariablesObject; + public final RubyClass noMatchingPatternErrorClass; @CompilationFinal private RubyClass eagainWaitReadable; @CompilationFinal private RubyClass eagainWaitWritable; @@ -331,6 +332,7 @@ public CoreLibrary(RubyContext context, RubyLanguage language) { unsupportedMessageErrorClass = defineClass(polyglotModule, standardErrorClass, "UnsupportedMessageError"); polyglotForeignObjectClass = defineClass(polyglotModule, objectClass, "ForeignObject"); polyglotForeignClasses = new RubyClass[ForeignClassNode.Trait.COMBINATIONS]; + noMatchingPatternErrorClass = defineClass(standardErrorClass, "NoMatchingPatternError"); // StandardError > RuntimeError runtimeErrorClass = defineClass(standardErrorClass, "RuntimeError"); diff --git a/src/main/java/org/truffleruby/core/array/ArrayPatternLengthCheckNode.java b/src/main/java/org/truffleruby/core/array/ArrayPatternLengthCheckNode.java new file mode 100644 index 000000000000..44920a88f6f5 --- /dev/null +++ b/src/main/java/org/truffleruby/core/array/ArrayPatternLengthCheckNode.java @@ -0,0 +1,52 @@ +/* + * Copyright (c) 2022, 2023 Oracle and/or its affiliates. All rights reserved. This + * code is released under a tri EPL/GPL/LGPL license. You can use it, + * redistribute it and/or modify it under the terms of the: + * + * Eclipse Public License version 2.0, or + * GNU General Public License version 2, or + * GNU Lesser General Public License version 2.1. + */ +package org.truffleruby.core.array; + +import com.oracle.truffle.api.profiles.ConditionProfile; +import org.truffleruby.language.RubyContextSourceNode; +import org.truffleruby.language.RubyNode; + +import com.oracle.truffle.api.frame.VirtualFrame; + +public class ArrayPatternLengthCheckNode extends RubyContextSourceNode { + + @Child RubyNode currentValueToMatch; + final int patternLength; + final boolean hasRest; + + final ConditionProfile isArrayProfile = ConditionProfile.create(); + + public ArrayPatternLengthCheckNode(int patternLength, RubyNode currentValueToMatch, boolean hasRest) { + this.currentValueToMatch = currentValueToMatch; + this.patternLength = patternLength; + this.hasRest = hasRest; + } + + @Override + public Object execute(VirtualFrame frame) { + Object matchArray = currentValueToMatch.execute(frame); + if (isArrayProfile.profile(matchArray instanceof RubyArray)) { + long size = ((RubyArray) matchArray).getArraySize(); + if (hasRest) { + return patternLength <= size; + } else { + return patternLength == size; + } + } else { + return false; + } + } + + @Override + public RubyNode cloneUninitialized() { + return new ArrayPatternLengthCheckNode(patternLength, currentValueToMatch.cloneUninitialized(), hasRest) + .copyFlags(this); + } +} diff --git a/src/main/java/org/truffleruby/core/exception/CoreExceptions.java b/src/main/java/org/truffleruby/core/exception/CoreExceptions.java index 4eade6e7b0e4..095724326854 100644 --- a/src/main/java/org/truffleruby/core/exception/CoreExceptions.java +++ b/src/main/java/org/truffleruby/core/exception/CoreExceptions.java @@ -378,6 +378,15 @@ public RubyException noMemoryError(Node currentNode, OutOfMemoryError javaThrowa javaThrowable); } + // NoMatchingPatternError + + @TruffleBoundary + public RubyException noMatchingPatternError(Object errorMessage, Node currentNode) { + assert RubyStringLibrary.getUncached().isRubyString(errorMessage); + RubyClass exceptionClass = context.getCoreLibrary().noMatchingPatternErrorClass; + return ExceptionOperations.createRubyException(context, exceptionClass, errorMessage, currentNode, null); + } + // Errno @TruffleBoundary diff --git a/src/main/java/org/truffleruby/core/string/TStringConstants.java b/src/main/java/org/truffleruby/core/string/TStringConstants.java index 7351fa511ff2..6e128f63152e 100644 --- a/src/main/java/org/truffleruby/core/string/TStringConstants.java +++ b/src/main/java/org/truffleruby/core/string/TStringConstants.java @@ -43,6 +43,10 @@ public class TStringConstants { } } + + public static final TruffleString __FILE__ = ascii("__FILE__"); + public static final TruffleString __LINE__ = ascii("__LINE__"); + public static final TruffleString __ENCODING__ = ascii("__ENCODING__"); public static final TruffleString AMPERSAND = ascii("&"); public static final TruffleString AMPERSAND_AMPERSAND = ascii("&&"); public static final TruffleString AMPERSAND_DOT = ascii("&."); @@ -93,6 +97,7 @@ public class TStringConstants { public static final TruffleString RBRACKET = ascii("]"); public static final TruffleString RCURLY = ascii("}"); public static final TruffleString RPAREN = ascii(")"); + public static final TruffleString SELF = ascii("self"); public static final TruffleString SEMICOLON = ascii(";"); public static final TruffleString SLASH = ascii("/"); public static final TruffleString STAR = ascii("*"); diff --git a/src/main/java/org/truffleruby/language/control/ExecuteAndReturnTrueNode.java b/src/main/java/org/truffleruby/language/control/ExecuteAndReturnTrueNode.java new file mode 100644 index 000000000000..2f94e6880830 --- /dev/null +++ b/src/main/java/org/truffleruby/language/control/ExecuteAndReturnTrueNode.java @@ -0,0 +1,35 @@ +/* + * Copyright (c) 2022, 2023 Oracle and/or its affiliates. All rights reserved. This + * code is released under a tri EPL/GPL/LGPL license. You can use it, + * redistribute it and/or modify it under the terms of the: + * + * Eclipse Public License version 2.0, or + * GNU General Public License version 2, or + * GNU Lesser General Public License version 2.1. + */ +package org.truffleruby.language.control; + +import org.truffleruby.language.RubyContextSourceNode; +import org.truffleruby.language.RubyNode; + +import com.oracle.truffle.api.frame.VirtualFrame; + +public final class ExecuteAndReturnTrueNode extends RubyContextSourceNode { + + @Child RubyNode child; + + public ExecuteAndReturnTrueNode(RubyNode child) { + this.child = child; + } + + @Override + public Object execute(VirtualFrame frame) { + child.doExecuteVoid(frame); + return true; + } + + @Override + public RubyNode cloneUninitialized() { + return new ExecuteAndReturnTrueNode(child.cloneUninitialized()).copyFlags(this); + } +} diff --git a/src/main/java/org/truffleruby/language/control/NoMatchingPatternNode.java b/src/main/java/org/truffleruby/language/control/NoMatchingPatternNode.java new file mode 100644 index 000000000000..7f90024baed4 --- /dev/null +++ b/src/main/java/org/truffleruby/language/control/NoMatchingPatternNode.java @@ -0,0 +1,36 @@ +/* + * Copyright (c) 2022, 2023 Oracle and/or its affiliates. All rights reserved. This + * code is released under a tri EPL/GPL/LGPL license. You can use it, + * redistribute it and/or modify it under the terms of the: + * + * Eclipse Public License version 2.0, or + * GNU General Public License version 2, or + * GNU Lesser General Public License version 2.1. + */ +package org.truffleruby.language.control; + +import com.oracle.truffle.api.dsl.Cached; +import com.oracle.truffle.api.dsl.NodeChild; +import com.oracle.truffle.api.dsl.Specialization; +import org.truffleruby.language.RubyContextSourceNode; + +import org.truffleruby.language.RubyNode; +import org.truffleruby.language.dispatch.DispatchNode; + +@NodeChild(value = "expressionNode", type = RubyNode.class) +public abstract class NoMatchingPatternNode extends RubyContextSourceNode { + + protected abstract RubyNode getExpressionNode(); + + @Specialization + protected Object noMatchingPattern(Object expression, + @Cached DispatchNode inspectNode) { + Object inspected = inspectNode.call(coreLibrary().truffleTypeModule, "rb_inspect", expression); + throw new RaiseException(getContext(), coreExceptions().noMatchingPatternError(inspected, this)); + } + + @Override + public RubyNode cloneUninitialized() { + return NoMatchingPatternNodeGen.create(getExpressionNode().cloneUninitialized()).copyFlags(this); + } +} diff --git a/src/main/java/org/truffleruby/language/dispatch/RubyCallNodeParameters.java b/src/main/java/org/truffleruby/language/dispatch/RubyCallNodeParameters.java index 26e9aeeb91e1..4da112df483e 100644 --- a/src/main/java/org/truffleruby/language/dispatch/RubyCallNodeParameters.java +++ b/src/main/java/org/truffleruby/language/dispatch/RubyCallNodeParameters.java @@ -31,9 +31,8 @@ public RubyCallNodeParameters( RubyNode block, ArgumentsDescriptor descriptor, RubyNode[] arguments, - boolean isSplatted, boolean ignoreVisibility) { - this(receiver, methodName, block, descriptor, arguments, isSplatted, ignoreVisibility, false, false, false); + this(receiver, methodName, block, descriptor, arguments, false, ignoreVisibility, false, false, false); } public RubyCallNodeParameters( diff --git a/src/main/java/org/truffleruby/language/locals/WriteLocalNode.java b/src/main/java/org/truffleruby/language/locals/WriteLocalNode.java index 41c89fda14a6..d6937a5a8eaf 100644 --- a/src/main/java/org/truffleruby/language/locals/WriteLocalNode.java +++ b/src/main/java/org/truffleruby/language/locals/WriteLocalNode.java @@ -39,6 +39,10 @@ public Object isDefined(VirtualFrame frame, RubyLanguage language, RubyContext c return FrozenStrings.ASSIGNMENT; } + public void setValueNode(RubyNode valueNode) { + this.valueNode = valueNode; + } + @Override public boolean hasTag(Class tag) { return tag == WriteVariableTag.class || super.hasTag(tag); @@ -49,5 +53,4 @@ public Object getNodeObject() { String name = getVariableName(); return new SingleMemberDescriptor(WriteVariableTag.NAME, name); } - } diff --git a/src/main/java/org/truffleruby/parser/BaseTranslator.java b/src/main/java/org/truffleruby/parser/BaseTranslator.java new file mode 100644 index 000000000000..47101d1793cc --- /dev/null +++ b/src/main/java/org/truffleruby/parser/BaseTranslator.java @@ -0,0 +1,55 @@ +/* + * Copyright (c) 2013, 2021 Oracle and/or its affiliates. All rights reserved. This + * code is released under a tri EPL/GPL/LGPL license. You can use it, + * redistribute it and/or modify it under the terms of the: + * + * Eclipse Public License version 2.0, or + * GNU General Public License version 2, or + * GNU Lesser General Public License version 2.1. + */ +package org.truffleruby.parser; + +import com.oracle.truffle.api.TruffleSafepoint; +import com.oracle.truffle.api.nodes.Node; +import com.oracle.truffle.api.source.Source; +import org.truffleruby.RubyLanguage; +import org.truffleruby.core.DummyNode; +import org.truffleruby.language.RubyNode; +import org.truffleruby.language.SourceIndexLength; +import org.truffleruby.parser.ast.ParseNode; + +public abstract class BaseTranslator extends Translator { + + protected final TranslatorEnvironment environment; + + public BaseTranslator( + RubyLanguage language, + Source source, + ParserContext parserContext, + Node currentNode, + TranslatorEnvironment environment) { + super(language, source, parserContext, currentNode); + this.environment = environment; + } + + protected RubyNode addNewlineIfNeeded(ParseNode jrubyNode, RubyNode node) { + if (jrubyNode.isNewline()) { + TruffleSafepoint.poll(DummyNode.INSTANCE); + + final SourceIndexLength current = node.getEncapsulatingSourceIndexLength(); + + if (current == null) { + return node; + } + + if (environment.getParseEnvironment().isCoverageEnabled()) { + node.unsafeSetIsCoverageLine(); + language.coverageManager.setLineHasCode(source, current.toSourceSection(source).getStartLine()); + } + node.unsafeSetIsNewLine(); + } + + return node; + } + +} diff --git a/src/main/java/org/truffleruby/parser/BodyTranslator.java b/src/main/java/org/truffleruby/parser/BodyTranslator.java index 3f7467a55632..15884a881ea5 100644 --- a/src/main/java/org/truffleruby/parser/BodyTranslator.java +++ b/src/main/java/org/truffleruby/parser/BodyTranslator.java @@ -9,18 +9,9 @@ */ package org.truffleruby.parser; -import java.math.BigInteger; -import java.nio.charset.StandardCharsets; -import java.util.ArrayDeque; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Deque; -import java.util.Iterator; -import java.util.List; - -import com.oracle.truffle.api.TruffleSafepoint; import com.oracle.truffle.api.strings.InternalByteArray; import com.oracle.truffle.api.strings.TruffleString; + import org.jcodings.Encoding; import org.joni.NameEntry; import org.joni.Regex; @@ -29,7 +20,6 @@ import org.truffleruby.RubyLanguage; import org.truffleruby.builtins.PrimitiveNodeConstructor; import org.truffleruby.core.CoreLibrary; -import org.truffleruby.core.DummyNode; import org.truffleruby.core.IsNilNode; import org.truffleruby.core.array.ArrayAppendOneNodeGen; import org.truffleruby.core.array.ArrayConcatNode; @@ -90,6 +80,7 @@ import org.truffleruby.language.control.InvalidReturnNode; import org.truffleruby.language.control.LocalReturnNode; import org.truffleruby.language.control.NextNode; +import org.truffleruby.language.control.NoMatchingPatternNodeGen; import org.truffleruby.language.control.NotNode; import org.truffleruby.language.control.OnceNode; import org.truffleruby.language.control.OrLazyValueDefinedNode; @@ -102,7 +93,6 @@ import org.truffleruby.language.control.WhileNode; import org.truffleruby.language.defined.DefinedNode; import org.truffleruby.language.defined.DefinedWrapperNode; -import org.truffleruby.language.dispatch.RubyCallNode; import org.truffleruby.language.dispatch.RubyCallNodeParameters; import org.truffleruby.language.exceptions.EnsureNode; import org.truffleruby.language.exceptions.RescueStandardErrorNode; @@ -224,7 +214,6 @@ import org.truffleruby.parser.ast.NextParseNode; import org.truffleruby.parser.ast.NilImplicitParseNode; import org.truffleruby.parser.ast.NilParseNode; -import org.truffleruby.parser.ast.NodeType; import org.truffleruby.parser.ast.NthRefParseNode; import org.truffleruby.parser.ast.OpAsgnAndParseNode; import org.truffleruby.parser.ast.OpAsgnConstDeclParseNode; @@ -272,8 +261,17 @@ import com.oracle.truffle.api.source.Source; import com.oracle.truffle.api.source.SourceSection; +import java.math.BigInteger; +import java.nio.charset.StandardCharsets; +import java.util.ArrayDeque; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Deque; +import java.util.Iterator; +import java.util.List; + /** A JRuby parser node visitor which translates JRuby AST nodes into truffle Nodes. */ -public class BodyTranslator extends Translator { +public class BodyTranslator extends BaseTranslator { public static final ToSNode[] EMPTY_TO_S_NODE_ARRAY = new ToSNode[0]; public static final RescueNode[] EMPTY_RESCUE_NODE_ARRAY = new RescueNode[0]; @@ -295,16 +293,12 @@ public BodyTranslator( ParserContext parserContext, Node currentNode, RubyDeferredWarnings rubyWarnings) { - super(language, source, parserContext, currentNode); + super(language, source, parserContext, currentNode, environment); this.parent = parent; this.environment = environment; this.rubyWarnings = rubyWarnings; } - private static RubyNode[] createArray(int size) { - return size == 0 ? RubyNode.EMPTY_ARRAY : new RubyNode[size]; - } - private RubySymbol translateNameNodeToSymbol(ParseNode node) { if (node instanceof LiteralParseNode) { return language.getSymbol(((LiteralParseNode) node).getName()); @@ -782,16 +776,7 @@ public RubyNode visitCaseNode(CaseParseNode node) { method = "when_splat"; arguments = new RubyNode[]{ rubyExpression, NodeUtil.cloneNode(readTemp) }; } - final RubyCallNodeParameters callParameters = new RubyCallNodeParameters( - receiver, - method, - null, - EmptyArgumentsDescriptor.INSTANCE, - arguments, - false, - true); - final RubyNode conditionNode = language.coreMethodAssumptions - .createCallNode(callParameters); + final RubyNode conditionNode = createCallNode(receiver, method, arguments); // Create the if node final RubyNode thenNode = translateNodeOrNil(sourceSection, when.getBodyNode()); @@ -830,6 +815,8 @@ public RubyNode visitCaseNode(CaseParseNode node) { @Override public RubyNode visitCaseInNode(CaseInParseNode node) { + final SourceIndexLength sourceSection = node.getPosition(); + if (!RubyLanguage.getCurrentContext().getOptions().PATTERN_MATCHING) { final RubyContext context = RubyLanguage.getCurrentContext(); throw new RaiseException( @@ -837,24 +824,27 @@ public RubyNode visitCaseInNode(CaseInParseNode node) { context.getCoreExceptions().syntaxError( "syntax error, unexpected keyword_in", currentNode, - node.getPosition().toSourceSection(source))); + sourceSection.toSourceSection(source))); } - final SourceIndexLength sourceSection = node.getPosition(); - - RubyNode elseNode = translateNodeOrNil(sourceSection, node.getElseNode()); - - final RubyNode ret; + PatternMatchingTranslator translator = new PatternMatchingTranslator(language, source, parserContext, + currentNode, environment, this); // Evaluate the case expression and store it in a local - - final int tempSlot = environment.declareLocalTemp("case"); + final int tempSlot = environment.declareLocalTemp("case in value"); final ReadLocalNode readTemp = environment.readNode(tempSlot, sourceSection); final RubyNode assignTemp = readTemp.makeWriteNode(node.getCaseNode().accept(this)); /* Build an if expression from the ins and else. Work backwards because the first if contains all the others in * its else clause. */ + RubyNode elseNode; + if (node.getElseNode() == null) { + elseNode = NoMatchingPatternNodeGen.create(readTemp); + } else { + elseNode = node.getElseNode().accept(this); + } + for (int n = node.getCases().size() - 1; n >= 0; n--) { final InParseNode in = (InParseNode) node.getCases().get(n); @@ -863,8 +853,7 @@ public RubyNode visitCaseInNode(CaseInParseNode node) { // us we-using the 'when' parser for 'in' temporarily. final ParseNode patternNode = in.getExpressionNodes(); - final RubyNode conditionNode = caseInPatternMatch(patternNode, node.getCaseNode(), readTemp, sourceSection); - + final RubyNode conditionNode = translator.translatePatternNode(patternNode, readTemp); // Create the if node final RubyNode thenNode = translateNodeOrNil(sourceSection, in.getBodyNode()); final IfElseNode ifNode = new IfElseNode(conditionNode, thenNode, elseNode); @@ -876,123 +865,9 @@ public RubyNode visitCaseInNode(CaseInParseNode node) { final RubyNode ifNode = elseNode; // A top-level block assigns the temp then runs the if - ret = sequence(sourceSection, Arrays.asList(assignTemp, ifNode)); - - return addNewlineIfNeeded(node, ret); - } - - private RubyNode caseInPatternMatch(ParseNode patternNode, ParseNode expressionNode, RubyNode expressionValue, - SourceIndexLength sourceSection) { - final RubyCallNodeParameters deconstructCallParameters; - final RubyCallNodeParameters matcherCallParameters; - final RubyNode receiver; - final RubyNode deconstructed; - - switch (patternNode.getNodeType()) { - case ARRAYNODE: - // Pattern-match element-wise recursively if possible. - final int size = ((ArrayParseNode) patternNode).size(); - if (expressionNode.getNodeType() == NodeType.ARRAYNODE && - ((ArrayParseNode) expressionNode).size() == size) { - final ParseNode[] patternElements = ((ArrayParseNode) patternNode).children(); - final ParseNode[] expressionElements = ((ArrayParseNode) expressionNode).children(); - - final RubyNode[] matches = new RubyNode[size]; - - // For each element of the case expression, evaluate and assign it, then run the pattern-matching - // on the element - for (int n = 0; n < size; n++) { - final int tempSlot = environment.declareLocalTemp("caseElem" + n); - final ReadLocalNode readTemp = environment.readNode(tempSlot, sourceSection); - final RubyNode assignTemp = readTemp.makeWriteNode(expressionElements[n].accept(this)); - matches[n] = sequence(sourceSection, Arrays.asList( - assignTemp, - caseInPatternMatch( - patternElements[n], - expressionElements[n], - readTemp, - sourceSection))); - } - - // Incorporate the element-wise pattern-matching into the AST, with the longer right leg since - // AndNode is visited left to right - RubyNode match = matches[size - 1]; - for (int n = size - 2; n >= 0; n--) { - match = new AndNode(matches[n], match); - } - return match; - } + final RubyNode ret = sequence(sourceSection, Arrays.asList(assignTemp, ifNode)); - deconstructCallParameters = new RubyCallNodeParameters( - expressionValue, - "deconstruct", - null, - EmptyArgumentsDescriptor.INSTANCE, - RubyNode.EMPTY_ARRAY, - false, - true); - deconstructed = language.coreMethodAssumptions - .createCallNode(deconstructCallParameters); - - receiver = new TruffleInternalModuleLiteralNode(); - receiver.unsafeSetSourceSection(sourceSection); - - matcherCallParameters = new RubyCallNodeParameters( - receiver, - "array_pattern_matches?", - null, - EmptyArgumentsDescriptor.INSTANCE, - new RubyNode[]{ patternNode.accept(this), NodeUtil.cloneNode(deconstructed) }, - false, - true); - return language.coreMethodAssumptions - .createCallNode(matcherCallParameters); - case HASHNODE: - deconstructCallParameters = new RubyCallNodeParameters( - expressionValue, - "deconstruct_keys", - null, - EmptyArgumentsDescriptor.INSTANCE, - new RubyNode[]{ new NilLiteralNode(true) }, - false, - true); - deconstructed = language.coreMethodAssumptions - .createCallNode(deconstructCallParameters); - - receiver = new TruffleInternalModuleLiteralNode(); - receiver.unsafeSetSourceSection(sourceSection); - - matcherCallParameters = new RubyCallNodeParameters( - receiver, - "hash_pattern_matches?", - null, - EmptyArgumentsDescriptor.INSTANCE, - new RubyNode[]{ patternNode.accept(this), NodeUtil.cloneNode(deconstructed) }, - false, - true); - return language.coreMethodAssumptions - .createCallNode(matcherCallParameters); - case LOCALVARNODE: - // Assigns the value of an existing variable pattern as the value of the expression. - // May need to add a case with same/similar logic for new variables. - final RubyNode assignmentNode = new LocalAsgnParseNode( - patternNode.getPosition(), - ((LocalVarParseNode) patternNode).getName(), - ((LocalVarParseNode) patternNode).getDepth(), - expressionNode).accept(this); - return new OrNode(assignmentNode, new BooleanLiteralNode(true)); // TODO refactor to remove "|| true" - default: - matcherCallParameters = new RubyCallNodeParameters( - patternNode.accept(this), - "===", - null, - EmptyArgumentsDescriptor.INSTANCE, - new RubyNode[]{ NodeUtil.cloneNode(expressionValue) }, - false, - true); - return language.coreMethodAssumptions - .createCallNode(matcherCallParameters); - } + return addNewlineIfNeeded(node, ret); } private RubyNode openModule(SourceIndexLength sourceSection, RubyNode defineOrGetNode, String moduleName, @@ -2364,15 +2239,7 @@ public RubyNode visitOpAsgnConstDeclNode(OpAsgnConstDeclParseNode node) { default: { final SourceIndexLength sourceSection = node.getPosition(); - final RubyCallNodeParameters callParameters = new RubyCallNodeParameters( - lhs, - node.getOperator(), - null, - EmptyArgumentsDescriptor.INSTANCE, - new RubyNode[]{ rhs }, - false, - true); - final RubyNode opNode = language.coreMethodAssumptions.createCallNode(callParameters); + final RubyNode opNode = createCallNode(lhs, node.getOperator(), rhs); final RubyNode ret = lhs.makeWriteNode(opNode); ret.unsafeSetSourceSection(sourceSection); return addNewlineIfNeeded(node, ret); @@ -2704,15 +2571,8 @@ private RubyNode translateRationalComplex(SourceIndexLength sourceSection, Strin final RubyNode moduleNode = new ObjectClassLiteralNode(); ReadConstantNode receiver = new ReadConstantNode(moduleNode, name); RubyNode[] arguments = new RubyNode[]{ a, b }; - RubyCallNodeParameters parameters = new RubyCallNodeParameters( - receiver, - "convert", - null, - EmptyArgumentsDescriptor.INSTANCE, - arguments, - false, - true); - return withSourceSection(sourceSection, new RubyCallNode(parameters)); + var callNode = createCallNode(receiver, "convert", arguments); + return withSourceSection(sourceSection, callNode); } @Override @@ -3169,26 +3029,6 @@ private void copyNewline(ParseNode from, ParseNode to) { } } - private RubyNode addNewlineIfNeeded(ParseNode jrubyNode, RubyNode node) { - if (jrubyNode.isNewline()) { - TruffleSafepoint.poll(DummyNode.INSTANCE); - - final SourceIndexLength current = node.getEncapsulatingSourceIndexLength(); - - if (current == null) { - return node; - } - - if (environment.getParseEnvironment().isCoverageEnabled()) { - node.unsafeSetIsCoverageLine(); - language.coverageManager.setLineHasCode(source, current.toSourceSection(source).getStartLine()); - } - node.unsafeSetIsNewLine(); - } - - return node; - } - private static ArgumentsDescriptor getKeywordArgumentsDescriptor(RubyLanguage language, ParseNode argsNode) { // Find the keyword argument hash parse node diff --git a/src/main/java/org/truffleruby/parser/PatternMatchingTranslator.java b/src/main/java/org/truffleruby/parser/PatternMatchingTranslator.java new file mode 100644 index 000000000000..53de80c8ba8a --- /dev/null +++ b/src/main/java/org/truffleruby/parser/PatternMatchingTranslator.java @@ -0,0 +1,315 @@ +/* + * Copyright (c) 2013, 2021 Oracle and/or its affiliates. All rights reserved. This + * code is released under a tri EPL/GPL/LGPL license. You can use it, + * redistribute it and/or modify it under the terms of the: + * + * Eclipse Public License version 2.0, or + * GNU General Public License version 2, or + * GNU Lesser General Public License version 2.1. + */ +package org.truffleruby.parser; + +import org.truffleruby.RubyContext; +import org.truffleruby.RubyLanguage; +import org.truffleruby.core.array.ArrayIndexNodes; +import org.truffleruby.core.array.ArrayLiteralNode; +import org.truffleruby.core.array.ArrayPatternLengthCheckNode; +import org.truffleruby.core.array.ArraySliceNodeGen; +import org.truffleruby.language.RubyNode; +import org.truffleruby.language.SourceIndexLength; +import org.truffleruby.language.control.AndNode; +import org.truffleruby.language.control.ExecuteAndReturnTrueNode; +import org.truffleruby.language.control.NotNode; +import org.truffleruby.language.control.RaiseException; +import org.truffleruby.language.literal.NilLiteralNode; +import org.truffleruby.language.literal.TruffleInternalModuleLiteralNode; +import org.truffleruby.language.locals.ReadLocalNode; +import org.truffleruby.language.locals.WriteLocalNode; +import org.truffleruby.parser.ast.ArrayParseNode; +import org.truffleruby.parser.ast.ArrayPatternParseNode; +import org.truffleruby.parser.ast.CallParseNode; +import org.truffleruby.parser.ast.ConstParseNode; +import org.truffleruby.parser.ast.DAsgnParseNode; +import org.truffleruby.parser.ast.DStrParseNode; +import org.truffleruby.parser.ast.DotParseNode; +import org.truffleruby.parser.ast.FalseParseNode; +import org.truffleruby.parser.ast.FindPatternParseNode; +import org.truffleruby.parser.ast.FixnumParseNode; +import org.truffleruby.parser.ast.HashPatternParseNode; +import org.truffleruby.parser.ast.IfParseNode; +import org.truffleruby.parser.ast.LambdaParseNode; +import org.truffleruby.parser.ast.LocalAsgnParseNode; +import org.truffleruby.parser.ast.NilParseNode; +import org.truffleruby.parser.ast.ParseNode; + +import com.oracle.truffle.api.nodes.Node; +import com.oracle.truffle.api.nodes.NodeUtil; +import com.oracle.truffle.api.source.Source; +import org.truffleruby.parser.ast.RegexpParseNode; +import org.truffleruby.parser.ast.StarParseNode; +import org.truffleruby.parser.ast.StrParseNode; +import org.truffleruby.parser.ast.TrueParseNode; + +import java.util.Arrays; + +public class PatternMatchingTranslator extends BaseTranslator { + + final TranslatorEnvironment environment; + final BodyTranslator bodyTranslator; + + RubyNode currentValueToMatch; + + public PatternMatchingTranslator( + RubyLanguage language, + Source source, + ParserContext parserContext, + Node currentNode, + TranslatorEnvironment environment, + BodyTranslator bodyTranslator) { + super(language, source, parserContext, currentNode, environment); + this.environment = environment; + this.bodyTranslator = bodyTranslator; + } + + public RubyNode translatePatternNode(ParseNode patternNode, RubyNode expressionValue) { + currentValueToMatch = expressionValue; + + // TODO move the other cases to the visitor pattern + switch (patternNode.getNodeType()) { + case ARRAYPATTERNNODE: + return this.visitArrayPatternNode((ArrayPatternParseNode) patternNode); + case HASHPATTERNNODE: // both of these throw the same exception, hence this is skipped. + case FINDPATTERNNODE: + final RubyContext context = RubyLanguage.getCurrentContext(); + throw new RaiseException( + context, + context.getCoreExceptions().syntaxError( + "not yet handled in pattern matching: " + patternNode + " " + patternNode.getPosition(), + currentNode, + patternNode.getPosition().toSourceSection(source))); + case IFNODE: // handles both if and unless + var ifNode = (IfParseNode) patternNode; + RubyNode pattern; + RubyNode condition = ifNode.getCondition().accept(bodyTranslator); + if (ifNode.getThenBody() != null) { + pattern = translatePatternNode(ifNode.getThenBody(), expressionValue); + } else { + pattern = translatePatternNode(ifNode.getElseBody(), expressionValue); + condition = new NotNode(condition); + } + + return new AndNode(pattern, condition); + default: + return createCallNode(patternNode.accept(this), "===", NodeUtil.cloneNode(expressionValue)); + } + } + + @Override + protected RubyNode defaultVisit(ParseNode node) { + final RubyContext context = RubyLanguage.getCurrentContext(); + throw new RaiseException( + context, + context.getCoreExceptions().syntaxError( + "not yet handled in pattern matching: " + node.toString() + " " + node.getPosition(), + currentNode, + node.getPosition().toSourceSection(source))); + } + + @Override + public RubyNode visitArrayPatternNode(ArrayPatternParseNode arrayPatternParseNode) { + final SourceIndexLength sourceSection = arrayPatternParseNode.getPosition(); + + var preNodes = arrayPatternParseNode.getPreArgs(); + var postNodes = arrayPatternParseNode.getPostArgs(); + var restNode = arrayPatternParseNode.getRestArg(); + + var deconstructed = createCallNode(new TruffleInternalModuleLiteralNode(), "deconstruct_checked", + currentValueToMatch); + + final int deconstructedSlot = environment.declareLocalTemp("p_decon_array"); + final ReadLocalNode readTemp = environment.readNode(deconstructedSlot, sourceSection); + final RubyNode assignTemp = readTemp.makeWriteNode(deconstructed); + currentValueToMatch = readTemp; + + int preSize = arrayPatternParseNode.preArgsNum(); + + RubyNode condition = new ArrayPatternLengthCheckNode(arrayPatternParseNode.minimumArgsNum(), + currentValueToMatch, arrayPatternParseNode.hasRestArg()); + + // Constant === pattern.deconstruct + if (arrayPatternParseNode.hasConstant()) { + ConstParseNode constant = (ConstParseNode) arrayPatternParseNode.getConstant(); + RubyNode constVal = constant.accept(this); + var isInstance = createCallNode(constVal, "===", currentValueToMatch); + condition = new AndNode(isInstance, condition); + } + + for (int i = 0; i < preSize; i++) { + var preNode = preNodes.get(i); + RubyNode translatedPatternElement; + RubyNode prev = currentValueToMatch; + var exprElement = ArrayIndexNodes.ReadConstantIndexNode.create(currentValueToMatch, i); + currentValueToMatch = exprElement; + try { + translatedPatternElement = preNode.accept(this); + } finally { + currentValueToMatch = prev; + } + + var callNode = createCallNode(translatedPatternElement, "===", NodeUtil.cloneNode(exprElement)); + condition = new AndNode(condition, callNode); + } + + if (restNode != null) { + if (!(restNode instanceof StarParseNode)) { + RubyNode prev = currentValueToMatch; + RubyNode restAccept; + int postSize; + if (postNodes == null) { // null does not have length, so assign 0 manually. + postSize = 0; + } else { + postSize = postNodes.size(); + } + var exprSlice = ArraySliceNodeGen.create(preSize, -postSize, currentValueToMatch); + currentValueToMatch = exprSlice; + try { + restAccept = restNode.accept(this); + } finally { + currentValueToMatch = prev; + } + var seq = new ExecuteAndReturnTrueNode(restAccept); + condition = new AndNode(condition, seq); + } + } + + if (postNodes != null) { + for (int i = 0; i < postNodes.size(); i++) { + ParseNode loopPostNode = postNodes.get(i); + RubyNode translatedPatternElement; + RubyNode prev = currentValueToMatch; + var exprElement = ArrayIndexNodes.ReadConstantIndexNode.create(currentValueToMatch, + -postNodes.size() + i); + currentValueToMatch = exprElement; + try { + translatedPatternElement = loopPostNode.accept(this); + } finally { + currentValueToMatch = prev; + } + + var callNode = createCallNode( + translatedPatternElement, + "===", + NodeUtil.cloneNode(exprElement)); + + condition = new AndNode(condition, callNode); + } + } + + return sequence(sourceSection, Arrays.asList(assignTemp, condition)); + } + + public RubyNode visitFindPatternNode(FindPatternParseNode findPatternParseNode) { + return findPatternParseNode.accept(this); + } + + @Override + public RubyNode visitHashPatternNode(HashPatternParseNode node) { + var deconstructed = createCallNode(currentValueToMatch, "deconstruct_keys", new NilLiteralNode(true)); + + return createCallNode( + new TruffleInternalModuleLiteralNode(), + "hash_pattern_matches?", + node.accept(this), + NodeUtil.cloneNode(deconstructed)); + } + + @Override + public RubyNode visitArrayNode(ArrayParseNode node) { + final ParseNode[] values = node.children(); + + final RubyNode[] translatedValues = createArray(values.length); + + for (int n = 0; n < values.length; n++) { + RubyNode prev = currentValueToMatch; + currentValueToMatch = ArrayIndexNodes.ReadConstantIndexNode.create(currentValueToMatch, n); + try { + translatedValues[n] = values[n].accept(this); + } finally { + currentValueToMatch = prev; + } + } + + final RubyNode ret = ArrayLiteralNode.create(language, translatedValues); + ret.unsafeSetSourceSection(node.getPosition()); + return addNewlineIfNeeded(node, ret); + } + + @Override + public RubyNode visitLocalAsgnNode(LocalAsgnParseNode node) { + WriteLocalNode writeLocalNode = bodyTranslator.visitLocalAsgnNode(node); + writeLocalNode.setValueNode(currentValueToMatch); + return writeLocalNode; + } + + @Override + public RubyNode visitDAsgnNode(DAsgnParseNode node) { + WriteLocalNode writeLocalNode = bodyTranslator.visitDAsgnNode(node); + writeLocalNode.setValueNode(currentValueToMatch); + return writeLocalNode; + } + + @Override + public RubyNode visitFixnumNode(FixnumParseNode node) { + return bodyTranslator.visitFixnumNode(node); + } + + @Override + public RubyNode visitTrueNode(TrueParseNode node) { + return bodyTranslator.visitTrueNode(node); + } + + @Override + public RubyNode visitFalseNode(FalseParseNode node) { + return bodyTranslator.visitFalseNode(node); + } + + @Override + public RubyNode visitStrNode(StrParseNode node) { + return bodyTranslator.visitStrNode(node); + } + + @Override + public RubyNode visitDotNode(DotParseNode node) { + return bodyTranslator.visitDotNode(node); + } + + @Override + public RubyNode visitNilNode(NilParseNode node) { + return bodyTranslator.visitNilNode(node); + } + + @Override + public RubyNode visitConstNode(ConstParseNode node) { + return bodyTranslator.visitConstNode(node); + } + + @Override + public RubyNode visitRegexpNode(RegexpParseNode node) { + return bodyTranslator.visitRegexpNode(node); + } + + @Override + public RubyNode visitLambdaNode(LambdaParseNode node) { + return bodyTranslator.visitLambdaNode(node); + } + + @Override + public RubyNode visitDStrNode(DStrParseNode node) { + return bodyTranslator.visitDStrNode(node); + } + + @Override + public RubyNode visitCallNode(CallParseNode node) { + return bodyTranslator.visitCallNode(node); + } +} diff --git a/src/main/java/org/truffleruby/parser/Translator.java b/src/main/java/org/truffleruby/parser/Translator.java index f1f128bfe3b0..7909a6f52257 100644 --- a/src/main/java/org/truffleruby/parser/Translator.java +++ b/src/main/java/org/truffleruby/parser/Translator.java @@ -15,11 +15,14 @@ import org.truffleruby.RubyLanguage; import org.truffleruby.debug.ChaosNode; +import org.truffleruby.language.RubyContextSourceNode; import org.truffleruby.language.RubyNode; import org.truffleruby.language.SourceIndexLength; +import org.truffleruby.language.arguments.EmptyArgumentsDescriptor; import org.truffleruby.language.arguments.ProfileArgumentNodeGen; import org.truffleruby.language.arguments.ReadSelfNode; import org.truffleruby.language.control.SequenceNode; +import org.truffleruby.language.dispatch.RubyCallNodeParameters; import org.truffleruby.language.literal.NilLiteralNode; import org.truffleruby.language.locals.WriteLocalVariableNode; import org.truffleruby.language.objects.SelfNode; @@ -164,4 +167,20 @@ public static T withSourceSection(SourceIndexLength sourceS return node; } + protected static RubyNode[] createArray(int size) { + return size == 0 ? RubyNode.EMPTY_ARRAY : new RubyNode[size]; + } + + /** Uses ignoreVisibility=true */ + protected RubyContextSourceNode createCallNode(RubyNode receiver, String method, RubyNode... arguments) { + var parameters = new RubyCallNodeParameters( + receiver, + method, + null, + EmptyArgumentsDescriptor.INSTANCE, + arguments, + true); + return language.coreMethodAssumptions.createCallNode(parameters); + } + } diff --git a/src/main/java/org/truffleruby/parser/ast/ArrayPatternParseNode.java b/src/main/java/org/truffleruby/parser/ast/ArrayPatternParseNode.java new file mode 100644 index 000000000000..f6480ed5c7a8 --- /dev/null +++ b/src/main/java/org/truffleruby/parser/ast/ArrayPatternParseNode.java @@ -0,0 +1,130 @@ +/* + ***** BEGIN LICENSE BLOCK ***** + * Version: EPL 2.0/GPL 2.0/LGPL 2.1 + * + * The contents of this file are subject to the Eclipse Public + * License Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.eclipse.org/legal/epl-v20.html + * + * Software distributed under the License is distributed on an "AS + * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or + * implied. See the License for the specific language governing + * rights and limitations under the License. + * + * Copyright (C) 2001-2002 Jan Arne Petersen + * Copyright (C) 2001-2002 Benoit Cerrina + * Copyright (C) 2002-2004 Anders Bengtsson + * Copyright (C) 2004 Thomas E Enebo + * + * Alternatively, the contents of this file may be used under the terms of + * either of the GNU General Public License Version 2 or later (the "GPL"), + * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), + * in which case the provisions of the GPL or the LGPL are applicable instead + * of those above. If you wish to allow use of your version of this file only + * under the terms of either the GPL or the LGPL, and not to allow others to + * use your version of this file under the terms of the EPL, indicate your + * decision by deleting the provisions above and replace them with the notice + * and other provisions required by the GPL or the LGPL. If you do not delete + * the provisions above, a recipient may use your version of this file under + * the terms of any one of the EPL, the GPL or the LGPL. + ***** END LICENSE BLOCK *****/ +package org.truffleruby.parser.ast; + +import org.truffleruby.language.SourceIndexLength; +import org.truffleruby.parser.ast.visitor.NodeVisitor; + +import java.util.List; + +public class ArrayPatternParseNode extends ParseNode { + private ListParseNode preArgs; + private final ParseNode restArg; + private final ListParseNode postArgs; + + private ParseNode constant; + + public ArrayPatternParseNode( + SourceIndexLength position, + ListParseNode preArgs, + ParseNode restArg, + ListParseNode postArgs) { + super(position); + + this.preArgs = preArgs; + this.restArg = restArg; + this.postArgs = postArgs; + } + + @Override + public T accept(NodeVisitor visitor) { + return visitor.visitArrayPatternNode(this); + } + + @Override + public List childNodes() { + return createList(preArgs, restArg, postArgs, constant); + } + + @Override + public NodeType getNodeType() { + return NodeType.ARRAYPATTERNNODE; + } + + public void setConstant(ParseNode constant) { + this.constant = constant; + } + + public boolean hasConstant() { + return constant != null; + } + + public ParseNode getConstant() { + return constant; + } + + public ListParseNode getPreArgs() { + return preArgs; + } + + public ListParseNode getPostArgs() { + return postArgs; + } + + public void setPreArgs(ListParseNode preArgs) { + this.preArgs = preArgs; + } + + public ParseNode getRestArg() { + return restArg; + } + + public boolean hasRestArg() { + return restArg != null; + } + + public boolean isNamedRestArg() { + return !(restArg instanceof StarParseNode); + } + + public boolean usesRestNum() { + if (restArg == null) { + return false; + } + + boolean named = !(restArg instanceof StarParseNode); + + return named || !named && postArgsNum() > 0; + } + + public int preArgsNum() { + return preArgs == null ? 0 : preArgs.size(); + } + + public int postArgsNum() { + return postArgs == null ? 0 : postArgs.size(); + } + + public int minimumArgsNum() { + return preArgsNum() + postArgsNum(); + } +} diff --git a/src/main/java/org/truffleruby/parser/ast/FindPatternParseNode.java b/src/main/java/org/truffleruby/parser/ast/FindPatternParseNode.java new file mode 100644 index 000000000000..51dd2792ed6e --- /dev/null +++ b/src/main/java/org/truffleruby/parser/ast/FindPatternParseNode.java @@ -0,0 +1,95 @@ +/* + ***** BEGIN LICENSE BLOCK ***** + * Version: EPL 2.0/GPL 2.0/LGPL 2.1 + * + * The contents of this file are subject to the Eclipse Public + * License Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.eclipse.org/legal/epl-v20.html + * + * Software distributed under the License is distributed on an "AS + * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or + * implied. See the License for the specific language governing + * rights and limitations under the License. + * + * Copyright (C) 2001-2002 Jan Arne Petersen + * Copyright (C) 2001-2002 Benoit Cerrina + * Copyright (C) 2002-2004 Anders Bengtsson + * Copyright (C) 2004 Thomas E Enebo + * + * Alternatively, the contents of this file may be used under the terms of + * either of the GNU General Public License Version 2 or later (the "GPL"), + * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), + * in which case the provisions of the GPL or the LGPL are applicable instead + * of those above. If you wish to allow use of your version of this file only + * under the terms of either the GPL or the LGPL, and not to allow others to + * use your version of this file under the terms of the EPL, indicate your + * decision by deleting the provisions above and replace them with the notice + * and other provisions required by the GPL or the LGPL. If you do not delete + * the provisions above, a recipient may use your version of this file under + * the terms of any one of the EPL, the GPL or the LGPL. + ***** END LICENSE BLOCK *****/ +package org.truffleruby.parser.ast; + +import org.truffleruby.language.SourceIndexLength; +import org.truffleruby.parser.ast.visitor.NodeVisitor; + +import java.util.List; + +public class FindPatternParseNode extends ParseNode { + private final ParseNode preRestArg; + private final ListParseNode args; + private final ParseNode postRestArg; + private ParseNode constant; + + public FindPatternParseNode( + SourceIndexLength position, + ParseNode preRestArg, + ListParseNode args, + ParseNode postRestArg) { + super(position); + + this.preRestArg = preRestArg; + this.args = args; + this.postRestArg = postRestArg; + } + + @Override + public T accept(NodeVisitor visitor) { + return visitor.visitFindPatternNode(this); + } + + @Override + public List childNodes() { + return createList(preRestArg, args, postRestArg, constant); + } + + @Override + public NodeType getNodeType() { + return NodeType.FINDPATTERNNODE; + } + + public void setConstant(ParseNode constant) { + this.constant = constant; + } + + public boolean hasConstant() { + return constant != null; + } + + public ParseNode getConstant() { + return constant; + } + + public ListParseNode getArgs() { + return args; + } + + public ParseNode getPreRestArg() { + return preRestArg; + } + + public ParseNode getPostRestArg() { + return postRestArg; + } +} diff --git a/src/main/java/org/truffleruby/parser/ast/HashPatternParseNode.java b/src/main/java/org/truffleruby/parser/ast/HashPatternParseNode.java new file mode 100644 index 000000000000..aedaa6620c99 --- /dev/null +++ b/src/main/java/org/truffleruby/parser/ast/HashPatternParseNode.java @@ -0,0 +1,116 @@ +/* + ***** BEGIN LICENSE BLOCK ***** + * Version: EPL 2.0/GPL 2.0/LGPL 2.1 + * + * The contents of this file are subject to the Eclipse Public + * License Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.eclipse.org/legal/epl-v20.html + * + * Software distributed under the License is distributed on an "AS + * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or + * implied. See the License for the specific language governing + * rights and limitations under the License. + * + * Copyright (C) 2001-2002 Jan Arne Petersen + * Copyright (C) 2001-2002 Benoit Cerrina + * Copyright (C) 2002-2004 Anders Bengtsson + * Copyright (C) 2004 Thomas E Enebo + * + * Alternatively, the contents of this file may be used under the terms of + * either of the GNU General Public License Version 2 or later (the "GPL"), + * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), + * in which case the provisions of the GPL or the LGPL are applicable instead + * of those above. If you wish to allow use of your version of this file only + * under the terms of either the GPL or the LGPL, and not to allow others to + * use your version of this file under the terms of the EPL, indicate your + * decision by deleting the provisions above and replace them with the notice + * and other provisions required by the GPL or the LGPL. If you do not delete + * the provisions above, a recipient may use your version of this file under + * the terms of any one of the EPL, the GPL or the LGPL. + ***** END LICENSE BLOCK *****/ +package org.truffleruby.parser.ast; + +import org.truffleruby.language.SourceIndexLength; +import org.truffleruby.parser.ast.visitor.NodeVisitor; +import org.truffleruby.parser.parser.ParseNodeTuple; + +import java.util.ArrayList; +import java.util.List; + +public class HashPatternParseNode extends ParseNode { + private final ParseNode restArg; + private final HashParseNode keywordArgs; + + private ParseNode constant; + + public HashPatternParseNode(SourceIndexLength position, ParseNode restArg, HashParseNode keywordArgs) { + super(position); + + this.restArg = restArg; + this.keywordArgs = keywordArgs; + } + + @Override + public T accept(NodeVisitor visitor) { + return visitor.visitHashPatternNode(this); + } + + @Override + public List childNodes() { + return createList(restArg, keywordArgs, constant); + } + + @Override + public NodeType getNodeType() { + return NodeType.HASHPATTERNNODE; + } + + public ParseNode getConstant() { + return constant; + } + + public void setConstant(ParseNode constant) { + this.constant = constant; + } + + // MRI: args_num in compile.c + public int getArgumentSize() { + return keywordArgs == null ? 0 : keywordArgs.getPairs().size(); + } + + public ParseNode getRestArg() { + return restArg; + } + + public boolean hasRestArg() { + return restArg != null; + } + + public boolean isNamedRestArg() { + return !(restArg instanceof StarParseNode); + } + + public boolean hasKeywordArgs() { + return keywordArgs != null; + } + + public HashParseNode getKeywordArgs() { + return keywordArgs; + } + + public List getKeys() { + List pairs = keywordArgs.getPairs(); + List keys = new ArrayList<>(pairs.size()); + + for (ParseNodeTuple pair : pairs) { + keys.add(pair.getKey()); + } + + return keys; + } + + public boolean hashNamedKeywordRestArg() { + return hasRestArg() && !(restArg instanceof StarParseNode); + } +} diff --git a/src/main/java/org/truffleruby/parser/ast/InParseNode.java b/src/main/java/org/truffleruby/parser/ast/InParseNode.java index 9977d56dd785..8dbaae8df612 100644 --- a/src/main/java/org/truffleruby/parser/ast/InParseNode.java +++ b/src/main/java/org/truffleruby/parser/ast/InParseNode.java @@ -39,6 +39,7 @@ ***** END LICENSE BLOCK *****/ package org.truffleruby.parser.ast; +import com.oracle.truffle.api.CompilerDirectives; import org.truffleruby.language.SourceIndexLength; import org.truffleruby.parser.ast.visitor.NodeVisitor; @@ -57,7 +58,13 @@ public InParseNode( ParseNode nextCase) { super(position); - expressionNodes = ((ArrayParseNode) expressionNodes).get(0); + if (expressionNodes instanceof ArrayParseNode) { + var arrayParseNode = (ArrayParseNode) expressionNodes; + if (arrayParseNode.size() != 1) { + throw CompilerDirectives.shouldNotReachHere(); + } + expressionNodes = arrayParseNode.get(0); + } this.expressionNodes = expressionNodes; this.bodyNode = bodyNode; diff --git a/src/main/java/org/truffleruby/parser/ast/NilRestArgParseNode.java b/src/main/java/org/truffleruby/parser/ast/NilRestArgParseNode.java new file mode 100644 index 000000000000..ff66765208b6 --- /dev/null +++ b/src/main/java/org/truffleruby/parser/ast/NilRestArgParseNode.java @@ -0,0 +1,60 @@ +/* + ***** BEGIN LICENSE BLOCK ***** + * Version: EPL 2.0/GPL 2.0/LGPL 2.1 + * + * The contents of this file are subject to the Eclipse Public + * License Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.eclipse.org/legal/epl-v20.html + * + * Software distributed under the License is distributed on an "AS + * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or + * implied. See the License for the specific language governing + * rights and limitations under the License. + * + * Copyright (C) 2001-2002 Jan Arne Petersen + * Copyright (C) 2001-2002 Benoit Cerrina + * Copyright (C) 2002-2004 Anders Bengtsson + * Copyright (C) 2004 Thomas E Enebo + * + * Alternatively, the contents of this file may be used under the terms of + * either of the GNU General Public License Version 2 or later (the "GPL"), + * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), + * in which case the provisions of the GPL or the LGPL are applicable instead + * of those above. If you wish to allow use of your version of this file only + * under the terms of either the GPL or the LGPL, and not to allow others to + * use your version of this file under the terms of the EPL, indicate your + * decision by deleting the provisions above and replace them with the notice + * and other provisions required by the GPL or the LGPL. If you do not delete + * the provisions above, a recipient may use your version of this file under + * the terms of any one of the EPL, the GPL or the LGPL. + ***** END LICENSE BLOCK *****/ +package org.truffleruby.parser.ast; + +import org.truffleruby.language.SourceIndexLength; +import org.truffleruby.parser.ast.visitor.NodeVisitor; + +import java.util.List; + +import static org.truffleruby.parser.ast.NodeType.NILRESTARG; + +public class NilRestArgParseNode extends ParseNode { + public NilRestArgParseNode(SourceIndexLength position) { + super(position); + } + + @Override + public T accept(NodeVisitor visitor) { + return visitor.visitNilRestArgNode(this); + } + + @Override + public List childNodes() { + return EMPTY_LIST; + } + + @Override + public NodeType getNodeType() { + return NILRESTARG; + } +} diff --git a/src/main/java/org/truffleruby/parser/ast/NodeType.java b/src/main/java/org/truffleruby/parser/ast/NodeType.java index 6a736801bd7c..f7e13a5088aa 100644 --- a/src/main/java/org/truffleruby/parser/ast/NodeType.java +++ b/src/main/java/org/truffleruby/parser/ast/NodeType.java @@ -36,6 +36,7 @@ public enum NodeType { ARGSNODE, ARGUMENTNODE, ARRAYNODE, + ARRAYPATTERNNODE, BACKREFNODE, BEGINNODE, BIGNUMNODE, @@ -67,6 +68,7 @@ public enum NodeType { EVSTRNODE, FALSENODE, FCALLNODE, + FINDPATTERNNODE, FIXNUMNODE, FLIPNODE, FLOATNODE, @@ -74,6 +76,7 @@ public enum NodeType { GLOBALASGNNODE, GLOBALVARNODE, HASHNODE, + HASHPATTERNNODE, IFNODE, INSTASGNNODE, INSTVARNODE, @@ -87,6 +90,7 @@ public enum NodeType { MODULENODE, NEXTNODE, NILNODE, + NILRESTARG, NTHREFNODE, OPASGNANDNODE, OPASGNNODE, diff --git a/src/main/java/org/truffleruby/parser/ast/visitor/AbstractNodeVisitor.java b/src/main/java/org/truffleruby/parser/ast/visitor/AbstractNodeVisitor.java index 2e4ac9cc76f0..e3f8a04b98f4 100644 --- a/src/main/java/org/truffleruby/parser/ast/visitor/AbstractNodeVisitor.java +++ b/src/main/java/org/truffleruby/parser/ast/visitor/AbstractNodeVisitor.java @@ -33,6 +33,7 @@ import org.truffleruby.parser.ast.ArgsPushParseNode; import org.truffleruby.parser.ast.ArgumentParseNode; import org.truffleruby.parser.ast.ArrayParseNode; +import org.truffleruby.parser.ast.ArrayPatternParseNode; import org.truffleruby.parser.ast.AttrAssignParseNode; import org.truffleruby.parser.ast.BackRefParseNode; import org.truffleruby.parser.ast.BeginParseNode; @@ -68,6 +69,7 @@ import org.truffleruby.parser.ast.EvStrParseNode; import org.truffleruby.parser.ast.FCallParseNode; import org.truffleruby.parser.ast.FalseParseNode; +import org.truffleruby.parser.ast.FindPatternParseNode; import org.truffleruby.parser.ast.FixnumParseNode; import org.truffleruby.parser.ast.FlipParseNode; import org.truffleruby.parser.ast.FloatParseNode; @@ -75,6 +77,7 @@ import org.truffleruby.parser.ast.GlobalAsgnParseNode; import org.truffleruby.parser.ast.GlobalVarParseNode; import org.truffleruby.parser.ast.HashParseNode; +import org.truffleruby.parser.ast.HashPatternParseNode; import org.truffleruby.parser.ast.IfParseNode; import org.truffleruby.parser.ast.InParseNode; import org.truffleruby.parser.ast.InstAsgnParseNode; @@ -94,6 +97,7 @@ import org.truffleruby.parser.ast.MultipleAsgnParseNode; import org.truffleruby.parser.ast.NextParseNode; import org.truffleruby.parser.ast.NilParseNode; +import org.truffleruby.parser.ast.NilRestArgParseNode; import org.truffleruby.parser.ast.NoKeywordsArgParseNode; import org.truffleruby.parser.ast.NthRefParseNode; import org.truffleruby.parser.ast.OpAsgnAndParseNode; @@ -178,6 +182,11 @@ public T visitArrayNode(ArrayParseNode node) { return defaultVisit(node); } + @Override + public T visitArrayPatternNode(ArrayPatternParseNode node) { + return defaultVisit(node); + } + @Override public T visitAttrAssignNode(AttrAssignParseNode node) { return defaultVisit(node); @@ -349,6 +358,11 @@ public T visitFalseNode(FalseParseNode node) { return defaultVisit(node); } + @Override + public T visitFindPatternNode(FindPatternParseNode node) { + return defaultVisit(node); + } + @Override public T visitFixnumNode(FixnumParseNode node) { return defaultVisit(node); @@ -384,6 +398,11 @@ public T visitHashNode(HashParseNode node) { return defaultVisit(node); } + @Override + public T visitHashPatternNode(HashPatternParseNode node) { + return defaultVisit(node); + } + @Override public T visitInstAsgnNode(InstAsgnParseNode node) { return defaultVisit(node); @@ -694,4 +713,9 @@ public T visitOther(ParseNode node) { return defaultVisit(node); } + @Override + public T visitNilRestArgNode(NilRestArgParseNode node) { + return defaultVisit(node); + } + } diff --git a/src/main/java/org/truffleruby/parser/ast/visitor/NodeVisitor.java b/src/main/java/org/truffleruby/parser/ast/visitor/NodeVisitor.java index 94c0be8d67ed..205ed7f3ca3f 100644 --- a/src/main/java/org/truffleruby/parser/ast/visitor/NodeVisitor.java +++ b/src/main/java/org/truffleruby/parser/ast/visitor/NodeVisitor.java @@ -39,6 +39,7 @@ import org.truffleruby.parser.ast.ArgsPushParseNode; import org.truffleruby.parser.ast.ArgumentParseNode; import org.truffleruby.parser.ast.ArrayParseNode; +import org.truffleruby.parser.ast.ArrayPatternParseNode; import org.truffleruby.parser.ast.AttrAssignParseNode; import org.truffleruby.parser.ast.BackRefParseNode; import org.truffleruby.parser.ast.BeginParseNode; @@ -74,6 +75,7 @@ import org.truffleruby.parser.ast.EvStrParseNode; import org.truffleruby.parser.ast.FCallParseNode; import org.truffleruby.parser.ast.FalseParseNode; +import org.truffleruby.parser.ast.FindPatternParseNode; import org.truffleruby.parser.ast.FixnumParseNode; import org.truffleruby.parser.ast.FlipParseNode; import org.truffleruby.parser.ast.FloatParseNode; @@ -81,6 +83,7 @@ import org.truffleruby.parser.ast.GlobalAsgnParseNode; import org.truffleruby.parser.ast.GlobalVarParseNode; import org.truffleruby.parser.ast.HashParseNode; +import org.truffleruby.parser.ast.HashPatternParseNode; import org.truffleruby.parser.ast.IfParseNode; import org.truffleruby.parser.ast.InParseNode; import org.truffleruby.parser.ast.InstAsgnParseNode; @@ -100,6 +103,7 @@ import org.truffleruby.parser.ast.MultipleAsgnParseNode; import org.truffleruby.parser.ast.NextParseNode; import org.truffleruby.parser.ast.NilParseNode; +import org.truffleruby.parser.ast.NilRestArgParseNode; import org.truffleruby.parser.ast.NoKeywordsArgParseNode; import org.truffleruby.parser.ast.NthRefParseNode; import org.truffleruby.parser.ast.OpAsgnAndParseNode; @@ -164,6 +168,8 @@ public interface NodeVisitor { T visitArrayNode(ArrayParseNode iVisited); + T visitArrayPatternNode(ArrayPatternParseNode iVisited); + T visitAttrAssignNode(AttrAssignParseNode iVisited); T visitBackRefNode(BackRefParseNode iVisited); @@ -232,6 +238,8 @@ public interface NodeVisitor { T visitFalseNode(FalseParseNode iVisited); + T visitFindPatternNode(FindPatternParseNode iVisited); + T visitFixnumNode(FixnumParseNode iVisited); T visitFlipNode(FlipParseNode iVisited); @@ -246,6 +254,8 @@ public interface NodeVisitor { T visitHashNode(HashParseNode iVisited); + T visitHashPatternNode(HashPatternParseNode iVisited); + T visitInstAsgnNode(InstAsgnParseNode iVisited); T visitInstVarNode(InstVarParseNode iVisited); @@ -369,4 +379,6 @@ public interface NodeVisitor { T visitTruffleFragmentNode(TruffleFragmentParseNode iVisited); T visitOther(ParseNode iVisited); + + T visitNilRestArgNode(NilRestArgParseNode nilRestArgParseNode); } diff --git a/src/main/java/org/truffleruby/parser/lexer/RubyLexer.java b/src/main/java/org/truffleruby/parser/lexer/RubyLexer.java index 476b4770a23f..6d20a4529a3a 100644 --- a/src/main/java/org/truffleruby/parser/lexer/RubyLexer.java +++ b/src/main/java/org/truffleruby/parser/lexer/RubyLexer.java @@ -3738,4 +3738,8 @@ public String getLocation() { public String toString() { return super.toString() + " @ " + getLocation(); } + + public int getRubySourceLine() { + return ruby_sourceline; + } } diff --git a/src/main/java/org/truffleruby/parser/parser/ParserSupport.java b/src/main/java/org/truffleruby/parser/parser/ParserSupport.java index 532035b555e4..df44acd1bfa6 100644 --- a/src/main/java/org/truffleruby/parser/parser/ParserSupport.java +++ b/src/main/java/org/truffleruby/parser/parser/ParserSupport.java @@ -35,9 +35,20 @@ ***** END LICENSE BLOCK *****/ package org.truffleruby.parser.parser; +import static org.truffleruby.core.string.TStringConstants.FALSE; +import static org.truffleruby.core.string.TStringConstants.NIL; +import static org.truffleruby.core.string.TStringConstants.SELF; +import static org.truffleruby.core.string.TStringConstants.TRUE; +import static org.truffleruby.core.string.TStringConstants.__ENCODING__; +import static org.truffleruby.core.string.TStringConstants.__FILE__; +import static org.truffleruby.core.string.TStringConstants.__LINE__; +import static org.truffleruby.parser.parser.ParserSupport.IDType.Constant; + import java.math.BigInteger; import java.util.ArrayList; +import java.util.HashSet; import java.util.List; +import java.util.Set; import com.oracle.truffle.api.strings.TruffleString; import org.jcodings.Encoding; @@ -91,17 +102,21 @@ import org.truffleruby.parser.ast.DRegexpParseNode; import org.truffleruby.parser.ast.DStrParseNode; import org.truffleruby.parser.ast.DSymbolParseNode; +import org.truffleruby.parser.ast.DVarParseNode; import org.truffleruby.parser.ast.DefinedParseNode; import org.truffleruby.parser.ast.DotParseNode; +import org.truffleruby.parser.ast.EncodingParseNode; import org.truffleruby.parser.ast.EvStrParseNode; import org.truffleruby.parser.ast.FCallParseNode; import org.truffleruby.parser.ast.FalseParseNode; +import org.truffleruby.parser.ast.FileParseNode; import org.truffleruby.parser.ast.FixnumParseNode; import org.truffleruby.parser.ast.FlipParseNode; import org.truffleruby.parser.ast.FloatParseNode; import org.truffleruby.parser.ast.GlobalAsgnParseNode; import org.truffleruby.parser.ast.GlobalVarParseNode; import org.truffleruby.parser.ast.HashParseNode; +import org.truffleruby.parser.ast.HashPatternParseNode; import org.truffleruby.parser.ast.IArgumentNode; import org.truffleruby.parser.ast.IfParseNode; import org.truffleruby.parser.ast.InParseNode; @@ -111,12 +126,14 @@ import org.truffleruby.parser.ast.KeywordRestArgParseNode; import org.truffleruby.parser.ast.ListParseNode; import org.truffleruby.parser.ast.LocalAsgnParseNode; +import org.truffleruby.parser.ast.LocalVarParseNode; import org.truffleruby.parser.ast.Match2ParseNode; import org.truffleruby.parser.ast.Match3ParseNode; import org.truffleruby.parser.ast.MatchParseNode; import org.truffleruby.parser.ast.MultipleAsgnParseNode; import org.truffleruby.parser.ast.NilImplicitParseNode; import org.truffleruby.parser.ast.NilParseNode; +import org.truffleruby.parser.ast.NilRestArgParseNode; import org.truffleruby.parser.ast.NoKeywordsArgParseNode; import org.truffleruby.parser.ast.NthRefParseNode; import org.truffleruby.parser.ast.NumericParseNode; @@ -132,15 +149,20 @@ import org.truffleruby.parser.ast.RestArgParseNode; import org.truffleruby.parser.ast.RootParseNode; import org.truffleruby.parser.ast.SValueParseNode; +import org.truffleruby.parser.ast.SelfParseNode; import org.truffleruby.parser.ast.SplatParseNode; +import org.truffleruby.parser.ast.StarParseNode; import org.truffleruby.parser.ast.StrParseNode; import org.truffleruby.parser.ast.SuperParseNode; import org.truffleruby.parser.ast.SymbolParseNode; import org.truffleruby.parser.ast.TrueParseNode; import org.truffleruby.parser.ast.UndefParseNode; +import org.truffleruby.parser.ast.VCallParseNode; import org.truffleruby.parser.ast.WhenOneArgParseNode; import org.truffleruby.parser.ast.WhenParseNode; import org.truffleruby.parser.ast.YieldParseNode; +import org.truffleruby.parser.ast.ArrayPatternParseNode; +import org.truffleruby.parser.ast.FindPatternParseNode; import org.truffleruby.parser.ast.types.ILiteralNode; import org.truffleruby.parser.ast.types.INameNode; import org.truffleruby.parser.lexer.LexerSource; @@ -183,6 +205,15 @@ public class ParserSupport { private final String file; private final RubyDeferredWarnings warnings; + // Added from JRuby for gettable helpers + private int maxNumParam = 0; + private ParseNode numParamCurrent = null; + private ParseNode numParamInner = null; + private ParseNode numParamOuter = null; + + private Set keyTable; + private Set variableTable; + public ParserSupport(LexerSource source, RubyDeferredWarnings warnings) { this.file = source.getSourcePath(); this.warnings = warnings; @@ -896,6 +927,7 @@ public SourceIndexLength position(ParseNode one, ParseNode two) { return one == null ? two.getPosition() : one.getPosition(); } + public AndParseNode newAndNode(SourceIndexLength position, ParseNode left, ParseNode right) { value_expr(lexer, left); @@ -941,6 +973,111 @@ public CaseParseNode newCaseNode(SourceIndexLength position, ParseNode expressio return caseNode; } + // TODO: adding to the node class now. + public ArrayPatternParseNode new_array_pattern(SourceIndexLength position, ParseNode constant, ParseNode preArg, + ArrayPatternParseNode arrayPattern) { + arrayPattern.setConstant(constant); + + if (preArg != null) { + ListParseNode preArgs = new ArrayParseNode(position, preArg); + ListParseNode arrayPatternPreArgs = arrayPattern.getPreArgs(); + + arrayPattern.setPreArgs(arrayPatternPreArgs != null ? list_concat(preArgs, arrayPatternPreArgs) : preArgs); + } + + return arrayPattern; + } + + public ArrayPatternParseNode new_array_pattern_tail(SourceIndexLength line, ListParseNode preArgs, boolean hasRest, + TruffleString restArg, ListParseNode postArgs) { + return new ArrayPatternParseNode( + line, + preArgs, + hasRest + ? restArg != null + ? assignableLabelOrIdentifier(restArg, null) + : new StarParseNode(lexer.getPosition()) + : null, + postArgs); + } + + public void error_duplicate_pattern_key(TruffleString key) { + // This is for bare one-line matches ({a: 1} => a:). + if (keyTable == null) { + keyTable = new HashSet<>(); + } + if (keyTable.contains(key)) { + yyerror("duplicated key name"); + } + + keyTable.add(key); + } + + public void error_duplicate_pattern_variable(TruffleString variable) { + if (is_private_local_id(variable)) { + return; + } + if (variableTable.contains(variable)) { + yyerror("duplicated variable name"); + } + + variableTable.add(variable); + } + + public boolean is_private_local_id(TruffleString name) { + if (name.byteLength(lexer.tencoding) == 1 && (char) name.readByteUncached(0, lexer.tencoding) == '_') { + return true; + } + if (!is_local_id(name)) { + return false; + } + + return name.readByteUncached(0, lexer.tencoding) == '_'; + } + + public ParseNode new_find_pattern(ParseNode constant, FindPatternParseNode findPattern) { + findPattern.setConstant(constant); + + return findPattern; + } + + public ParseNode new_find_pattern_tail(SourceIndexLength line, TruffleString preRestArg, ListParseNode postArgs, + TruffleString postRestArg) { + /* FIXME: in MRI all the StarNodes are the same node and so perhaps source line for them is unimportant. */ + return new FindPatternParseNode( + line, + preRestArg != null + ? assignableLabelOrIdentifier(preRestArg, null) + : new StarParseNode(lexer.getPosition()), + postArgs, + postRestArg != null + ? assignableLabelOrIdentifier(postRestArg, null) + : new StarParseNode(lexer.getPosition())); + } + + public HashPatternParseNode new_hash_pattern(ParseNode constant, HashPatternParseNode hashPatternNode) { + hashPatternNode.setConstant(constant); + + return hashPatternNode; + } + + public static TruffleString KWNOREST = TStringConstants.EMPTY_US_ASCII; + + public HashPatternParseNode new_hash_pattern_tail(SourceIndexLength line, HashParseNode keywordArgs, + TruffleString keywordRestArg) { + ParseNode restArg; + + if (keywordRestArg == KWNOREST) { // '**nil' + restArg = new NilRestArgParseNode(line); + } else if (keywordRestArg != null) { // '**something' + restArg = assignableLabelOrIdentifier(keywordRestArg, null); + } else { // '**' + restArg = new StarParseNode(lexer.getPosition()); + } + + return new HashPatternParseNode(line, restArg, keywordArgs == null ? new HashParseNode(line) : keywordArgs); + } + /* This method exists for us to break up multiple expression when nodes (e.g. when 1,2,3:) into individual * whenNodes. The primary reason for this is to ensure lazy evaluation of the arguments (when foo,bar,gar:) to * prevent side-effects. In the old code this was done using nested when statements, which was awful for interpreter @@ -1428,19 +1565,19 @@ public ParseNode new_args(SourceIndexLength position, ListParseNode pre, ListPar } public ArgsTailHolder new_args_tail(SourceIndexLength position, ListParseNode keywordArg, - TruffleString keywordRestArgNameRope, BlockArgParseNode blockArg) { - if (keywordRestArgNameRope == null) { + TruffleString keywordRestArgName, BlockArgParseNode blockArg) { + if (keywordRestArgName == null) { return new ArgsTailHolder(position, keywordArg, null, blockArg); - } else if (keywordRestArgNameRope == RubyLexer.Keyword.NIL.bytes) { // def m(**nil) + } else if (keywordRestArgName == RubyLexer.Keyword.NIL.bytes) { // def m(**nil) return new ArgsTailHolder(position, keywordArg, new NoKeywordsArgParseNode(position, Layouts.TEMP_PREFIX + "nil_kwrest"), blockArg); } final String restKwargsName; - if (keywordRestArgNameRope.isEmpty()) { + if (keywordRestArgName.isEmpty()) { restKwargsName = Layouts.TEMP_PREFIX + "kwrest"; } else { - restKwargsName = keywordRestArgNameRope.toJavaStringUncached().intern(); + restKwargsName = keywordRestArgName.toJavaStringUncached().intern(); } int slot = currentScope.exists(restKwargsName); @@ -1530,6 +1667,14 @@ public SourceIndexLength getPosition(ParseNode start) { } } + public SourceIndexLength getPosition(Object start) { + if (start instanceof ParseNode) { + return ((ParseNode) start).getPosition(); + } else { + return lexer.getPosition(); + } + } + public void warn(SourceIndexLength position, String message) { warnings.warn(file, position.toSourceSection(lexer.getSource()).getStartLine(), message); } @@ -1875,6 +2020,31 @@ public NumericParseNode negateNumeric(NumericParseNode node) { return null; } + public Set push_pvtbl() { + Set currentTable = variableTable; + + variableTable = new HashSet<>(); + + return currentTable; + } + + public void pop_pvtbl(Set table) { + variableTable = table; + } + + public Set push_pktbl() { + Set currentTable = keyTable; + + keyTable = new HashSet<>(); + + return currentTable; + } + + public void pop_pktbl(Set table) { + keyTable = table; + } + + public ParseNode new_defined(SourceIndexLength position, ParseNode something) { return new DefinedParseNode(position, makeNullNil(something)); } @@ -1885,4 +2055,176 @@ public SourceIndexLength extendedUntil(SourceIndexLength start, SourceIndexLengt return new SourceIndexLength(start.getCharIndex(), end.getCharEnd() - start.getCharIndex()); } + + public ParseNode gettable(TruffleString id) { + SourceIndexLength loc = lexer.getPosition(); + if (id.equals(SELF)) { + return new SelfParseNode(loc); + } + if (id.equals(NIL)) { + return new NilParseNode(loc); + } + if (id.equals(TRUE)) { + return new TrueParseNode(loc); + } + if (id.equals(FALSE)) { + return new FalseParseNode(loc); + } + if (id.equals(__FILE__)) { + return new FileParseNode(loc, + TruffleString.fromByteArrayUncached(lexer.getFile().getBytes(), lexer.tencoding, true), + lexer.encoding); + } + if (id.equals(__LINE__)) { + return new FixnumParseNode(loc, lexer.getRubySourceLine()); + } + if (id.equals(__ENCODING__)) { + return new EncodingParseNode(loc, lexer.getEncoding()); + } + + TruffleString name = symbolID(id); + + switch (id_type(id)) { + case Local: { + String id2 = name.toString(); + int slot = currentScope.isDefined(id2); + + if (currentScope.isBlockScope() && slot != -1) { + if (isNumParamId(id2) && isNumParamNested()) { + return null; + } + if (name.equals(lexer.getCurrentArg())) { + // compile_error(str(getConfiguration().getRuntime(), "circular argument reference - ", name)); + warn(lexer.getPosition(), "circular argument reference - " + name); + } + + ParseNode newNode = new DVarParseNode(loc, slot, + TruffleString.ToJavaStringNode.create().execute(name)); + + // if (warnOnUnusedVariables && newNode instanceof IScopedNode) { + // scopedParserState.markUsedVariable(name, ((IScopedNode) newNode).getDepth()); + // } + return newNode; + } + + StaticScope.Type type = currentScope.getType(); + if (type == StaticScope.Type.LOCAL && slot != -1) { + if (name.equals(lexer.getCurrentArg())) { + // compile_error(str(getConfiguration().getRuntime(), "circular argument reference - ", name)); + warn(lexer.getPosition(), "circular argument reference - " + name); + } + + ParseNode newNode = new LocalVarParseNode(loc, slot, id2); + + // if (warnOnUnusedVariables && newNode instanceof IScopedNode) { + // scopedParserState.markUsedVariable(name, ((IScopedNode) newNode).getDepth()); + // } + + return newNode; + } + if (type == StaticScope.Type.BLOCK && isNumParamId(id2) && numberedParam(id2)) { + if (isNumParamNested()) { + return null; + } + + ParseNode newNode = new DVarParseNode(loc, slot, + TruffleString.ToJavaStringNode.create().execute(name)); + if (numParamCurrent == null) { + numParamCurrent = newNode; + } + return newNode; + } + // if (currentScope.getType() != StaticScope.Type.BLOCK) numparam_name(name); + + return new VCallParseNode(loc, id2); + } + case Global: + return new GlobalVarParseNode(loc, name); + case Instance: + return new InstVarParseNode(loc, name); + case Constant: + return new ConstParseNode(loc, name); + case Class: + return new ClassVarParseNode(loc, name); + default: + compile_error("identifier " + id + " is not valid to get"); + } + + + return null; + } + + enum IDType { + Local, + Global, + Instance, + AttrSet, + Constant, + Class; + } + + public IDType id_type(TruffleString identifier) { // required for gettable + byte first = (byte) identifier.readByteUncached(0, lexer.tencoding); + + if (Character.isUpperCase(first)) { + return Constant; + } + + switch (first) { + case '@': + return (char) identifier.readByteUncached(1, lexer.tencoding) == '@' ? IDType.Class : IDType.Instance; + case '$': + return IDType.Global; + } + + return IDType.Local; + } + + private boolean isNumParamId(String id) { + if (id.length() != 2 || id.charAt(0) != '_') { + return false; + } + + char one = id.charAt(1); + return one != '0' && Character.isDigit(one); // _1..._9 + } + + private boolean isNumParamNested() { + if (numParamOuter == null && numParamInner == null) { + return false; + } + + ParseNode used = numParamOuter != null ? numParamOuter : numParamInner; + compile_error("numbered parameter is already used in\n" + lexer.getFile() + ":" + used.getPosition() + ": " + + (numParamOuter != null ? "outer" : "inner") + " block here"); + // FIXME: Show error line + return true; + } + + private boolean numberedParam(String id) { + int n = Integer.parseInt(id.substring(1)); + if (currentScope.getEnclosingScope() == null) { + return false; + } + + if (maxNumParam == -1) { + compile_error("ordinary parameter is defined"); + return false; + } + + // if we have proc { _3 } then we need to up to 3 even though we never reference _1 or _2. + if (maxNumParam < n) { + maxNumParam = n; + } + + // MRI adds to their vtable here but we do it in makePreNumArgs. We are just + // making them like legit params and IRBuilder will be none the wiser. + + return true; + } + + + public void nd_set_first_loc(ParseNode node, SourceIndexLength line) { + /* FIXME: IMPL */ + } } diff --git a/src/main/java/org/truffleruby/parser/parser/RubyParser.java b/src/main/java/org/truffleruby/parser/parser/RubyParser.java index 57646fe5ee39..9eaa41aa5a42 100644 --- a/src/main/java/org/truffleruby/parser/parser/RubyParser.java +++ b/src/main/java/org/truffleruby/parser/parser/RubyParser.java @@ -42,6 +42,10 @@ import com.oracle.truffle.api.strings.TruffleString; +import java.util.Set; +import org.jcodings.Encoding; +import org.jcodings.specific.UTF8Encoding; + import org.truffleruby.Layouts; import org.truffleruby.annotations.SuppressFBWarnings; import org.truffleruby.core.encoding.Encodings; @@ -53,6 +57,7 @@ import org.truffleruby.parser.ast.ArgsParseNode; import org.truffleruby.parser.ast.ArgumentParseNode; import org.truffleruby.parser.ast.ArrayParseNode; +import org.truffleruby.parser.ast.ArrayPatternParseNode; import org.truffleruby.parser.ast.AssignableParseNode; import org.truffleruby.parser.ast.BackRefParseNode; import org.truffleruby.parser.ast.BeginParseNode; @@ -73,19 +78,23 @@ import org.truffleruby.parser.ast.DefnParseNode; import org.truffleruby.parser.ast.DefsParseNode; import org.truffleruby.parser.ast.DotParseNode; +import org.truffleruby.parser.ast.DVarParseNode; import org.truffleruby.parser.ast.EncodingParseNode; import org.truffleruby.parser.ast.EnsureParseNode; import org.truffleruby.parser.ast.EvStrParseNode; import org.truffleruby.parser.ast.FCallParseNode; import org.truffleruby.parser.ast.FalseParseNode; import org.truffleruby.parser.ast.FileParseNode; +import org.truffleruby.parser.ast.FindPatternParseNode; import org.truffleruby.parser.ast.FixnumParseNode; import org.truffleruby.parser.ast.FloatParseNode; import org.truffleruby.parser.ast.ForParseNode; import org.truffleruby.parser.ast.GlobalAsgnParseNode; import org.truffleruby.parser.ast.GlobalVarParseNode; import org.truffleruby.parser.ast.HashParseNode; +import org.truffleruby.parser.ast.HashPatternParseNode; import org.truffleruby.parser.ast.IfParseNode; +import org.truffleruby.parser.ast.InParseNode; import org.truffleruby.parser.ast.InstAsgnParseNode; import org.truffleruby.parser.ast.InstVarParseNode; import org.truffleruby.parser.ast.IterParseNode; @@ -157,7 +166,7 @@ public RubyParser(LexerSource source, RubyDeferredWarnings warnings) { this.lexer = new RubyLexer(support, source, warnings); support.setLexer(lexer); } -// line 125 "-" +// line 134 "-" // %token constants public static final int keyword_class = 257; public static final int keyword_module = 258; @@ -181,118 +190,118 @@ public RubyParser(LexerSource source, RubyDeferredWarnings warnings) { public static final int keyword_next = 276; public static final int keyword_redo = 277; public static final int keyword_retry = 278; - public static final int keyword_in = 279; - public static final int keyword_do = 280; - public static final int keyword_do_cond = 281; - public static final int keyword_do_block = 282; - public static final int keyword_return = 283; - public static final int keyword_yield = 284; - public static final int keyword_super = 285; - public static final int keyword_self = 286; - public static final int keyword_nil = 287; - public static final int keyword_true = 288; - public static final int keyword_false = 289; - public static final int keyword_and = 290; - public static final int keyword_or = 291; - public static final int keyword_not = 292; - public static final int modifier_if = 293; - public static final int modifier_unless = 294; - public static final int modifier_while = 295; - public static final int modifier_until = 296; - public static final int modifier_rescue = 297; - public static final int keyword_alias = 298; - public static final int keyword_defined = 299; - public static final int keyword_BEGIN = 300; - public static final int keyword_END = 301; - public static final int keyword__LINE__ = 302; - public static final int keyword__FILE__ = 303; - public static final int keyword__ENCODING__ = 304; - public static final int keyword_do_lambda = 305; - public static final int tIDENTIFIER = 306; - public static final int tFID = 307; - public static final int tGVAR = 308; - public static final int tIVAR = 309; - public static final int tCONSTANT = 310; - public static final int tCVAR = 311; - public static final int tLABEL = 312; - public static final int tCHAR = 313; - public static final int tUPLUS = 314; - public static final int tUMINUS = 315; - public static final int tUMINUS_NUM = 316; - public static final int tPOW = 317; - public static final int tCMP = 318; - public static final int tEQ = 319; - public static final int tEQQ = 320; - public static final int tNEQ = 321; - public static final int tGEQ = 322; - public static final int tLEQ = 323; - public static final int tANDOP = 324; - public static final int tOROP = 325; - public static final int tMATCH = 326; - public static final int tNMATCH = 327; - public static final int tDOT = 328; - public static final int tDOT2 = 329; - public static final int tDOT3 = 330; - public static final int tBDOT2 = 331; - public static final int tBDOT3 = 332; - public static final int tAREF = 333; - public static final int tASET = 334; - public static final int tLSHFT = 335; - public static final int tRSHFT = 336; - public static final int tANDDOT = 337; - public static final int tCOLON2 = 338; - public static final int tCOLON3 = 339; - public static final int tOP_ASGN = 340; - public static final int tASSOC = 341; - public static final int tLPAREN = 342; - public static final int tLPAREN2 = 343; - public static final int tRPAREN = 344; - public static final int tLPAREN_ARG = 345; - public static final int tLBRACK = 346; - public static final int tRBRACK = 347; - public static final int tLBRACE = 348; - public static final int tLBRACE_ARG = 349; - public static final int tSTAR = 350; - public static final int tSTAR2 = 351; - public static final int tAMPER = 352; - public static final int tAMPER2 = 353; - public static final int tTILDE = 354; - public static final int tPERCENT = 355; - public static final int tDIVIDE = 356; - public static final int tPLUS = 357; - public static final int tMINUS = 358; - public static final int tLT = 359; - public static final int tGT = 360; - public static final int tPIPE = 361; - public static final int tBANG = 362; - public static final int tCARET = 363; - public static final int tLCURLY = 364; - public static final int tRCURLY = 365; - public static final int tBACK_REF2 = 366; - public static final int tSYMBEG = 367; - public static final int tSTRING_BEG = 368; - public static final int tXSTRING_BEG = 369; - public static final int tREGEXP_BEG = 370; - public static final int tWORDS_BEG = 371; - public static final int tQWORDS_BEG = 372; - public static final int tSTRING_DBEG = 373; - public static final int tSTRING_DVAR = 374; - public static final int tSTRING_END = 375; - public static final int tLAMBDA = 376; - public static final int tLAMBEG = 377; - public static final int tNTH_REF = 378; - public static final int tBACK_REF = 379; - public static final int tSTRING_CONTENT = 380; - public static final int tINTEGER = 381; - public static final int tIMAGINARY = 382; - public static final int tFLOAT = 383; - public static final int tRATIONAL = 384; - public static final int tREGEXP_END = 385; - public static final int tSYMBOLS_BEG = 386; - public static final int tQSYMBOLS_BEG = 387; - public static final int tDSTAR = 388; - public static final int tSTRING_DEND = 389; - public static final int tLABEL_END = 390; + public static final int keyword_do = 279; + public static final int keyword_do_cond = 280; + public static final int keyword_do_block = 281; + public static final int keyword_return = 282; + public static final int keyword_yield = 283; + public static final int keyword_super = 284; + public static final int keyword_self = 285; + public static final int keyword_nil = 286; + public static final int keyword_true = 287; + public static final int keyword_false = 288; + public static final int keyword_and = 289; + public static final int keyword_or = 290; + public static final int keyword_not = 291; + public static final int modifier_if = 292; + public static final int modifier_unless = 293; + public static final int modifier_while = 294; + public static final int modifier_until = 295; + public static final int modifier_rescue = 296; + public static final int keyword_alias = 297; + public static final int keyword_defined = 298; + public static final int keyword_BEGIN = 299; + public static final int keyword_END = 300; + public static final int keyword__LINE__ = 301; + public static final int keyword__FILE__ = 302; + public static final int keyword__ENCODING__ = 303; + public static final int keyword_do_lambda = 304; + public static final int tIDENTIFIER = 305; + public static final int tFID = 306; + public static final int tGVAR = 307; + public static final int tIVAR = 308; + public static final int tCONSTANT = 309; + public static final int tCVAR = 310; + public static final int tLABEL = 311; + public static final int tCHAR = 312; + public static final int tUPLUS = 313; + public static final int tUMINUS = 314; + public static final int tUMINUS_NUM = 315; + public static final int tPOW = 316; + public static final int tCMP = 317; + public static final int tEQ = 318; + public static final int tEQQ = 319; + public static final int tNEQ = 320; + public static final int tGEQ = 321; + public static final int tLEQ = 322; + public static final int tANDOP = 323; + public static final int tOROP = 324; + public static final int tMATCH = 325; + public static final int tNMATCH = 326; + public static final int tDOT = 327; + public static final int tDOT2 = 328; + public static final int tDOT3 = 329; + public static final int tBDOT2 = 330; + public static final int tBDOT3 = 331; + public static final int tAREF = 332; + public static final int tASET = 333; + public static final int tLSHFT = 334; + public static final int tRSHFT = 335; + public static final int tANDDOT = 336; + public static final int tCOLON2 = 337; + public static final int tCOLON3 = 338; + public static final int tOP_ASGN = 339; + public static final int tASSOC = 340; + public static final int tLPAREN = 341; + public static final int tLPAREN2 = 342; + public static final int tRPAREN = 343; + public static final int tLPAREN_ARG = 344; + public static final int tLBRACK = 345; + public static final int tRBRACK = 346; + public static final int tLBRACE = 347; + public static final int tLBRACE_ARG = 348; + public static final int tSTAR = 349; + public static final int tSTAR2 = 350; + public static final int tAMPER = 351; + public static final int tAMPER2 = 352; + public static final int tTILDE = 353; + public static final int tPERCENT = 354; + public static final int tDIVIDE = 355; + public static final int tPLUS = 356; + public static final int tMINUS = 357; + public static final int tLT = 358; + public static final int tGT = 359; + public static final int tPIPE = 360; + public static final int tBANG = 361; + public static final int tCARET = 362; + public static final int tLCURLY = 363; + public static final int tRCURLY = 364; + public static final int tBACK_REF2 = 365; + public static final int tSYMBEG = 366; + public static final int tSTRING_BEG = 367; + public static final int tXSTRING_BEG = 368; + public static final int tREGEXP_BEG = 369; + public static final int tWORDS_BEG = 370; + public static final int tQWORDS_BEG = 371; + public static final int tSTRING_DBEG = 372; + public static final int tSTRING_DVAR = 373; + public static final int tSTRING_END = 374; + public static final int tLAMBDA = 375; + public static final int tLAMBEG = 376; + public static final int tNTH_REF = 377; + public static final int tBACK_REF = 378; + public static final int tSTRING_CONTENT = 379; + public static final int tINTEGER = 380; + public static final int tIMAGINARY = 381; + public static final int tFLOAT = 382; + public static final int tRATIONAL = 383; + public static final int tREGEXP_END = 384; + public static final int tSYMBOLS_BEG = 385; + public static final int tQSYMBOLS_BEG = 386; + public static final int tDSTAR = 387; + public static final int tSTRING_DEND = 388; + public static final int tLABEL_END = 389; + public static final int keyword_in = 390; public static final int tLOWEST = 391; public static final int yyErrorCode = 256; @@ -304,77 +313,88 @@ public RubyParser(LexerSource source, RubyDeferredWarnings warnings) { Order is mandated by jay. */ protected static final short[] yyLhs = { -//yyLhs 675 - -1, 156, 0, 142, 143, 143, 143, 143, 144, 144, - 37, 36, 38, 38, 38, 38, 44, 159, 44, 160, +//yyLhs 782 + -1, 186, 0, 141, 142, 142, 142, 142, 143, 143, + 37, 36, 38, 38, 38, 38, 44, 189, 44, 190, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 31, 31, 31, 31, 31, 31, 31, 31, 62, 62, 62, 40, 40, - 40, 40, 40, 40, 45, 32, 32, 61, 61, 116, - 152, 43, 43, 43, 43, 43, 43, 43, 43, 43, - 43, 43, 119, 119, 130, 130, 120, 120, 120, 120, - 120, 120, 120, 120, 120, 120, 76, 76, 106, 106, - 107, 107, 77, 77, 77, 77, 77, 77, 77, 77, + 40, 40, 40, 40, 45, 32, 32, 61, 61, 115, + 151, 43, 43, 43, 43, 43, 43, 43, 43, 43, + 43, 43, 118, 118, 129, 129, 119, 119, 119, 119, + 119, 119, 119, 119, 119, 119, 76, 76, 105, 105, + 106, 106, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, - 77, 83, 83, 83, 83, 83, 83, 83, 83, 83, - 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, + 77, 82, 82, 82, 82, 82, 82, 82, 82, 82, + 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 8, 8, 30, 30, 30, 7, 7, 7, 7, 7, - 123, 123, 124, 124, 65, 162, 65, 6, 6, 6, + 122, 122, 123, 123, 65, 192, 65, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, - 6, 6, 6, 6, 6, 6, 6, 137, 137, 137, - 137, 137, 137, 137, 137, 137, 137, 137, 137, 137, - 137, 137, 137, 137, 137, 137, 137, 137, 137, 137, - 137, 137, 137, 137, 137, 137, 137, 137, 137, 137, - 137, 137, 137, 137, 137, 137, 137, 137, 137, 41, + 6, 6, 6, 6, 6, 6, 6, 136, 136, 136, + 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, + 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, + 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, + 136, 136, 136, 136, 136, 136, 136, 136, 136, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, - 41, 41, 139, 139, 139, 139, 52, 52, 78, 82, - 82, 82, 82, 63, 63, 55, 55, 55, 59, 59, - 133, 133, 133, 133, 133, 53, 53, 53, 53, 53, - 164, 57, 110, 110, 109, 109, 85, 85, 85, 85, + 41, 41, 138, 138, 138, 138, 52, 52, 78, 81, + 81, 81, 81, 63, 63, 55, 55, 55, 59, 59, + 132, 132, 132, 132, 132, 53, 53, 53, 53, 53, + 194, 57, 109, 109, 108, 108, 84, 84, 84, 84, 35, 35, 75, 75, 75, 42, 42, 42, 42, 42, - 42, 42, 42, 42, 42, 42, 165, 42, 166, 42, - 167, 168, 42, 42, 42, 42, 42, 42, 42, 42, + 42, 42, 42, 42, 42, 42, 195, 42, 196, 42, + 197, 198, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, - 42, 170, 172, 42, 173, 174, 42, 42, 42, 42, - 175, 176, 42, 177, 42, 179, 42, 180, 42, 181, - 182, 42, 183, 184, 42, 42, 42, 42, 42, 46, - 154, 155, 153, 169, 169, 169, 171, 171, 50, 50, - 47, 47, 132, 132, 134, 134, 90, 90, 135, 135, - 135, 135, 135, 135, 135, 135, 135, 97, 97, 97, - 97, 97, 96, 96, 71, 71, 71, 71, 71, 71, + 42, 200, 202, 42, 203, 204, 42, 42, 42, 42, + 205, 206, 42, 207, 42, 209, 42, 210, 42, 211, + 212, 42, 213, 214, 42, 42, 42, 42, 42, 46, + 153, 154, 152, 199, 199, 199, 201, 201, 50, 50, + 47, 47, 131, 131, 133, 133, 89, 89, 134, 134, + 134, 134, 134, 134, 134, 134, 134, 96, 96, 96, + 96, 96, 95, 95, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 71, 73, - 186, 73, 72, 72, 72, 127, 127, 126, 126, 136, - 136, 187, 188, 129, 189, 70, 190, 70, 70, 128, - 128, 115, 60, 60, 60, 60, 22, 22, 22, 22, - 22, 22, 22, 22, 22, 114, 114, 191, 192, 117, - 193, 194, 118, 79, 48, 48, 80, 49, 49, 121, - 121, 81, 81, 81, 51, 51, 54, 54, 28, 28, - 28, 15, 16, 16, 16, 17, 18, 19, 25, 87, - 87, 27, 27, 93, 91, 91, 26, 94, 86, 86, - 92, 92, 20, 20, 21, 21, 24, 24, 23, 195, - 23, 196, 197, 198, 199, 200, 23, 66, 66, 66, - 66, 2, 1, 1, 1, 1, 29, 33, 33, 34, - 34, 34, 34, 58, 58, 58, 58, 58, 58, 58, - 58, 58, 58, 58, 58, 122, 122, 122, 122, 122, - 122, 122, 122, 122, 122, 122, 122, 67, 67, 201, - 56, 56, 74, 202, 74, 98, 98, 98, 98, 98, - 95, 95, 68, 68, 69, 69, 69, 69, 69, 69, + 216, 73, 72, 72, 72, 126, 126, 125, 125, 135, + 135, 217, 218, 128, 219, 70, 220, 70, 70, 127, + 127, 114, 60, 60, 60, 60, 22, 22, 22, 22, + 22, 22, 22, 22, 22, 113, 113, 221, 222, 116, + 223, 224, 117, 79, 48, 48, 225, 226, 227, 155, + 49, 49, 156, 156, 156, 157, 157, 157, 157, 157, + 157, 158, 159, 159, 160, 160, 182, 183, 161, 161, + 161, 161, 161, 161, 161, 161, 161, 161, 161, 161, + 161, 228, 161, 161, 229, 161, 163, 163, 163, 163, + 163, 163, 163, 163, 164, 164, 165, 165, 162, 177, + 177, 166, 166, 167, 174, 174, 174, 174, 175, 175, + 176, 176, 181, 181, 178, 178, 179, 180, 180, 168, + 168, 168, 168, 168, 168, 168, 168, 168, 168, 169, + 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, + 169, 169, 169, 169, 169, 170, 171, 171, 172, 173, + 173, 173, 120, 120, 80, 80, 80, 51, 51, 54, + 54, 28, 28, 28, 15, 16, 16, 16, 17, 18, + 19, 25, 86, 86, 27, 27, 92, 90, 90, 26, + 93, 85, 85, 91, 91, 20, 20, 21, 21, 24, + 24, 23, 230, 23, 231, 232, 233, 234, 235, 23, + 66, 66, 66, 66, 2, 1, 1, 1, 1, 29, + 33, 33, 184, 184, 184, 34, 34, 34, 34, 58, + 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, + 58, 121, 121, 121, 121, 121, 121, 121, 121, 121, + 121, 121, 121, 67, 67, 236, 56, 56, 74, 237, + 74, 97, 97, 97, 97, 97, 94, 94, 68, 68, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, - 148, 138, 138, 138, 138, 9, 9, 151, 125, 125, - 88, 88, 147, 99, 99, 100, 100, 101, 101, 102, - 102, 145, 145, 185, 146, 146, 64, 131, 108, 108, - 89, 89, 10, 10, 13, 13, 12, 12, 113, 113, - 112, 112, 14, 203, 14, 103, 103, 104, 104, 105, - 105, 105, 105, 105, 3, 3, 3, 4, 4, 4, - 4, 5, 5, 5, 11, 11, 149, 149, 150, 150, - 157, 157, 161, 161, 140, 141, 163, 163, 163, 178, - 178, 158, 158, 84, 111, + 69, 69, 69, 69, 69, 69, 147, 137, 137, 137, + 137, 9, 9, 150, 124, 124, 87, 87, 146, 98, + 98, 99, 99, 100, 100, 101, 101, 144, 144, 215, + 145, 145, 64, 130, 107, 107, 88, 88, 10, 10, + 13, 13, 12, 12, 112, 112, 111, 111, 14, 238, + 14, 102, 102, 103, 103, 104, 104, 104, 104, 104, + 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, + 11, 11, 148, 148, 149, 149, 187, 187, 191, 191, + 139, 140, 185, 193, 193, 193, 208, 208, 188, 188, + 83, 110, }, yyLen = { -//yyLen 675 +//yyLen 782 2, 0, 2, 2, 1, 1, 3, 2, 1, 4, 4, 2, 1, 1, 3, 2, 1, 0, 5, 0, 4, 3, 3, 3, 2, 3, 3, 3, 3, 3, @@ -408,7 +428,7 @@ public RubyParser(LexerSource source, RubyDeferredWarnings warnings) { 1, 1, 3, 4, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 4, 0, 3, 0, 0, 5, 3, 3, 2, 3, 3, 1, 4, - 3, 1, 5, 4, 3, 2, 1, 2, 2, 6, + 3, 1, 5, 4, 3, 2, 1, 2, 1, 6, 6, 0, 0, 7, 0, 0, 7, 5, 4, 5, 0, 0, 9, 0, 6, 0, 7, 0, 5, 0, 0, 7, 0, 0, 9, 1, 1, 1, 1, 1, @@ -418,185 +438,213 @@ public RubyParser(LexerSource source, RubyDeferredWarnings warnings) { 2, 1, 2, 0, 6, 8, 4, 6, 4, 2, 6, 2, 4, 6, 2, 4, 2, 4, 1, 1, 0, 2, 3, 1, 4, 1, 4, 1, 3, 1, - 1, 0, 0, 4, 0, 5, 0, 2, 0, 3, + 1, 0, 0, 5, 0, 5, 0, 2, 0, 3, 3, 3, 2, 4, 5, 5, 2, 4, 4, 3, 3, 3, 2, 1, 4, 3, 3, 0, 0, 4, - 0, 0, 4, 5, 1, 1, 5, 1, 1, 6, - 0, 1, 1, 1, 2, 1, 2, 1, 1, 1, - 1, 1, 1, 1, 2, 3, 3, 3, 4, 0, - 3, 1, 2, 4, 0, 3, 4, 4, 0, 3, - 0, 3, 0, 2, 0, 2, 0, 2, 1, 0, - 3, 0, 0, 0, 0, 0, 8, 1, 1, 1, - 1, 2, 1, 1, 1, 1, 3, 1, 2, 1, + 0, 0, 4, 5, 1, 1, 0, 0, 0, 8, + 1, 1, 1, 3, 3, 1, 2, 3, 1, 1, + 1, 1, 3, 1, 3, 1, 1, 1, 1, 1, + 4, 4, 4, 3, 4, 4, 4, 3, 3, 3, + 2, 0, 4, 2, 0, 4, 1, 1, 2, 3, + 5, 2, 4, 1, 2, 3, 1, 3, 5, 2, + 1, 1, 3, 1, 3, 1, 2, 1, 1, 3, + 2, 1, 1, 3, 2, 1, 2, 1, 1, 1, + 3, 3, 2, 2, 1, 1, 1, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 2, 2, 4, 2, + 3, 1, 6, 0, 1, 1, 1, 2, 1, 2, + 1, 1, 1, 1, 1, 1, 1, 2, 3, 3, + 3, 4, 0, 3, 1, 2, 4, 0, 3, 4, + 4, 0, 3, 0, 3, 0, 2, 0, 2, 0, + 2, 1, 0, 3, 0, 0, 0, 0, 0, 8, + 1, 1, 1, 1, 2, 1, 1, 1, 1, 3, + 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, - 4, 0, 3, 0, 3, 4, 2, 2, 2, 1, - 2, 0, 1, 0, 6, 8, 4, 6, 4, 6, - 2, 4, 6, 2, 4, 2, 4, 1, 3, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, - 1, 3, 1, 2, 1, 2, 1, 1, 3, 1, - 3, 1, 1, 2, 2, 1, 3, 3, 1, 3, - 1, 3, 1, 1, 2, 1, 1, 1, 2, 1, - 2, 0, 1, 0, 4, 1, 2, 1, 3, 3, - 2, 1, 4, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 0, 1, 0, 1, 2, 2, 0, 1, 1, 1, - 1, 1, 2, 0, 0, + 1, 1, 1, 1, 1, 0, 4, 0, 3, 0, + 3, 4, 2, 2, 2, 1, 2, 0, 1, 0, + 6, 8, 4, 6, 4, 6, 2, 4, 6, 2, + 4, 2, 4, 1, 3, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 3, 1, 3, 1, 2, + 1, 2, 1, 1, 3, 1, 3, 1, 1, 2, + 2, 1, 3, 3, 1, 3, 1, 3, 1, 1, + 2, 1, 1, 1, 2, 1, 2, 0, 1, 0, + 4, 1, 2, 1, 3, 3, 2, 1, 4, 2, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, + 2, 2, 2, 0, 1, 1, 1, 1, 1, 2, + 0, 0, }, yyDefRed = { -//yyDefRed 1142 +//yyDefRed 1290 1, 0, 0, 0, 370, 371, 0, 0, 316, 0, 0, 0, 341, 344, 0, 0, 0, 367, 368, 372, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 482, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 502, 504, 506, 0, 0, - 431, 557, 558, 529, 532, 530, 531, 0, 0, 479, - 60, 306, 0, 483, 307, 308, 0, 309, 310, 305, - 480, 31, 48, 478, 527, 0, 0, 0, 0, 0, + 585, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 605, 607, 609, 0, 0, + 431, 663, 664, 635, 638, 636, 637, 0, 0, 582, + 60, 306, 0, 586, 307, 308, 0, 309, 310, 305, + 583, 31, 48, 581, 630, 0, 0, 0, 0, 0, 0, 0, 313, 0, 56, 0, 0, 86, 0, 4, - 311, 312, 0, 0, 72, 0, 2, 0, 5, 0, - 0, 0, 0, 7, 187, 198, 188, 211, 184, 204, - 194, 193, 214, 215, 209, 192, 191, 186, 212, 216, - 217, 196, 185, 199, 203, 205, 197, 190, 206, 213, + 311, 312, 0, 0, 72, 0, 338, 2, 0, 5, + 0, 0, 0, 0, 7, 187, 198, 188, 211, 184, + 204, 194, 193, 214, 215, 209, 192, 191, 186, 212, + 216, 217, 196, 185, 199, 203, 205, 190, 206, 213, 208, 0, 0, 0, 0, 183, 202, 201, 218, 182, - 189, 180, 181, 0, 0, 0, 0, 137, 535, 534, - 0, 537, 172, 173, 169, 150, 151, 152, 159, 156, - 158, 153, 154, 174, 175, 160, 161, 633, 166, 165, + 189, 180, 181, 0, 0, 0, 0, 137, 641, 640, + 0, 643, 172, 173, 169, 150, 151, 152, 159, 156, + 158, 153, 154, 174, 175, 160, 161, 739, 166, 165, 149, 171, 168, 167, 163, 164, 157, 155, 147, 170, - 148, 176, 162, 138, 359, 0, 632, 139, 207, 200, - 210, 195, 177, 178, 179, 135, 136, 141, 140, 143, - 0, 142, 144, 0, 0, 0, 0, 0, 0, 0, + 148, 176, 162, 197, 138, 359, 0, 738, 139, 207, + 200, 210, 195, 177, 178, 179, 135, 136, 141, 140, + 143, 0, 142, 144, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 669, 670, 0, 0, 0, - 671, 0, 0, 365, 366, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 776, 777, 0, 0, + 0, 778, 0, 0, 365, 366, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 369, 0, 0, 382, 383, 0, 0, - 328, 0, 0, 0, 0, 502, 0, 0, 285, 70, - 0, 0, 0, 637, 289, 71, 0, 68, 0, 0, - 452, 67, 0, 663, 0, 0, 19, 0, 0, 0, - 241, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 13, 12, 0, 0, 0, 0, 0, - 269, 0, 0, 0, 635, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 369, 0, 0, 382, 383, 0, + 0, 328, 0, 0, 0, 0, 605, 0, 0, 285, + 70, 0, 0, 0, 743, 289, 71, 0, 68, 0, + 0, 452, 67, 0, 769, 0, 0, 19, 0, 0, + 0, 241, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 13, 12, 0, 0, 0, 0, + 0, 269, 0, 0, 0, 741, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 254, 52, 253, 524, 523, 525, - 521, 522, 0, 0, 0, 0, 489, 498, 338, 0, - 494, 500, 484, 460, 457, 337, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 254, 52, 253, 627, 626, + 628, 624, 625, 0, 0, 0, 0, 592, 601, 0, + 597, 603, 587, 460, 457, 337, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 264, 265, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 263, 262, 0, 0, 0, 0, - 460, 442, 656, 657, 0, 0, 0, 0, 659, 658, + 460, 442, 762, 763, 0, 0, 0, 0, 765, 764, 0, 0, 88, 0, 0, 0, 0, 0, 0, 3, - 0, 446, 0, 335, 69, 539, 538, 540, 541, 543, - 542, 544, 0, 0, 0, 0, 133, 0, 0, 314, - 357, 0, 360, 654, 655, 362, 145, 0, 0, 0, + 0, 446, 0, 335, 69, 645, 644, 646, 647, 649, + 648, 650, 0, 0, 0, 0, 133, 0, 0, 314, + 357, 0, 360, 760, 761, 362, 145, 0, 0, 0, 374, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 672, 0, 0, 0, 528, 0, 0, - 0, 0, 350, 640, 297, 292, 0, 643, 0, 0, + 0, 0, 0, 779, 0, 0, 0, 631, 0, 0, + 0, 0, 350, 746, 297, 292, 0, 749, 0, 0, 286, 295, 0, 287, 0, 330, 0, 291, 0, 281, 280, 0, 0, 0, 0, 0, 334, 51, 21, 23, 22, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 323, 11, 0, 0, 319, 0, 326, - 0, 667, 270, 0, 272, 327, 636, 0, 90, 0, - 0, 0, 0, 0, 511, 509, 526, 508, 505, 485, - 503, 486, 487, 507, 0, 0, 434, 432, 0, 0, + 0, 774, 270, 0, 272, 327, 742, 0, 90, 0, + 0, 0, 0, 0, 614, 612, 629, 611, 608, 588, + 606, 589, 590, 610, 0, 0, 434, 432, 0, 0, 0, 0, 461, 0, 458, 25, 26, 27, 28, 29, 49, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 449, 0, 451, 0, 0, 0, 649, 0, 0, 650, - 450, 0, 647, 648, 0, 47, 0, 0, 0, 44, + 449, 0, 451, 0, 0, 0, 755, 0, 0, 756, + 450, 0, 753, 754, 0, 47, 0, 0, 0, 44, 227, 0, 0, 0, 0, 37, 219, 33, 296, 0, 0, 0, 0, 89, 32, 0, 300, 0, 38, 220, - 6, 457, 62, 0, 130, 0, 132, 559, 353, 0, + 6, 457, 62, 0, 130, 0, 132, 665, 353, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 317, - 0, 375, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 375, 0, 0, 0, 0, 0, 0, 466, 0, 0, 0, 348, 377, 342, 376, 345, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 639, 0, 0, 0, - 294, 638, 329, 664, 0, 0, 275, 277, 333, 20, + 0, 0, 0, 0, 0, 0, 745, 0, 0, 0, + 294, 744, 329, 770, 0, 0, 275, 277, 333, 20, 0, 9, 30, 0, 226, 0, 0, 14, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 512, 0, 488, - 491, 0, 496, 0, 0, 0, 596, 593, 592, 591, - 594, 602, 611, 590, 0, 623, 622, 627, 626, 612, - 597, 0, 0, 0, 620, 437, 0, 0, 587, 609, - 0, 569, 600, 595, 0, 0, 0, 589, 0, 0, - 493, 0, 497, 0, 456, 0, 455, 0, 0, 441, + 0, 0, 0, 0, 0, 0, 0, 615, 0, 591, + 594, 0, 599, 0, 0, 0, 702, 699, 698, 697, + 700, 708, 717, 696, 0, 729, 728, 733, 732, 718, + 703, 0, 0, 0, 726, 437, 0, 0, 693, 715, + 0, 675, 706, 701, 0, 0, 0, 695, 0, 0, + 596, 0, 600, 0, 456, 0, 455, 0, 0, 441, 0, 0, 448, 0, 0, 0, 0, 0, 0, 279, 0, 447, 278, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 87, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 134, 0, 0, 634, 0, 0, 0, - 363, 146, 472, 0, 0, 473, 0, 0, 380, 0, - 378, 0, 0, 0, 0, 0, 0, 0, 0, 347, - 349, 0, 0, 0, 0, 0, 0, 642, 299, 288, - 0, 0, 332, 0, 322, 271, 91, 0, 513, 517, - 518, 519, 510, 520, 490, 492, 499, 0, 572, 0, - 0, 433, 0, 0, 384, 0, 386, 0, 624, 628, - 0, 585, 0, 580, 0, 583, 0, 566, 613, 614, - 0, 567, 603, 0, 568, 495, 501, 0, 419, 0, - 0, 0, 43, 224, 42, 225, 66, 0, 665, 40, + 0, 0, 0, 134, 0, 0, 740, 0, 0, 0, + 363, 146, 575, 0, 0, 576, 0, 0, 380, 0, + 378, 0, 0, 0, 0, 0, 0, 0, 467, 347, + 349, 0, 0, 0, 0, 0, 0, 748, 299, 288, + 0, 0, 332, 0, 322, 271, 91, 0, 616, 620, + 621, 622, 613, 623, 593, 595, 602, 0, 678, 0, + 0, 433, 0, 0, 384, 0, 386, 0, 730, 734, + 0, 691, 0, 686, 0, 689, 0, 672, 719, 720, + 0, 673, 709, 0, 674, 598, 604, 0, 419, 0, + 0, 0, 43, 224, 42, 225, 66, 0, 771, 40, 222, 41, 223, 64, 445, 444, 46, 0, 0, 0, 0, 0, 0, 0, 0, 0, 34, 59, 0, 0, - 0, 454, 358, 0, 0, 0, 0, 0, 0, 475, - 381, 0, 10, 477, 0, 339, 0, 340, 0, 298, - 0, 0, 0, 351, 0, 276, 18, 514, 0, 0, - 0, 0, 0, 0, 0, 0, 599, 0, 570, 598, - 0, 0, 601, 588, 0, 621, 0, 610, 630, 0, - 0, 616, 462, 423, 0, 421, 459, 0, 0, 39, - 0, 0, 0, 560, 354, 562, 361, 564, 0, 0, + 0, 454, 358, 0, 0, 0, 0, 0, 0, 578, + 381, 0, 10, 580, 0, 339, 0, 340, 0, 298, + 0, 0, 0, 351, 0, 276, 18, 617, 0, 0, + 0, 0, 0, 0, 0, 0, 705, 0, 676, 704, + 0, 0, 707, 694, 0, 727, 0, 716, 736, 0, + 0, 722, 462, 423, 0, 421, 459, 0, 0, 39, + 0, 0, 0, 666, 354, 668, 361, 670, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 577, 0, 579, 0, 558, 557, + 559, 560, 562, 561, 563, 565, 571, 532, 0, 0, + 0, 504, 0, 0, 0, 605, 0, 550, 551, 552, + 553, 554, 549, 555, 556, 564, 0, 0, 0, 0, + 481, 0, 485, 478, 479, 488, 0, 489, 544, 545, + 0, 480, 0, 528, 0, 537, 538, 527, 0, 464, + 463, 465, 343, 346, 0, 618, 435, 0, 440, 439, + 385, 0, 0, 0, 387, 0, 692, 0, 684, 0, + 682, 0, 687, 690, 671, 0, 0, 0, 418, 713, + 0, 0, 401, 0, 724, 0, 0, 0, 0, 356, + 0, 0, 0, 0, 0, 0, 0, 547, 548, 131, + 569, 0, 500, 0, 0, 0, 0, 513, 0, 503, + 0, 0, 519, 0, 566, 633, 632, 634, 0, 567, + 536, 534, 468, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 474, 0, 476, 0, 0, 464, - 463, 465, 343, 346, 0, 515, 435, 0, 440, 439, - 385, 0, 0, 0, 387, 0, 586, 0, 578, 0, - 576, 0, 581, 584, 565, 0, 0, 0, 418, 607, - 0, 0, 401, 0, 618, 0, 0, 0, 0, 356, - 0, 0, 0, 0, 0, 0, 0, 467, 466, 468, - 0, 0, 429, 0, 427, 430, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 416, 0, 0, 411, 0, - 398, 0, 414, 422, 399, 0, 0, 0, 0, 0, - 400, 364, 0, 0, 0, 0, 0, 469, 379, 352, - 0, 0, 426, 0, 0, 579, 0, 574, 577, 582, - 0, 402, 424, 0, 0, 608, 0, 0, 0, 619, - 325, 0, 0, 0, 516, 428, 0, 0, 0, 417, - 0, 408, 0, 406, 397, 0, 412, 415, 0, 0, - 575, 0, 0, 0, 0, 410, 0, 404, 407, 413, - 0, 405, + 429, 0, 427, 430, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 416, 0, 0, 411, 0, 398, 0, + 414, 422, 399, 0, 0, 0, 0, 0, 400, 364, + 0, 0, 0, 0, 0, 572, 379, 0, 499, 498, + 0, 0, 0, 514, 772, 605, 0, 533, 0, 0, + 473, 474, 482, 477, 0, 484, 540, 541, 570, 497, + 493, 0, 0, 0, 0, 0, 0, 529, 524, 0, + 521, 352, 0, 0, 426, 0, 0, 685, 0, 680, + 683, 688, 0, 402, 424, 0, 0, 714, 0, 0, + 0, 725, 325, 0, 0, 0, 505, 0, 0, 515, + 0, 502, 568, 0, 0, 491, 490, 492, 495, 494, + 496, 0, 619, 428, 0, 0, 0, 417, 0, 408, + 0, 406, 397, 0, 412, 415, 0, 0, 0, 0, + 470, 469, 471, 0, 522, 518, 681, 0, 0, 0, + 0, 0, 0, 410, 0, 404, 407, 413, 0, 405, }, yyDgoto = { -//yyDgoto 204 - 1, 350, 69, 70, 669, 590, 591, 208, 436, 730, - 731, 445, 732, 733, 195, 71, 72, 73, 74, 75, - 353, 352, 76, 538, 355, 77, 78, 711, 79, 80, - 437, 81, 82, 83, 84, 625, 447, 448, 311, 312, - 86, 87, 88, 89, 313, 229, 301, 810, 1000, 1048, - 811, 918, 91, 489, 922, 592, 638, 287, 92, 771, - 93, 94, 615, 616, 734, 210, 842, 231, 847, 848, - 547, 1026, 965, 877, 798, 617, 96, 97, 280, 462, - 660, 804, 319, 232, 314, 593, 545, 544, 736, 737, - 855, 549, 550, 100, 101, 861, 1065, 1101, 948, 739, - 1029, 1030, 740, 325, 492, 283, 102, 529, 1031, 480, - 284, 481, 867, 741, 423, 401, 632, 553, 551, 103, - 104, 648, 233, 211, 212, 742, 1053, 938, 851, 358, - 316, 1034, 268, 493, 856, 857, 1054, 197, 743, 399, - 485, 765, 106, 107, 108, 744, 745, 746, 747, 641, - 410, 949, 269, 270, 111, 112, 2, 238, 239, 511, - 501, 486, 646, 522, 288, 213, 317, 318, 698, 451, - 241, 664, 823, 242, 824, 674, 1004, 790, 452, 788, +//yyDgoto 239 + 1, 351, 69, 70, 669, 590, 591, 209, 436, 730, + 731, 445, 732, 733, 196, 71, 72, 73, 74, 75, + 354, 353, 76, 540, 356, 77, 78, 711, 79, 80, + 437, 81, 82, 83, 84, 625, 447, 448, 312, 313, + 86, 87, 88, 89, 314, 230, 302, 810, 1050, 1271, + 811, 918, 91, 489, 922, 592, 638, 288, 92, 771, + 93, 94, 615, 616, 734, 211, 842, 232, 847, 848, + 547, 1076, 965, 877, 798, 617, 96, 97, 281, 462, + 804, 320, 233, 315, 593, 545, 544, 736, 737, 855, + 549, 550, 100, 101, 861, 1153, 1223, 948, 739, 1079, + 1080, 740, 326, 492, 284, 102, 529, 1081, 480, 285, + 481, 867, 741, 423, 401, 632, 553, 551, 103, 104, + 648, 234, 212, 213, 742, 1141, 938, 851, 106, 317, + 1084, 269, 493, 856, 857, 1142, 198, 743, 399, 485, + 765, 107, 108, 109, 744, 745, 746, 747, 641, 410, + 949, 110, 111, 112, 113, 660, 1027, 1028, 1181, 1030, + 1031, 1032, 1033, 1105, 1106, 1107, 1209, 1108, 1035, 1036, + 1037, 1038, 1039, 1040, 1041, 1042, 1043, 1044, 1045, 1046, + 1047, 1048, 1133, 1134, 1119, 1109, 2, 239, 240, 511, + 501, 486, 646, 522, 289, 214, 318, 319, 698, 451, + 242, 664, 823, 243, 824, 674, 1054, 790, 452, 788, 642, 442, 644, 645, 916, 749, 879, 359, 715, 714, - 548, 554, 757, 552, 755, 708, 707, 838, 937, 1005, - 1051, 789, 799, 441, + 548, 554, 757, 552, 755, 818, 928, 1189, 1111, 1101, + 708, 707, 838, 937, 1055, 1139, 789, 799, 441, }, yySindex = { -//yySindex 1142 - 0, 0, 19997, 21580, 0, 0, 19352, 19748, 0, 22759, - 22759, 18556, 0, 0, 23283, 20392, 20392, 0, 0, 0, - -278, -196, 0, 0, 0, 0, 91, 19616, 149, -202, - -161, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 22890, 22890, 867, 22890, 22890, -92, 20129, 0, 21052, - 21448, 18824, 22890, 23021, 19484, 0, 0, 0, 211, 261, - 0, 0, 0, 0, 0, 0, 0, 269, 288, 0, - 0, 0, -64, 0, 0, 0, -222, 0, 0, 0, - 0, 0, 0, 0, 0, 925, 49, 3634, 0, 95, - 699, 477, 0, 481, 0, -11, 309, 0, 320, 0, - 0, 0, 23414, 345, 0, 116, 0, 135, 0, -197, - 20392, 23545, 23676, 0, 0, 0, 0, 0, 0, 0, +//yySindex 1290 + 0, 0, 21762, 23333, 0, 0, 21107, 21509, 0, 24503, + 24503, 19515, 0, 0, 25023, 22154, 22154, 0, 0, 0, + -236, -177, 0, 0, 0, 0, 114, 21375, 158, -160, + -127, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 24633, 24633, 940, 24633, 24633, -44, 21893, 0, 22809, + 23202, 20074, 24633, 24763, 21241, 0, 0, 0, 249, 259, + 0, 0, 0, 0, 0, 0, 0, 270, 346, 0, + 0, 0, -61, 0, 0, 0, -84, 0, 0, 0, + 0, 0, 0, 0, 0, 1706, 80, 7772, 0, 285, + 1041, 568, 0, 688, 0, 60, 497, 0, 517, 0, + 0, 0, 25153, 544, 0, 282, 0, 0, 649, 0, + -112, 22154, 25283, 25413, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -604,242 +652,273 @@ public RubyParser(LexerSource source, RubyDeferredWarnings warnings) { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, -105, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, -68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 423, 0, 0, 20261, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 160, 20261, 49, 107, - 823, 178, 461, 185, 107, 0, 0, 135, 274, 492, - 0, 22759, 22759, 0, 0, -278, -196, 0, 0, 0, - 0, 267, 149, 0, 0, 0, 0, 0, 0, 0, - 0, 867, 314, 0, 1154, 0, 0, 0, 327, -197, - 0, 22890, 22890, 22890, 22890, 0, 22890, 3634, 0, 0, - 294, 607, 609, 0, 0, 0, 16851, 0, 20392, 20524, - 0, 0, 18691, 0, 22759, 322, 0, 21842, 19997, 20261, - 0, 1175, 351, 357, 3720, 3720, 338, 21711, 0, 20129, - 337, 135, 925, 0, 0, 0, 149, 149, 21711, 335, - 0, 158, 163, 294, 0, 319, 163, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 396, - 23807, 1248, 0, 651, 0, 0, 0, 0, 0, 0, - 0, 0, 612, 827, 1214, 323, 0, 0, 0, 369, - 0, 0, 0, 0, 0, 0, 22759, 22759, 22759, 22759, - 21711, 22759, 22759, 22890, 22890, 22890, 22890, 22890, 0, 0, - 22890, 22890, 22890, 22890, 22890, 22890, 22890, 22890, 22890, 22890, - 22890, 22890, 22890, 22890, 0, 0, 22890, 22890, 22890, 22890, - 0, 0, 0, 0, 4093, 20392, 4601, 22890, 0, 0, - 24673, 23021, 0, 21973, 20129, 18959, 675, 21973, 23021, 0, - 19090, 0, 375, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 22759, -4, 0, 367, 1276, 0, - 0, 22759, 0, 0, 0, 0, 0, 469, 479, 338, - 0, 20261, 466, 5201, 20392, 5667, 22890, 22890, 22890, 20261, - 29, 22104, 485, 0, 75, 75, 402, 0, 0, 6089, - 20392, 8232, 0, 0, 0, 0, 754, 0, 22890, 20656, - 0, 0, 21184, 0, 149, 0, 409, 0, 22890, 0, - 0, 719, 720, 149, 149, 272, 0, 0, 0, 0, - 0, 19748, 22759, 3634, 405, 410, 5201, 5667, 22890, 22890, - 925, 403, 149, 0, 0, 19221, 0, 0, 925, 0, - 21316, 0, 0, 21448, 0, 0, 0, 0, 0, 728, - 24151, 20392, 24209, 23807, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1243, 233, 0, 0, 4179, 1345, - 264, 513, 0, 416, 0, 0, 0, 0, 0, 0, - 0, 0, 351, 3241, 3241, 3241, 3241, 4736, 4228, 3241, - 3241, 3720, 3720, 457, 457, 351, 2645, 351, 351, 815, - 815, 2673, 2673, 6598, 3095, 521, 452, 0, 454, -196, - 0, 0, 0, 751, 149, 505, 0, 510, -196, 0, - 0, 3095, 0, 0, -196, 0, 500, 3164, 1303, 0, - 0, -11, 745, 22890, 3164, 0, 0, 0, 0, 808, - 149, 23807, 810, 0, 0, 528, 0, 0, 0, 0, - 0, 0, 0, 49, 0, 0, 0, 0, 0, 24267, - 20392, 24325, 20261, 272, 518, 19880, 19748, 22235, 587, 0, - 300, 0, 522, 529, 149, 530, 532, 587, 22104, 604, - 615, 710, 0, 0, 0, 0, 0, 0, 0, -196, - 149, 0, 0, -196, 22759, 22890, 0, 22890, 294, 609, - 0, 0, 0, 0, 20788, 21184, 0, 0, 0, 0, - 272, 0, 0, 351, 0, 19997, 0, 0, 149, 163, - 23807, 0, 0, 149, 0, 0, 728, 0, 717, 0, - 0, 10, 0, 844, 4179, -151, 0, 0, 0, 0, - 0, 0, 0, 0, 1533, 0, 0, 0, 0, 0, - 0, 584, 586, 849, 0, 0, 854, 857, 0, 0, - 866, 0, 0, 0, -27, 868, 22890, 0, 852, 868, - 0, 159, 0, 884, 0, 0, 0, 0, 864, 0, - 23021, 23021, 0, 375, 20656, 585, 581, 23021, 23021, 0, - 375, 0, 0, 95, -222, 21711, 22890, 24383, 20392, 24441, - 23021, 0, 22366, 0, 728, 23807, 21711, 567, 135, 22759, - 20261, 0, 0, 0, 149, 685, 0, 4179, 20261, 4179, - 0, 0, 0, 0, 603, 0, 20261, 698, 0, 22759, - 0, 700, 22890, 22890, 623, 22890, 22890, 702, 710, 0, - 0, 22497, 20261, 20261, 20261, 0, 75, 0, 0, 0, - 924, 149, 0, 605, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 149, 0, 20261, - 20261, 0, 1533, 549, 0, 935, 0, 149, 0, 0, - 1927, 0, 4179, 0, 4687, 0, 842, 0, 0, 0, - 290, 0, 0, 22890, 0, 0, 0, 20261, 0, -140, - 20261, 22890, 0, 0, 0, 0, 0, 23021, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 3634, 452, 454, - 149, 505, 510, 22890, 0, 728, 0, 0, 20261, 135, - 718, 0, 0, 149, 725, 135, 518, 23938, 107, 0, - 0, 20261, 0, 0, 107, 0, 22890, 0, 20261, 0, - 316, 730, 733, 0, 21184, 0, 0, 0, 639, 941, - 737, 642, 149, 2297, 967, 2236, 0, 968, 0, 0, - 975, 976, 0, 0, 978, 0, 968, 0, 0, 723, - 868, 0, 0, 0, 663, 0, 0, 3634, 3634, 0, - 585, 0, 759, 0, 0, 0, 0, 0, 20261, 0, + 0, 596, 0, 0, 22024, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 341, 22024, 80, + 104, 1139, 308, 605, 380, 104, 0, 0, 649, 459, + 674, 0, 24503, 24503, 0, 0, -236, -177, 0, 0, + 0, 0, 394, 158, 0, 0, 0, 0, 0, 0, + 0, 0, 940, 435, 0, 1197, 0, 0, 0, 364, + -112, 0, 24633, 24633, 24633, 24633, 0, 24633, 7772, 0, + 0, 416, 721, 743, 0, 0, 0, 17967, 0, 22154, + 22285, 0, 0, 19647, 0, 24503, 486, 0, 23593, 21762, + 22024, 0, 1320, 451, 461, 4268, 4268, 498, 23463, 0, + 21893, 529, 649, 1706, 0, 0, 0, 158, 158, 23463, + 500, 0, 69, 87, 416, 0, 545, 87, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 721, 1307, 0, 0, 20261, 0, 20261, -31, 0, - 0, 0, 0, 0, 20261, 0, 0, 1616, 0, 0, - 0, 995, 2297, 625, 0, 1927, 0, 1927, 0, 4687, - 0, 1927, 0, 0, 0, 998, 149, 1004, 0, 0, - 1009, 1010, 0, 694, 0, 868, 24069, 1006, 868, 0, - 795, 0, 24499, 20392, 24557, 469, 300, 0, 0, 0, - 801, 20261, 0, 202, 0, 0, 2297, 995, 2297, 1024, - 968, 1028, 968, 968, 1927, 0, 712, 4687, 0, 842, - 0, 4687, 0, 0, 0, 0, 0, 768, 1439, 24069, - 0, 0, 0, 0, 149, 0, 0, 0, 0, 0, - 690, 1616, 0, 995, 2297, 0, 1927, 0, 0, 0, - 1036, 0, 0, 1040, 1043, 0, 868, 1044, 1036, 0, - 0, 24615, 1439, 0, 0, 0, 995, 968, 1927, 0, - 1927, 0, 4687, 0, 0, 1927, 0, 0, 0, 0, - 0, 1036, 1045, 1036, 1036, 0, 1927, 0, 0, 0, - 1036, 0, + 579, 25543, 1344, 0, 890, 0, 0, 0, 0, 0, + 0, 0, 0, 1332, 1440, 1694, 1293, 0, 0, 598, + 0, 0, 0, 0, 0, 0, 24503, 24503, 24503, 24503, + 23463, 24503, 24503, 24633, 24633, 24633, 24633, 24633, 0, 0, + 24633, 24633, 24633, 24633, 24633, 24633, 24633, 24633, 24633, 24633, + 24633, 24633, 24633, 24633, 0, 0, 24633, 24633, 24633, 24633, + 0, 0, 0, 0, 4218, 22154, 4729, 24633, 0, 0, + 5295, 24763, 0, 23723, 21893, 20204, 899, 23723, 24763, 0, + 20334, 0, 608, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 24503, -184, 0, 601, 1390, 0, + 0, 24503, 0, 0, 0, 0, 0, 700, 710, 498, + 0, 22024, 715, 7657, 22154, 25885, 24633, 24633, 24633, 22024, + -144, 23853, 722, 0, 208, 208, 650, 0, 0, 25943, + 22154, 26001, 0, 0, 0, 0, 1035, 0, 24633, 22416, + 0, 0, 22940, 0, 158, 0, 662, 0, 24633, 0, + 0, 966, 973, 158, 158, 92, 0, 0, 0, 0, + 0, 21509, 24503, 7772, 657, 668, 7657, 25885, 24633, 24633, + 1706, 671, 158, 0, 0, 20464, 0, 0, 1706, 0, + 23071, 0, 0, 23202, 0, 0, 0, 0, 0, 991, + 26059, 22154, 26117, 25543, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1703, -203, 0, 0, 3708, 1753, + 494, 775, 0, 679, 0, 0, 0, 0, 0, 0, + 0, 0, 451, 3338, 3338, 3338, 3338, 4807, 4352, 3338, + 3338, 4268, 4268, 1680, 1680, 451, 1220, 451, 451, 1157, + 1157, 1800, 1800, 6248, 3172, 781, 712, 0, 714, -177, + 0, 0, 0, 1016, 158, 735, 0, 737, -177, 0, + 0, 3172, 0, 0, -177, 0, 776, 7264, 1446, 0, + 0, 60, 1019, 24633, 7264, 0, 0, 0, 0, 1051, + 158, 25543, 1052, 0, 0, 801, 0, 0, 0, 0, + 0, 0, 0, 80, 0, 0, 0, 0, 0, 26175, + 22154, 26233, 22024, 92, 757, 21643, 21509, 23983, 832, 0, + 553, 0, 767, 771, 158, 777, 779, 832, 0, 856, + 860, 118, 0, 0, 0, 0, 0, 0, 0, -177, + 158, 0, 0, -177, 24503, 24633, 0, 24633, 416, 743, + 0, 0, 0, 0, 22547, 22940, 0, 0, 0, 0, + 92, 0, 0, 451, 0, 21762, 0, 0, 158, 87, + 25543, 0, 0, 158, 0, 0, 991, 0, 1274, 0, + 0, 210, 0, 1097, 3708, -174, 0, 0, 0, 0, + 0, 0, 0, 0, 2734, 0, 0, 0, 0, 0, + 0, 830, 833, 1112, 0, 0, 1113, 1115, 0, 0, + 1122, 0, 0, 0, -58, 1124, 24633, 0, 1109, 1124, + 0, 257, 0, 1140, 0, 0, 0, 0, 1117, 0, + 24763, 24763, 0, 608, 22416, 838, 834, 24763, 24763, 0, + 608, 0, 0, 285, -84, 23463, 24633, 26291, 22154, 26349, + 24763, 0, 24113, 0, 991, 25543, 23463, 817, 649, 24503, + 22024, 0, 0, 0, 158, 927, 0, 3708, 22024, 3708, + 0, 0, 0, 0, 852, 0, 22024, 930, 0, 24503, + 0, 932, 24633, 24633, 867, 24633, 24633, 945, 0, 0, + 0, 24243, 22024, 22024, 22024, 0, 208, 0, 0, 0, + 1168, 158, 0, 855, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 158, 0, 22024, + 22024, 0, 2734, 1123, 0, 1176, 0, 158, 0, 0, + 3169, 0, 3708, 0, 3255, 0, 1036, 0, 0, 0, + 503, 0, 0, 24633, 0, 0, 0, 22024, 0, -136, + 22024, 24633, 0, 0, 0, 0, 0, 24763, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 7772, 712, 714, + 158, 735, 737, 24633, 0, 991, 0, 0, 22024, 649, + 957, 0, 0, 158, 961, 649, 757, 25673, 104, 0, + 0, 22024, 0, 0, 104, 0, 24633, 0, 20772, 0, + 342, 971, 972, 0, 22940, 0, 0, 0, 900, 1196, + 993, 894, 158, 1673, 1217, 3326, 0, 1219, 0, 0, + 1223, 1231, 0, 0, 1234, 0, 1219, 0, 0, 975, + 1124, 0, 0, 0, 2588, 0, 0, 7772, 7772, 0, + 838, 0, 1017, 0, 0, 0, 0, 0, 22024, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 974, 1601, 0, 0, 22024, 0, 22024, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 3823, 3823, + 466, 0, 3699, 158, 980, 0, 1708, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 254, 104, 610, 65, + 0, 1165, 0, 0, 0, 0, 604, 0, 0, 0, + 175, 0, 1248, 0, 1249, 0, 0, 0, 20977, 0, + 0, 0, 0, 0, 22024, 0, 0, 1545, 0, 0, + 0, 1251, 1673, 1146, 0, 3169, 0, 3169, 0, 3255, + 0, 3169, 0, 0, 0, 1253, 158, 1257, 0, 0, + 1259, 1260, 0, 946, 0, 1124, 25803, 1250, 1124, 0, + 1045, 0, 26407, 22154, 26465, 700, 553, 0, 0, 0, + 0, 20977, 0, 992, 158, 158, 17703, 0, 1269, 0, + 951, 469, 0, 1121, 0, 0, 0, 0, 24503, 0, + 0, 0, 0, 24503, 24503, 1029, 20875, 20977, 3823, 3823, + 466, 158, 158, 20772, 20772, 469, 20977, 992, 1074, 22024, + 0, 97, 0, 0, 1673, 1251, 1673, 1302, 1219, 1304, + 1219, 1219, 3169, 0, 995, 3255, 0, 1036, 0, 3255, + 0, 0, 0, 0, 0, 1054, 1782, 25803, 0, 0, + 0, 0, 158, 0, 0, 0, 0, 177, 0, 0, + 17, 992, 1316, 0, 0, 0, 158, 0, 1342, 22024, + 0, 0, 0, 0, 1317, 0, 0, 0, 0, 0, + 0, 158, 158, 158, 158, 158, 158, 0, 0, 1341, + 0, 0, 1007, 1545, 0, 1251, 1673, 0, 3169, 0, + 0, 0, 1366, 0, 0, 1369, 1375, 0, 1124, 1382, + 1366, 0, 0, 26523, 1782, 0, 0, 1395, 20977, 0, + 436, 0, 0, -210, 20977, 0, 0, 0, 0, 0, + 0, 20875, 0, 0, 1251, 1219, 3169, 0, 3169, 0, + 3255, 0, 0, 3169, 0, 0, 0, 0, 20977, 1399, + 0, 0, 0, 1399, 0, 0, 0, 1366, 1402, 1366, + 1366, 1399, 20977, 0, 3169, 0, 0, 0, 1366, 0, }, yyRindex = { -//yyRindex 1142 - 0, 0, 161, 0, 0, 0, 0, 0, 0, 0, - 0, 822, 0, 0, 0, 10675, 10812, 0, 0, 0, - 5486, 5020, 12220, 12324, 12435, 12572, 23152, 0, 22628, 0, - 0, 12676, 12787, 12924, 5819, 4004, 13028, 13139, 5952, 13276, - 0, 0, 0, 0, 0, 0, 0, 139, 18422, 753, - 736, 114, 0, 0, 1367, 0, 0, 0, 0, 0, +//yyRindex 1290 + 0, 0, 758, 0, 0, 0, 0, 0, 0, 0, + 0, 1177, 0, 0, 0, 11472, 11609, 0, 0, 0, + 5578, 5112, 9613, 9964, 10315, 10666, 24893, 0, 24373, 0, + 0, 11017, 13075, 13187, 5910, 4096, 13322, 13426, 6044, 13538, + 0, 0, 0, 0, 0, 0, 0, 116, 19378, 1106, + 1093, 31, 0, 0, 1852, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 10419, 0, 0, 0, 10907, 0, 0, 0, + 0, 0, 0, 0, 0, 76, 1758, 17377, 11121, 17480, + 0, 13673, 0, 17515, 0, 14024, 0, 0, 0, 0, + 0, 0, 194, 0, 0, 0, 0, 0, 63, 0, + 22678, 11713, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 10108, 0, 0, 0, 10212, 0, 0, 0, - 0, 0, 0, 0, 0, 72, 16729, 7210, 10323, 7718, - 0, 13380, 0, 16527, 0, 13491, 0, 0, 0, 0, - 0, 0, 263, 0, 0, 0, 0, 36, 0, 20920, - 10916, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 5216, 5682, 6197, 6705, 0, 0, 0, 0, 0, + 0, 0, 0, 7213, 7721, 12054, 12391, 0, 0, 0, + 12728, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1484, 2710, 3091, 5126, 0, 0, 0, 0, 0, - 0, 0, 0, 5592, 6041, 6550, 7058, 0, 0, 0, - 7566, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 3318, 0, 0, 1632, 2513, 8450, 8664, 8801, 9015, + 9152, 9366, 2925, 9503, 9717, 3080, 9854, 0, 116, 17649, + 0, 0, 10556, 0, 0, 0, 0, 0, -133, 0, + -60, 0, 0, 0, 0, 0, 11258, 10068, 410, 729, + 750, 1268, 0, 1132, 1280, 1312, 1376, 2169, 1652, 1670, + 2766, 1882, 0, 0, 0, 0, 1996, 0, 0, 0, + 0, 0, 2198, 0, 17117, 0, 0, 0, 2709, 0, + 0, 16963, 17160, 17160, 0, 0, 0, 1134, 0, 0, + 156, 0, 0, 1134, 0, 0, 0, 0, 0, 100, + 100, 0, 0, 12162, 1596, 16167, 16273, 14130, 0, 18977, + 116, 0, 2557, 1741, 0, 0, 57, 1134, 1134, 0, + 0, 0, 1119, 1119, 0, 0, 0, 1116, 897, 1037, + 1195, 1435, 1453, 1754, 1967, 2409, 2257, 2350, 2607, 2631, + 0, 0, 0, 2697, 200, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 3192, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 16787, 0, 0, 1064, 8452, 8563, 8700, 8804, 8915, 9052, - 9156, 2852, 9267, 9404, 2988, 9508, 0, 139, 16674, 0, - 0, 9860, 0, 0, 0, 0, 0, 80, 0, 92, - 0, 0, 0, 0, 0, 10460, 9619, 1146, 1172, 1301, - 1435, 0, 765, 1700, 1713, 1756, 1322, 1938, 2474, 1785, - 2531, 0, 0, 0, 0, 3277, 0, 0, 0, 0, - 0, 1302, 0, 3738, 0, 0, 0, 16299, 0, 0, - 16427, 4246, 4246, 0, 0, 0, 769, 0, 0, 166, - 0, 0, 769, 0, 0, 0, 0, 0, 37, 37, - 0, 0, 11268, 10564, 1918, 2553, 13628, 0, 18018, 139, - 0, 2689, 1282, 0, 0, 38, 769, 769, 0, 0, - 0, 770, 770, 0, 0, 0, 750, 1471, 1611, 1677, - 2131, 2300, 9479, 9831, 1663, 10183, 10535, 1998, 10887, 0, - 0, 0, 11239, 273, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 3589, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 11825, 11960, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 11027, 11164, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 18, 0, 0, 0, 0, + 0, 0, 0, 0, 116, 217, 219, 0, 0, 0, + 82, 0, 17206, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 18106, 18250, 0, 0, 0, 19109, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 815, 0, 10770, + 0, 707, 17837, 0, 18, 0, 0, 0, 0, 725, + 0, 0, 0, 0, 0, 0, 0, 0, 2109, 0, + 18, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1134, 0, 0, 0, 176, 0, + 0, 222, 207, 1134, 1134, 1134, 0, 0, 0, 0, + 0, 0, 0, 16529, 0, 0, 0, 0, 0, 0, + 2187, 0, 1134, 0, 0, 2648, 68, 0, 229, 0, + 1143, 0, 0, -41, 0, 0, 0, 2710, 0, 224, + 0, 18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 40, 0, 0, 0, 0, - 0, 0, 0, 0, 139, 344, 538, 0, 0, 0, - 71, 0, 4754, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 16984, 17120, 0, 0, 0, 18153, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 570, 0, 9971, - 0, 488, 17748, 0, 40, 0, 0, 0, 0, 673, - 0, 0, 0, 0, 0, 0, 0, 0, 3785, 0, - 40, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 769, 0, 0, 0, 170, 0, - 0, 183, 52, 769, 769, 769, 0, 0, 0, 0, - 0, 0, 0, 15935, 0, 0, 0, 0, 0, 0, - 1414, 0, 769, 0, 0, 3127, 46, 0, 194, 0, - 778, 0, 0, -52, 0, 0, 0, 11591, 0, 616, - 0, 40, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 12297, 15263, 15366, 15477, 15608, 15719, 16017, 15822, + 15911, 16362, 16423, 14377, 14481, 12499, 14619, 12634, 12836, 13777, + 13915, 14779, 14910, 1427, 15021, 0, 6418, 4470, 7942, 22678, + 0, 4604, 0, 98, 1156, 6552, 0, 6926, 5444, 0, + 0, 15124, 0, 0, 8316, 0, 2083, 16874, 0, 0, + 0, 14266, 0, 0, 1405, 0, 0, 0, 0, 0, + 1134, 0, 263, 0, 0, 8488, 0, 1539, 0, 0, + 0, 0, 0, 702, 0, 18708, 0, 0, 0, 0, + 18, 0, 1632, 1134, 12740, 0, 0, 822, 685, 0, + 1222, 0, 3454, 4978, 1156, 3588, 3962, 1222, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 3213, 524, 0, + 1156, 3794, 4302, 10205, 0, 0, 0, 0, 17027, 17160, + 0, 0, 0, 0, 231, 248, 0, 0, 0, 0, + 1134, 0, 0, 12971, 0, 100, 140, 0, 1134, 1119, + 0, 2752, 886, 1156, 12047, 12072, 283, 0, 0, 0, + 0, 0, 0, 0, 130, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 11379, 14909, 15032, 15149, 15249, 15340, 15691, 15489, - 15600, 15781, 15845, 14084, 14195, 11516, 14332, 11620, 11731, 13732, - 13843, 14436, 14547, 1084, 14680, 0, 6327, 4379, 7851, 20920, - 0, 4512, 0, 47, 796, 6460, 0, 6835, 5353, 0, - 0, 14792, 0, 0, 2394, 0, 1840, 16363, 0, 0, - 0, 13980, 0, 0, 15404, 0, 0, 0, 0, 0, - 769, 0, 618, 0, 0, 2023, 0, 2061, 0, 0, - 0, 0, 0, 150, 0, 17614, 0, 0, 0, 0, - 40, 0, 1064, 769, 8072, 0, 0, 617, 407, 0, - 883, 0, 3363, 4887, 796, 3496, 3871, 883, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 2099, 1299, 0, - 796, 2601, 3198, 9756, 0, 0, 0, 0, 16487, 4246, - 0, 0, 0, 0, 206, 129, 0, 0, 0, 0, - 769, 0, 0, 11868, 0, 37, 134, 0, 769, 770, - 0, 2085, 1065, 796, 2197, 2529, 644, 0, 0, 0, - 0, 0, 0, 0, 212, 0, 0, 0, 0, 0, + 0, 294, 267, 363, 0, 0, 363, 363, 0, 0, + 407, 0, 0, 0, 621, 407, 146, 0, 665, 407, + 0, 0, 0, 0, 0, 18840, 0, 19246, 0, 0, + 0, 0, 0, 17273, 136, 8911, 0, 0, 0, 0, + 17337, 0, 0, 17593, 11394, 0, 0, 0, 18, 0, + 0, 1298, 0, 0, 333, 0, 0, 0, 0, 0, + 1632, 18407, 18551, 0, 1156, 0, 0, 258, 1632, 732, + 0, 0, 0, 821, 280, 0, 840, 1222, 0, 0, + 0, 0, 0, 0, 2045, 0, 0, 0, 0, 0, + 0, 0, 947, 675, 675, 910, 0, 0, 0, 0, + 207, 1134, 0, 0, 0, 0, 0, 1039, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 3, 0, 1632, + 100, 0, 0, 260, 0, 274, 0, 1134, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 221, 268, 200, 0, 0, 200, 200, 0, 0, - 244, 0, 0, 0, 271, 244, 53, 0, 120, 244, - 0, 0, 0, 0, 0, 17884, 0, 18287, 0, 0, - 0, 0, 0, 6194, 57, 11972, 0, 0, 0, 0, - 6702, 0, 0, 16591, 1152, 0, 0, 0, 40, 0, - 0, 843, 0, 0, 677, 0, 0, 0, 0, 0, - 1064, 17300, 17434, 0, 796, 0, 0, 214, 1064, 155, - 0, 0, 0, 171, 606, 0, 781, 883, 0, 0, - 0, 0, 0, 0, 8348, 0, 0, 0, 0, 0, - 0, 0, 640, 191, 191, 671, 0, 0, 0, 0, - 52, 769, 0, 0, 0, 0, 0, 2727, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 2, 0, 1064, - 37, 0, 0, 222, 0, 226, 0, 769, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1632, 0, 0, + 100, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 16618, 7060, 8076, + 1156, 7434, 7568, 0, 16232, 370, 0, 0, 1632, 0, + 0, 0, 0, 1134, 0, 0, 12740, 0, 0, 0, + 0, 675, 0, 0, 0, 0, 0, 0, 0, 0, + 1222, 0, 0, 0, 331, 0, 0, 0, 0, 188, + 0, 0, 1134, 0, 289, 0, 0, 363, 0, 0, + 363, 363, 0, 0, 363, 0, 363, 0, 0, 621, + 407, 0, 0, 0, -1, 0, 0, 16721, 16785, 0, + 9262, 17702, 0, 0, 0, 0, 0, 0, 1632, 2231, + 2591, 2615, 2755, 5219, 5685, 8706, 2228, 9020, 9305, 2817, + 9371, 0, 0, 9402, 0, 1632, 0, 707, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1064, 0, 0, - 37, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 16023, 6968, 7984, - 796, 7343, 7476, 0, 1690, 680, 0, 0, 1064, 0, - 0, 0, 0, 769, 0, 0, 8072, 0, 0, 0, - 0, 191, 0, 0, 0, 0, 0, 0, 449, 0, - 883, 0, 0, 0, 143, 0, 0, 0, 0, -70, - 0, 0, 769, 0, 231, 0, 0, 200, 0, 0, - 200, 200, 0, 0, 200, 0, 200, 0, 0, 271, - 244, 0, 0, 0, -6, 0, 0, 16123, 16211, 0, - 12083, 16655, 0, 0, 0, 0, 0, 0, 1064, 1779, - 2151, 2246, 2500, 2523, 2526, 2636, 919, 8389, 8427, 947, - 8457, 0, 0, 8599, 0, 1064, 0, 488, 883, 0, - 0, 0, 0, 0, 191, 0, 0, 0, 0, 0, - 0, 234, 0, 235, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 130, -6, 130, 0, 0, - 140, 130, 0, 0, 0, 140, 111, 125, 140, 0, - 0, 8671, 0, 40, 0, 570, 883, 0, 0, 0, - 0, 25, 0, 17, 0, 0, 0, 237, 0, 246, - 200, 200, 200, 200, 0, 0, 0, 141, 0, 0, - 0, 0, 0, 0, 0, 2010, 13918, 0, 128, 0, - 0, 0, 1810, 1565, 796, 2461, 2463, 0, 0, 0, - 0, 0, 0, 253, 0, 0, 0, 0, 0, 0, - 130, 0, 0, 130, 130, 0, 140, 130, 130, 0, - 0, 0, 138, 543, 0, 0, 260, 200, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 14577, 1394, - 0, 130, 130, 130, 130, 0, 0, 0, 0, 0, - 130, 0, + 0, 0, 1156, 620, 2689, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1286, 0, 733, 686, + 0, 8878, 0, 0, 0, 0, 902, 0, 0, 0, + 1698, 0, 1700, 0, 1935, 0, 0, 0, 769, 0, + 0, 0, 0, 0, 675, 0, 0, 0, 0, 0, + 0, 309, 0, 317, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 93, -1, 93, 0, 0, + 110, 93, 0, 0, 0, 110, 137, 138, 110, 0, + 0, 9408, 0, 18, 0, 815, 1222, 0, 0, 0, + 0, 0, 0, 6707, 1156, 1156, 2210, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 911, 0, 11649, 13009, + 0, 20566, 20669, 0, 0, 1764, 0, 1058, 0, 16, + 0, 367, 0, 0, 0, 326, 0, 338, 363, 363, + 363, 363, 0, 0, 0, 126, 0, 0, 0, 0, + 0, 0, 0, 1542, 2189, 0, 150, 0, 0, 0, + 8554, 1449, 1156, 8557, 10175, 0, 0, 1134, 0, 0, + 4202, 7215, 4710, 0, 0, 0, 1128, 0, 0, 86, + 0, 0, 0, 0, 934, 0, 0, 0, 0, 0, + 0, 1134, 1134, 1134, 1156, 1156, 1156, 0, 0, 4844, + 0, 0, 0, 0, 0, 355, 0, 0, 0, 0, + 0, 0, 93, 0, 0, 93, 93, 0, 110, 93, + 93, 0, 0, 0, 154, 10877, 0, 5684, 0, 0, + 0, 0, 0, 1222, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 414, 363, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 8806, 6118, 0, 5818, + 0, 0, 0, 1258, 0, 0, 0, 93, 93, 93, + 93, 6792, 0, 0, 0, 0, 0, 0, 93, 0, }, yyGindex = { -//yyGindex 204 - 0, 0, 3, 0, -218, 0, 14, 22, -354, -113, - 0, 0, 0, 318, 0, 0, 0, 1076, 0, 0, - 878, 1099, 0, -280, 0, 0, 0, 608, 0, 16, - 1046, -286, -38, 0, 27, 0, 437, 391, 0, 30, - 94, 2110, 4, 23, 648, 77, -2, -406, 0, 0, - 131, 0, 0, 764, 0, 48, 0, -15, 1169, 589, - 0, 0, -320, 509, -800, 0, 0, 296, -177, 637, - 0, 0, 0, 431, 275, -371, -91, -20, 385, -435, - 198, 0, 0, 1250, 87, 103, 0, 0, 11855, 341, - -737, 0, 0, 0, 0, 218, 2439, 241, -437, 331, - 146, 0, 0, 0, 64, -428, 0, -413, 145, -258, - -423, 0, 86, 1970, -72, 455, -421, 579, 838, 1225, - 13, 196, 1553, 0, -5, -229, 0, -821, 0, 0, - -186, -993, 0, -368, -879, 390, 174, 0, -933, 1163, - 917, -577, -269, 0, 31, -814, 1186, 398, -262, -74, - 0, -531, 937, 1088, 0, 0, 0, 21, 34, 0, - 0, -23, 0, -282, 0, 0, 0, 0, 0, -232, - 0, -373, 0, 0, 0, 0, 0, 0, 15, 0, - 0, 0, 0, 0, 0, 1841, 0, 0, 0, 0, +//yyGindex 239 + 0, 0, 26, 0, -316, 0, 37, 6, -425, -695, + 0, 0, 0, -690, 0, 15241, 0, 1432, 15819, 16686, + -274, 1450, 0, -202, 0, 18935, 18987, 956, 18998, 38, + 1403, -180, 117, 0, 14, 0, 190, 509, 0, 67, + 40, 2247, -13, 62, 1000, 29, 21, -644, 0, 0, + 422, 0, 0, 782, 0, 90, 0, -12, 1514, 919, + 0, 0, -384, 796, -769, 0, 0, 205, -465, 982, + 0, 0, 0, 770, 612, -351, -88, -5, 585, -445, + 0, 0, 504, -2, 462, 0, 0, 56, 673, -179, + 0, 0, 19035, 19166, -593, 1884, 584, 153, 693, 411, + 0, 0, 0, 5, -440, 0, 101, 425, -266, -463, + 0, -665, 178, -70, 798, -564, 958, 1187, 1574, 46, + 502, 723, 0, -22, -840, 0, -822, 0, 19182, -191, + -998, 0, -353, -841, 747, 389, 0, -1001, 1522, 340, + 265, -281, 0, 22, 550, 184, 2334, -283, -82, 0, + -369, 1348, 1797, 0, 0, 371, 0, 0, 2524, 0, + 0, 488, -890, -239, 0, 690, -362, 979, 0, -816, + 499, 0, 0, 0, -443, 0, 484, -1011, 0, 0, + 491, 0, 0, 0, 0, 441, 0, 536, -3, 0, + 0, 45, 0, -242, 0, 0, 0, 0, 0, -232, + 0, -378, 0, 0, 0, 0, 0, 0, 264, 0, + 0, 0, 0, 0, 0, 2359, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, }; protected static final short[] yyTable = YyTables.yyTable(); protected static final short[] yyCheck = YyTables.yyCheck(); @@ -851,12 +930,13 @@ public RubyParser(LexerSource source, RubyDeferredWarnings warnings) { "end-of-file",null,null,null,null,null,null,null,null,null,"'\\n'", null,null,null,null,null,null,null,null,null,null,null,null,null,null, null,null,null,null,null,null,null,"' '",null,null,null,null,null, - null,null,null,null,null,null,"','",null,null,null,null,null,null, + null,null,"'('","')'",null,null,"','",null,null,null,null,null,null, null,null,null,null,null,null,null,"':'","';'",null,"'='",null,"'?'", null,null,null,null,null,null,null,null,null,null,null,null,null,null, null,null,null,null,null,null,null,null,null,null,null,null,null, - "'['",null,null,null,null,null,null,null,null,null,null,null,null, + "'['",null,null,"'^'",null,null,null,null,null,null,null,null,null, null,null,null,null,null,null,null,null,null,null,null,null,null,null, + null,null,null,null,null,null,"'|'",null,null,null,null,null,null, null,null,null,null,null,null,null,null,null,null,null,null,null,null, null,null,null,null,null,null,null,null,null,null,null,null,null,null, null,null,null,null,null,null,null,null,null,null,null,null,null,null, @@ -866,34 +946,32 @@ public RubyParser(LexerSource source, RubyDeferredWarnings warnings) { null,null,null,null,null,null,null,null,null,null,null,null,null,null, null,null,null,null,null,null,null,null,null,null,null,null,null,null, null,null,null,null,null,null,null,null,null,null,null,null,null,null, - null,null,null,null,null,null,null,null,null,null,null,null,null, "keyword_class","keyword_module","keyword_def","keyword_undef", "keyword_begin","keyword_rescue","keyword_ensure","keyword_end", "keyword_if","keyword_unless","keyword_then","keyword_elsif", "keyword_else","keyword_case","keyword_when","keyword_while", "keyword_until","keyword_for","keyword_break","keyword_next", - "keyword_redo","keyword_retry","keyword_in","keyword_do", - "keyword_do_cond","keyword_do_block","keyword_return","keyword_yield", - "keyword_super","keyword_self","keyword_nil","keyword_true", - "keyword_false","keyword_and","keyword_or","keyword_not", - "modifier_if","modifier_unless","modifier_while","modifier_until", - "modifier_rescue","keyword_alias","keyword_defined","keyword_BEGIN", - "keyword_END","keyword__LINE__","keyword__FILE__", - "keyword__ENCODING__","keyword_do_lambda","tIDENTIFIER","tFID", - "tGVAR","tIVAR","tCONSTANT","tCVAR","tLABEL","tCHAR","unary+", -"unary-","tUMINUS_NUM","'**'","'<=>'","'=='","'==='","'!='","'>='", -"'<='","'&&'","'||'","'=~'","'!~'","'.'","'..'","'...'", - "tBDOT2","tBDOT3","'[]'","'[]='","'<<'","'>>'","'&.'", -"'::'","':: at EXPR_BEG'","tOP_ASGN","'=>'","'('","'( arg'", -"')'","'['","'{'","'{ arg'","'['","'[ args'", -"'*'","'*'","'&'","'&'","'~'","'%'","'/'", -"'+'","'-'","'<'","'>'","'|'","'!'","'^'","'{'", -"'}'","'`'","':'","tSTRING_BEG","tXSTRING_BEG", - "tREGEXP_BEG","tWORDS_BEG","tQWORDS_BEG","tSTRING_DBEG", - "tSTRING_DVAR","tSTRING_END","'->'","tLAMBEG","tNTH_REF", - "tBACK_REF","tSTRING_CONTENT","tINTEGER","tIMAGINARY","tFLOAT", - "tRATIONAL","tREGEXP_END","tSYMBOLS_BEG","tQSYMBOLS_BEG","'**'", - "tSTRING_DEND","tLABEL_END","tLOWEST", + "keyword_redo","keyword_retry","keyword_do","keyword_do_cond", + "keyword_do_block","keyword_return","keyword_yield","keyword_super", + "keyword_self","keyword_nil","keyword_true","keyword_false", + "keyword_and","keyword_or","keyword_not","modifier_if", + "modifier_unless","modifier_while","modifier_until","modifier_rescue", + "keyword_alias","keyword_defined","keyword_BEGIN","keyword_END", + "keyword__LINE__","keyword__FILE__","keyword__ENCODING__", + "keyword_do_lambda","tIDENTIFIER","tFID","tGVAR","tIVAR","tCONSTANT", + "tCVAR","tLABEL","tCHAR","unary+","unary-","tUMINUS_NUM","'**'", +"'<=>'","'=='","'==='","'!='","'>='","'<='","'&&'","'||'","'=~'", +"'!~'","'.'","'..'","'...'","tBDOT2","tBDOT3","'[]'","'[]='", +"'<<'","'>>'","'&.'","'::'","':: at EXPR_BEG'","tOP_ASGN","'=>'", +"'('","'( arg'","')'","'['","'['","'[ arg'", +"'{'","'{ args'","'*'","'*'","'&'","'&'","'~'", +"'%'","'/'","'+'","'-'","'<'","'>'","'|'","'!'", +"'^'","'{'","'}'","'`'","':'","tSTRING_BEG", + "tXSTRING_BEG","tREGEXP_BEG","tWORDS_BEG","tQWORDS_BEG", + "tSTRING_DBEG","tSTRING_DVAR","tSTRING_END","'->'","tLAMBEG", + "tNTH_REF","tBACK_REF","tSTRING_CONTENT","tINTEGER","tIMAGINARY", + "tFLOAT","tRATIONAL","tREGEXP_END","tSYMBOLS_BEG","tQSYMBOLS_BEG", +"'**'","tSTRING_DEND","tLABEL_END","keyword_in","tLOWEST", }; @@ -1056,7 +1134,7 @@ public Object yyparse (RubyLexer yyLex) { } } -static ParserState[] states = new ParserState[675]; +static ParserState[] states = new ParserState[782]; static { states[1] = (support, lexer, yyVal, yyVals, yyTop) -> { lexer.setState(EXPR_BEG); @@ -2197,7 +2275,7 @@ public Object yyparse (RubyLexer yyLex) { return yyVal; }; states[258] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = support.newOrNode(((ParseNode)yyVals[-2+yyTop]).getPosition(), ((ParseNode)yyVals[-2+yyTop]), ((ParseNode)yyVals[0+yyTop])); + yyVal = support.newOrNode(support.getPosition(((ParseNode)yyVals[-2+yyTop])), ((ParseNode)yyVals[-2+yyTop]), ((ParseNode)yyVals[0+yyTop])); return yyVal; }; states[259] = (support, lexer, yyVal, yyVals, yyTop) -> { @@ -2584,7 +2662,7 @@ public Object yyparse (RubyLexer yyLex) { return yyVal; }; states[349] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = support.newCaseInNode(((SourceIndexLength)yyVals[-4+yyTop]), ((ParseNode)yyVals[-3+yyTop]), ((ParseNode)yyVals[-1+yyTop])); + yyVal = support.newCaseInNode(((SourceIndexLength)yyVals[-4+yyTop]), ((ParseNode)yyVals[-3+yyTop]), ((InParseNode)yyVals[-1+yyTop])); return yyVal; }; states[350] = (support, lexer, yyVal, yyVals, yyTop) -> { @@ -2737,7 +2815,7 @@ public Object yyparse (RubyLexer yyLex) { return yyVal; }; states[381] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = ((ParseNode)yyVals[0+yyTop]); + yyVal = ((ParseNode)yyVals[0+yyTop]) == null ? NilImplicitParseNode.NIL : ((ParseNode)yyVals[0+yyTop]); return yyVal; }; states[383] = (support, lexer, yyVal, yyVals, yyTop) -> yyVal; @@ -3100,549 +3178,967 @@ public Object yyparse (RubyLexer yyLex) { return yyVal; }; states[466] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = support.newInNode(((SourceIndexLength)yyVals[-4+yyTop]), ((ParseNode)yyVals[-3+yyTop]), ((ParseNode)yyVals[-1+yyTop]), ((ParseNode)yyVals[0+yyTop])); + lexer.setState(EXPR_BEG|EXPR_LABEL); + lexer.commandStart = false; + /* Lexcontext object is not used in favour of lexer.inKwarg*/ + /* LexContext ctxt = (LexContext) lexer.getLexContext();*/ + yyVals[0+yyTop] = lexer.inKwarg; + lexer.inKwarg = true; + yyVal = support.push_pvtbl(); return yyVal; }; -states[469] = (support, lexer, yyVal, yyVals, yyTop) -> { - ParseNode node; - if (((ParseNode)yyVals[-3+yyTop]) != null) { - node = support.appendToBlock(support.node_assign(((ParseNode)yyVals[-3+yyTop]), new GlobalVarParseNode(((SourceIndexLength)yyVals[-5+yyTop]), support.symbolID(TStringConstants.DOLLAR_BANG))), ((ParseNode)yyVals[-1+yyTop])); - if (((ParseNode)yyVals[-1+yyTop]) != null) { - node.extendPosition(((SourceIndexLength)yyVals[-5+yyTop])); - } - } else { - node = ((ParseNode)yyVals[-1+yyTop]); - } - ParseNode body = support.makeNullNil(node); - yyVal = new RescueBodyParseNode(((SourceIndexLength)yyVals[-5+yyTop]), ((ParseNode)yyVals[-4+yyTop]), body, ((RescueBodyParseNode)yyVals[0+yyTop])); +states[467] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = support.push_pktbl(); /* after in*/ return yyVal; }; -states[470] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = null; +states[468] = (support, lexer, yyVal, yyVals, yyTop) -> { + support.pop_pktbl(((Set)yyVals[-2+yyTop])); + support.pop_pvtbl(((Set)yyVals[-3+yyTop])); + lexer.inKwarg = ((Boolean)yyVals[-4+yyTop]); + return yyVal; +}; +states[469] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = support.newInNode(support.getPosition(yyVals[-7+yyTop]), ((ParseNode)yyVals[-4+yyTop]), ((ParseNode)yyVals[-1+yyTop]), ((ParseNode)yyVals[0+yyTop])); return yyVal; }; states[471] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = support.newArrayNode(((ParseNode)yyVals[0+yyTop]).getPosition(), ((ParseNode)yyVals[0+yyTop])); + yyVal = ((InParseNode)yyVals[0+yyTop]); return yyVal; }; -states[472] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = support.splat_array(((ParseNode)yyVals[0+yyTop])); - if (yyVal == null) yyVal = ((ParseNode)yyVals[0+yyTop]); /* ArgsCat or ArgsPush*/ +states[473] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = new IfParseNode(support.getPosition(((ParseNode)yyVals[-2+yyTop])), support.getConditionNode(((ParseNode)yyVals[0+yyTop])), ((ParseNode)yyVals[-2+yyTop]), null); + ((ParseNode)yyVal).extendPosition(((ParseNode)yyVals[0+yyTop])); return yyVal; }; states[474] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = ((ParseNode)yyVals[0+yyTop]); + yyVal = new IfParseNode(support.getPosition(((ParseNode)yyVals[-2+yyTop])), support.getConditionNode(((ParseNode)yyVals[0+yyTop])), null, ((ParseNode)yyVals[-2+yyTop])); + ((ParseNode)yyVal).extendPosition(((ParseNode)yyVals[0+yyTop])); return yyVal; }; states[476] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = ((ParseNode)yyVals[0+yyTop]); + yyVal = support.new_array_pattern(support.getPosition(((ParseNode)yyVals[-1+yyTop])), null, ((ParseNode)yyVals[-1+yyTop]), + support.new_array_pattern_tail(support.getPosition(((ParseNode)yyVals[-1+yyTop])), null, true, null, null)); + return yyVal; +}; +states[477] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = support.new_array_pattern(support.getPosition(((ParseNode)yyVals[-2+yyTop])), null, ((ParseNode)yyVals[-2+yyTop]), ((ArrayPatternParseNode)yyVals[0+yyTop])); + /* the following line is a no-op. May or many not require an impl*/ + support.nd_set_first_loc(((ParseNode)yyVal), support.getPosition(((ParseNode)yyVals[-2+yyTop]))); return yyVal; }; states[478] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = ((NumericParseNode)yyVals[0+yyTop]); + yyVal = support.new_find_pattern(null, ((FindPatternParseNode)yyVals[0+yyTop])); return yyVal; }; states[479] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = support.asSymbol(lexer.getPosition(), ((TruffleString)yyVals[0+yyTop])); + yyVal = support.new_array_pattern(support.getPosition(((ArrayPatternParseNode)yyVals[0+yyTop])), null, null, ((ArrayPatternParseNode)yyVals[0+yyTop])); return yyVal; }; -states[481] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = ((ParseNode)yyVals[0+yyTop]) instanceof EvStrParseNode ? new DStrParseNode(((ParseNode)yyVals[0+yyTop]).getPosition(), lexer.getEncoding()).add(((ParseNode)yyVals[0+yyTop])) : ((ParseNode)yyVals[0+yyTop]); - /* - NODE *node = $1; - if (!node) { - node = NEW_STR(STR_NEW0()); - } else { - node = evstr2dstr(node); - } - $$ = node; - */ +states[480] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = support.new_hash_pattern(null, ((HashPatternParseNode)yyVals[0+yyTop])); /* new_hash_pattern*/ return yyVal; }; states[482] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = ((StrParseNode)yyVals[0+yyTop]); - return yyVal; -}; -states[483] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = ((ParseNode)yyVals[0+yyTop]); + yyVal = new HashParseNode(support.getPosition(((ParseNode)yyVals[-2+yyTop])), new ParseNodeTuple(((ParseNode)yyVals[-2+yyTop]), ((ParseNode)yyVals[0+yyTop]))); /* p_as*/ return yyVal; }; states[484] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = support.literal_concat(((ParseNode)yyVals[-1+yyTop]), ((ParseNode)yyVals[0+yyTop])); - return yyVal; -}; -states[485] = (support, lexer, yyVal, yyVals, yyTop) -> { - lexer.heredoc_dedent(((ParseNode)yyVals[-1+yyTop])); - lexer.setHeredocIndent(0); - yyVal = ((ParseNode)yyVals[-1+yyTop]); + yyVal = support.newOrNode(support.getPosition(((ParseNode)yyVals[-2+yyTop])), ((ParseNode)yyVals[-2+yyTop]), ((ParseNode)yyVals[0+yyTop])); return yyVal; }; states[486] = (support, lexer, yyVal, yyVals, yyTop) -> { - SourceIndexLength position = support.getPosition(((ParseNode)yyVals[-1+yyTop])); - - lexer.heredoc_dedent(((ParseNode)yyVals[-1+yyTop])); - lexer.setHeredocIndent(0); - - if (((ParseNode)yyVals[-1+yyTop]) == null) { - yyVal = new XStrParseNode(position, null); - } else if (((ParseNode)yyVals[-1+yyTop]) instanceof StrParseNode) { - yyVal = new XStrParseNode(position, ((StrParseNode)yyVals[-1+yyTop])); - } else if (((ParseNode)yyVals[-1+yyTop]) instanceof DStrParseNode) { - yyVal = new DXStrParseNode(position, ((DStrParseNode)yyVals[-1+yyTop])); - } else { - yyVal = new DXStrParseNode(position).add(((ParseNode)yyVals[-1+yyTop])); - } + yyVal = support.push_pktbl(); return yyVal; }; states[487] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = support.newRegexpNode(support.getPosition(((ParseNode)yyVals[-1+yyTop])), ((ParseNode)yyVals[-1+yyTop]), ((RegexpParseNode)yyVals[0+yyTop])); - return yyVal; -}; -states[488] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = ((ListParseNode)yyVals[-1+yyTop]); - return yyVal; -}; -states[489] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = new ArrayParseNode(lexer.getPosition()); + yyVal = support.push_pktbl(); return yyVal; }; states[490] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = ((ListParseNode)yyVals[-2+yyTop]).add(((ParseNode)yyVals[-1+yyTop]) instanceof EvStrParseNode ? new DStrParseNode(((ListParseNode)yyVals[-2+yyTop]).getPosition(), lexer.getEncoding()).add(((ParseNode)yyVals[-1+yyTop])) : ((ParseNode)yyVals[-1+yyTop])); + support.pop_pktbl(((Set)yyVals[-2+yyTop])); + yyVal = support.new_array_pattern(support.getPosition(((ParseNode)yyVals[-3+yyTop])), ((ParseNode)yyVals[-3+yyTop]), null, ((ArrayPatternParseNode)yyVals[-1+yyTop])); + support.nd_set_first_loc(((ParseNode)yyVal), support.getPosition(((ParseNode)yyVals[-3+yyTop]))); return yyVal; }; states[491] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = ((ParseNode)yyVals[0+yyTop]); + support.pop_pktbl(((Set)yyVals[-2+yyTop])); + yyVal = support.new_find_pattern(((ParseNode)yyVals[-3+yyTop]), ((FindPatternParseNode)yyVals[-1+yyTop])); + support.nd_set_first_loc(((ParseNode)yyVal), support.getPosition(((ParseNode)yyVals[-3+yyTop]))); return yyVal; }; states[492] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = support.literal_concat(((ParseNode)yyVals[-1+yyTop]), ((ParseNode)yyVals[0+yyTop])); + support.pop_pktbl(((Set)yyVals[-2+yyTop])); + yyVal = support.new_hash_pattern(((ParseNode)yyVals[-3+yyTop]), ((HashPatternParseNode)yyVals[-1+yyTop])); + support.nd_set_first_loc(((ParseNode)yyVal), support.getPosition(((ParseNode)yyVals[-3+yyTop]))); return yyVal; }; states[493] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = ((ListParseNode)yyVals[-1+yyTop]); + yyVal = support.new_array_pattern(support.getPosition(((ParseNode)yyVals[-2+yyTop])), ((ParseNode)yyVals[-2+yyTop]), null, + support.new_array_pattern_tail(support.getPosition(((ParseNode)yyVals[-2+yyTop])), null, false, null, null)); return yyVal; }; states[494] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = new ArrayParseNode(lexer.getPosition()); + support.pop_pktbl(((Set)yyVals[-2+yyTop])); + yyVal = support.new_array_pattern(support.getPosition(((ParseNode)yyVals[-3+yyTop])), ((ParseNode)yyVals[-3+yyTop]), null, ((ArrayPatternParseNode)yyVals[-1+yyTop])); + support.nd_set_first_loc(((ParseNode)yyVal), support.getPosition(((ParseNode)yyVals[-3+yyTop]))); return yyVal; }; states[495] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = ((ListParseNode)yyVals[-2+yyTop]).add(((ParseNode)yyVals[-1+yyTop]) instanceof EvStrParseNode ? new DSymbolParseNode(((ListParseNode)yyVals[-2+yyTop]).getPosition()).add(((ParseNode)yyVals[-1+yyTop])) : support.asSymbol(((ListParseNode)yyVals[-2+yyTop]).getPosition(), ((ParseNode)yyVals[-1+yyTop]))); + support.pop_pktbl(((Set)yyVals[-2+yyTop])); + yyVal = support.new_find_pattern(((ParseNode)yyVals[-3+yyTop]), ((FindPatternParseNode)yyVals[-1+yyTop])); + support.nd_set_first_loc(((ParseNode)yyVal), support.getPosition(((ParseNode)yyVals[-3+yyTop]))); return yyVal; }; states[496] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = ((ListParseNode)yyVals[-1+yyTop]); + support.pop_pktbl(((Set)yyVals[-2+yyTop])); + yyVal = support.new_hash_pattern(((ParseNode)yyVals[-3+yyTop]), ((HashPatternParseNode)yyVals[-1+yyTop])); + support.nd_set_first_loc(((ParseNode)yyVal), support.getPosition(((ParseNode)yyVals[-3+yyTop]))); return yyVal; }; states[497] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = ((ListParseNode)yyVals[-1+yyTop]); + yyVal = support.new_array_pattern(support.getPosition(((ParseNode)yyVals[-2+yyTop])), ((ParseNode)yyVals[-2+yyTop]), null, + support.new_array_pattern_tail(support.getPosition(((ParseNode)yyVals[-2+yyTop])), null, false, null, null)); return yyVal; }; states[498] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = new ArrayParseNode(lexer.getPosition()); + yyVal = support.new_array_pattern(support.getPosition(((TruffleString)yyVals[-2+yyTop])), null, null, ((ArrayPatternParseNode)yyVals[-1+yyTop])); return yyVal; }; states[499] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = ((ListParseNode)yyVals[-2+yyTop]).add(((ParseNode)yyVals[-1+yyTop])); + yyVal = support.new_find_pattern(null, ((FindPatternParseNode)yyVals[-1+yyTop])); return yyVal; }; states[500] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = new ArrayParseNode(lexer.getPosition()); + yyVal = support.new_array_pattern(support.getPosition(((TruffleString)yyVals[-1+yyTop])), null, null, + support.new_array_pattern_tail(support.getPosition(((TruffleString)yyVals[-1+yyTop])), null, false, null, null)); return yyVal; }; states[501] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = ((ListParseNode)yyVals[-2+yyTop]).add(support.asSymbol(((ListParseNode)yyVals[-2+yyTop]).getPosition(), ((ParseNode)yyVals[-1+yyTop]))); + yyVal = support.push_pktbl(); /* p_expr_basic last production*/ + yyVals[0+yyTop] = lexer.inKwarg; + lexer.inKwarg = false; return yyVal; }; states[502] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = lexer.createStr(lexer.encoding.tencoding.getEmpty(), lexer.encoding, 0); + support.pop_pktbl(((Set)yyVals[-2+yyTop])); /* p_expr_basic last production 1*/ + lexer.inKwarg = ((Boolean)yyVals[-3+yyTop]); + yyVal = support.new_hash_pattern(null, ((HashPatternParseNode)yyVals[-1+yyTop])); return yyVal; }; states[503] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = support.literal_concat(((ParseNode)yyVals[-1+yyTop]), ((ParseNode)yyVals[0+yyTop])); + yyVal = support.new_hash_pattern(null, support.new_hash_pattern_tail(support.getPosition(yyVals[-1+yyTop]), null, null)); return yyVal; }; states[504] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = null; + yyVal = support.push_pktbl(); return yyVal; }; states[505] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = support.literal_concat(((ParseNode)yyVals[-1+yyTop]), ((ParseNode)yyVals[0+yyTop])); + support.pop_pktbl(((Set)yyVals[-2+yyTop])); + yyVal = ((ParseNode)yyVals[-1+yyTop]); return yyVal; }; states[506] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = null; + ListParseNode preArgs = support.newArrayNode(support.getPosition(((ParseNode)yyVals[0+yyTop])), ((ParseNode)yyVals[0+yyTop])); /* p_expr*/ + yyVal = support.new_array_pattern_tail(support.getPosition(((ParseNode)yyVals[0+yyTop])), preArgs, false, null, null); return yyVal; }; states[507] = (support, lexer, yyVal, yyVals, yyTop) -> { - /* FIXME: mri is different here.*/ - yyVal = support.literal_concat(((ParseNode)yyVals[-1+yyTop]), ((ParseNode)yyVals[0+yyTop])); + yyVal = support.new_array_pattern_tail(support.getPosition(((ListParseNode)yyVals[0+yyTop])), ((ListParseNode)yyVals[0+yyTop]), true, null, null); return yyVal; }; states[508] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = ((ParseNode)yyVals[0+yyTop]); + yyVal = support.new_array_pattern_tail(support.getPosition(((ListParseNode)yyVals[-1+yyTop])), support.list_concat(((ListParseNode)yyVals[-1+yyTop]), ((ListParseNode)yyVals[0+yyTop])), false, null, null); return yyVal; }; states[509] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = lexer.getStrTerm(); - lexer.setStrTerm(null); - lexer.setState(EXPR_BEG); + yyVal = support.new_array_pattern_tail(support.getPosition(((ListParseNode)yyVals[-2+yyTop])), ((ListParseNode)yyVals[-2+yyTop]), true, ((TruffleString)yyVals[0+yyTop]), null); return yyVal; }; states[510] = (support, lexer, yyVal, yyVals, yyTop) -> { - lexer.setStrTerm(((StrTerm)yyVals[-1+yyTop])); - yyVal = new EvStrParseNode(support.getPosition(((ParseNode)yyVals[0+yyTop])), ((ParseNode)yyVals[0+yyTop])); + yyVal = support.new_array_pattern_tail(support.getPosition(((ListParseNode)yyVals[-4+yyTop])), ((ListParseNode)yyVals[-4+yyTop]), true, ((TruffleString)yyVals[-2+yyTop]), ((ListParseNode)yyVals[0+yyTop])); return yyVal; }; states[511] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = lexer.getStrTerm(); - lexer.setStrTerm(null); - lexer.getConditionState().stop(); + yyVal = support.new_array_pattern_tail(support.getPosition(((ListParseNode)yyVals[-1+yyTop])), ((ListParseNode)yyVals[-1+yyTop]), true, null, null); return yyVal; }; states[512] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = lexer.getCmdArgumentState().getStack(); - lexer.getCmdArgumentState().reset(); + yyVal = support.new_array_pattern_tail(support.getPosition(((ListParseNode)yyVals[-3+yyTop])), ((ListParseNode)yyVals[-3+yyTop]), true, null, ((ListParseNode)yyVals[0+yyTop])); return yyVal; }; states[513] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = lexer.getState(); - lexer.setState(EXPR_BEG); + yyVal = ((ArrayPatternParseNode)yyVals[0+yyTop]); return yyVal; }; states[514] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = lexer.getBraceNest(); - lexer.setBraceNest(0); + yyVal = ((ListParseNode)yyVals[-1+yyTop]); return yyVal; }; states[515] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = lexer.getHeredocIndent(); - lexer.setHeredocIndent(0); + yyVal = support.list_concat(((ListParseNode)yyVals[-2+yyTop]), ((ListParseNode)yyVals[-1+yyTop])); return yyVal; }; states[516] = (support, lexer, yyVal, yyVals, yyTop) -> { - lexer.getConditionState().restart(); - lexer.setStrTerm(((StrTerm)yyVals[-6+yyTop])); - lexer.getCmdArgumentState().reset(((Long)yyVals[-5+yyTop]).longValue()); - lexer.setState(((Integer)yyVals[-4+yyTop])); - lexer.setBraceNest(((Integer)yyVals[-3+yyTop])); - lexer.setHeredocIndent(((Integer)yyVals[-2+yyTop])); - lexer.setHeredocLineIndent(-1); - - yyVal = support.newEvStrNode(support.getPosition(((ParseNode)yyVals[-1+yyTop])), ((ParseNode)yyVals[-1+yyTop])); + yyVal = support.new_array_pattern_tail(support.getPosition(((TruffleString)yyVals[0+yyTop])), null, true, ((TruffleString)yyVals[0+yyTop]), null); /* p_args_tail*/ return yyVal; }; states[517] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = new GlobalVarParseNode(lexer.getPosition(), support.symbolID(((TruffleString)yyVals[0+yyTop]))); + yyVal = support.new_array_pattern_tail(support.getPosition(((TruffleString)yyVals[-2+yyTop])), null, true, ((TruffleString)yyVals[-2+yyTop]), ((ListParseNode)yyVals[0+yyTop])); /* p_args_tail_2*/ return yyVal; }; states[518] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = new InstVarParseNode(lexer.getPosition(), support.symbolID(((TruffleString)yyVals[0+yyTop]))); + yyVal = support.new_find_pattern_tail(support.getPosition(((TruffleString)yyVals[-4+yyTop])), ((TruffleString)yyVals[-4+yyTop]), ((ListParseNode)yyVals[-2+yyTop]), ((TruffleString)yyVals[0+yyTop])); /* p_find*/ + support.warn(support.getPosition(((TruffleString)yyVals[-4+yyTop])), "Find pattern is experimental, and the behavior may change in future versions of Ruby!"); return yyVal; }; states[519] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = new ClassVarParseNode(lexer.getPosition(), support.symbolID(((TruffleString)yyVals[0+yyTop]))); + yyVal = ((TruffleString)yyVals[0+yyTop]); /* p_rest*/ return yyVal; }; -states[521] = (support, lexer, yyVal, yyVals, yyTop) -> { - lexer.setState(EXPR_END|EXPR_ENDARG); - yyVal = ((TruffleString)yyVals[0+yyTop]); +states[520] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = null; /* p_rest_2*/ + return yyVal; +}; +states[522] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = support.list_concat(((ListParseNode)yyVals[-2+yyTop]), ((ListParseNode)yyVals[0+yyTop])); /* p_args_post*/ return yyVal; }; states[523] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = ((TruffleString)yyVals[0+yyTop]); + yyVal = support.newArrayNode(((ParseNode)yyVals[0+yyTop]).getPosition(), ((ParseNode)yyVals[0+yyTop])); /* p_arg*/ return yyVal; }; states[524] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = ((TruffleString)yyVals[0+yyTop]); + yyVal = support.new_hash_pattern_tail(support.getPosition(((HashParseNode)yyVals[-2+yyTop])), ((HashParseNode)yyVals[-2+yyTop]), ((TruffleString)yyVals[0+yyTop])); /* p_kwargs_1*/ return yyVal; }; states[525] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = ((TruffleString)yyVals[0+yyTop]); + yyVal = support.new_hash_pattern_tail(support.getPosition(((HashParseNode)yyVals[0+yyTop])), ((HashParseNode)yyVals[0+yyTop]), null); /* p_kwargs_2*/ return yyVal; }; states[526] = (support, lexer, yyVal, yyVals, yyTop) -> { - lexer.setState(EXPR_END|EXPR_ENDARG); - - /* DStrNode: :"some text #{some expression}"*/ - /* StrNode: :"some text"*/ - /* EvStrNode :"#{some expression}"*/ - /* Ruby 1.9 allows empty strings as symbols*/ - if (((ParseNode)yyVals[-1+yyTop]) == null) { - yyVal = support.asSymbol(lexer.getPosition(), TStringConstants.EMPTY_US_ASCII); - } else if (((ParseNode)yyVals[-1+yyTop]) instanceof DStrParseNode) { - yyVal = new DSymbolParseNode(((ParseNode)yyVals[-1+yyTop]).getPosition(), ((DStrParseNode)yyVals[-1+yyTop])); - } else if (((ParseNode)yyVals[-1+yyTop]) instanceof StrParseNode) { - yyVal = support.asSymbol(((ParseNode)yyVals[-1+yyTop]).getPosition(), ((ParseNode)yyVals[-1+yyTop])); - } else { - yyVal = new DSymbolParseNode(((ParseNode)yyVals[-1+yyTop]).getPosition()); - ((DSymbolParseNode)yyVal).add(((ParseNode)yyVals[-1+yyTop])); - } + yyVal = support.new_hash_pattern_tail(support.getPosition(((HashParseNode)yyVals[-1+yyTop])), ((HashParseNode)yyVals[-1+yyTop]), null); /* p_kwargs_3*/ return yyVal; }; states[527] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = ((NumericParseNode)yyVals[0+yyTop]); + yyVal = support.new_hash_pattern_tail(support.getPosition(((TruffleString)yyVals[0+yyTop])), null, ((TruffleString)yyVals[0+yyTop])); /* p_kwargs_4*/ return yyVal; }; states[528] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = support.negateNumeric(((NumericParseNode)yyVals[0+yyTop])); + yyVal = new HashParseNode(support.getPosition(((ParseNodeTuple)yyVals[0+yyTop])), ((ParseNodeTuple)yyVals[0+yyTop])); /* p_kwarg*/ return yyVal; }; states[529] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = ((ParseNode)yyVals[0+yyTop]); + ((HashParseNode)yyVals[-2+yyTop]).add(((ParseNodeTuple)yyVals[0+yyTop])); /* p_kwarg 2*/ + yyVal = ((HashParseNode)yyVals[-2+yyTop]); return yyVal; }; states[530] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = ((FloatParseNode)yyVals[0+yyTop]); + support.error_duplicate_pattern_key(((TruffleString)yyVals[-1+yyTop])); /* p_kw.*/ + + ParseNode label = support.asSymbol(support.getPosition(((TruffleString)yyVals[-1+yyTop])), ((TruffleString)yyVals[-1+yyTop])); + + yyVal = new ParseNodeTuple(label, ((ParseNode)yyVals[0+yyTop])); return yyVal; }; states[531] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = ((RationalParseNode)yyVals[0+yyTop]); - return yyVal; -}; -states[532] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = ((ParseNode)yyVals[0+yyTop]); + support.error_duplicate_pattern_key(((TruffleString)yyVals[0+yyTop])); /* p_kw_label.*/ + if (((TruffleString)yyVals[0+yyTop]) != null && !support.is_local_id(((TruffleString)yyVals[0+yyTop]))) { + support.yyerror("key must be valid as local variables"); + } + support.error_duplicate_pattern_variable(((TruffleString)yyVals[0+yyTop])); + + ParseNode label = support.asSymbol(support.getPosition(((TruffleString)yyVals[0+yyTop])), ((TruffleString)yyVals[0+yyTop])); + yyVal = new ParseNodeTuple(label, support.assignableLabelOrIdentifier(((TruffleString)yyVals[0+yyTop]), null)); return yyVal; }; states[533] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = support.declareIdentifier(((TruffleString)yyVals[0+yyTop])); + if (((ParseNode)yyVals[-1+yyTop]) == null || ((ParseNode)yyVals[-1+yyTop]) instanceof StrParseNode) { + yyVal = ((StrParseNode)yyVals[-1+yyTop]).getValue(); + } else { + support.yyerror("symbol literal with interpolation is not allowed"); + yyVal = null; + } return yyVal; }; states[534] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = new InstVarParseNode(lexer.tokline, support.symbolID(((TruffleString)yyVals[0+yyTop]))); + yyVal = ((TruffleString)yyVals[0+yyTop]); return yyVal; }; states[535] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = new GlobalVarParseNode(lexer.tokline, support.symbolID(((TruffleString)yyVals[0+yyTop]))); + yyVal = null; return yyVal; }; states[536] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = new ConstParseNode(lexer.tokline, support.symbolID(((TruffleString)yyVals[0+yyTop]))); - return yyVal; -}; -states[537] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = new ClassVarParseNode(lexer.tokline, support.symbolID(((TruffleString)yyVals[0+yyTop]))); + yyVal = null; return yyVal; }; states[538] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = new NilParseNode(lexer.tokline); - return yyVal; -}; -states[539] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = new SelfParseNode(lexer.tokline); + yyVal = ParserSupport.KWNOREST; return yyVal; }; states[540] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = new TrueParseNode((SourceIndexLength) yyVal); + ParserSupport.value_expr(lexer, ((ParseNode)yyVals[-2+yyTop])); + ParserSupport.value_expr(lexer, ((ParseNode)yyVals[0+yyTop])); + boolean isLiteral = ((ParseNode)yyVals[-2+yyTop]) instanceof FixnumParseNode && ((ParseNode)yyVals[0+yyTop]) instanceof FixnumParseNode; + yyVal = new DotParseNode(support.getPosition(((ParseNode)yyVals[-2+yyTop])), support.makeNullNil(((ParseNode)yyVals[-2+yyTop])), support.makeNullNil(((ParseNode)yyVals[0+yyTop])), false, isLiteral); return yyVal; }; states[541] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = new FalseParseNode((SourceIndexLength) yyVal); + ParserSupport.value_expr(lexer, ((ParseNode)yyVals[-2+yyTop])); + ParserSupport.value_expr(lexer, ((ParseNode)yyVals[0+yyTop])); + boolean isLiteral = ((ParseNode)yyVals[-2+yyTop]) instanceof FixnumParseNode && ((ParseNode)yyVals[0+yyTop]) instanceof FixnumParseNode; + yyVal = new DotParseNode(support.getPosition(((ParseNode)yyVals[-2+yyTop])), support.makeNullNil(((ParseNode)yyVals[-2+yyTop])), support.makeNullNil(((ParseNode)yyVals[0+yyTop])), true, isLiteral); return yyVal; }; states[542] = (support, lexer, yyVal, yyVals, yyTop) -> { - RubyEncoding encoding = support.getConfiguration().getContext() == null ? Encodings.UTF_8 : support.getConfiguration().getContext().getEncodingManager().getLocaleEncoding(); - yyVal = new FileParseNode(lexer.tokline, TStringUtils.fromJavaString(lexer.getFile(), encoding), encoding); + ParserSupport.value_expr(lexer, ((ParseNode)yyVals[-1+yyTop])); + boolean isLiteral = ((ParseNode)yyVals[-1+yyTop]) instanceof FixnumParseNode; + yyVal = new DotParseNode(support.getPosition(((ParseNode)yyVals[-1+yyTop])), support.makeNullNil(((ParseNode)yyVals[-1+yyTop])), NilImplicitParseNode.NIL, false, isLiteral); return yyVal; }; states[543] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = new FixnumParseNode(lexer.tokline, lexer.tokline.toSourceSection(lexer.getSource()).getStartLine() + lexer.getLineOffset()); - return yyVal; -}; -states[544] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = new EncodingParseNode(lexer.tokline, lexer.getEncoding()); - return yyVal; -}; -states[545] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = support.assignableLabelOrIdentifier(((TruffleString)yyVals[0+yyTop]), null); - return yyVal; -}; -states[546] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = new InstAsgnParseNode(lexer.tokline, support.symbolID(((TruffleString)yyVals[0+yyTop])), NilImplicitParseNode.NIL); + ParserSupport.value_expr(lexer, ((ParseNode)yyVals[-1+yyTop])); + boolean isLiteral = ((ParseNode)yyVals[-1+yyTop]) instanceof FixnumParseNode; + yyVal = new DotParseNode(support.getPosition(((ParseNode)yyVals[-1+yyTop])), support.makeNullNil(((ParseNode)yyVals[-1+yyTop])), NilImplicitParseNode.NIL, true, isLiteral); return yyVal; }; states[547] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = new GlobalAsgnParseNode(lexer.tokline, support.symbolID(((TruffleString)yyVals[0+yyTop])), NilImplicitParseNode.NIL); + ParserSupport.value_expr(lexer, ((ParseNode)yyVals[0+yyTop])); + boolean isLiteral = ((ParseNode)yyVals[0+yyTop]) instanceof FixnumParseNode; + yyVal = new DotParseNode(support.getPosition(((TruffleString)yyVals[-1+yyTop])), NilImplicitParseNode.NIL, support.makeNullNil(((ParseNode)yyVals[0+yyTop])), false, isLiteral); return yyVal; }; states[548] = (support, lexer, yyVal, yyVals, yyTop) -> { - if (support.isInDef()) support.compile_error("dynamic constant assignment"); - - yyVal = new ConstDeclParseNode(lexer.tokline, support.symbolID(((TruffleString)yyVals[0+yyTop])), null, NilImplicitParseNode.NIL); - return yyVal; -}; -states[549] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = new ClassVarAsgnParseNode(lexer.tokline, support.symbolID(((TruffleString)yyVals[0+yyTop])), NilImplicitParseNode.NIL); - return yyVal; -}; -states[550] = (support, lexer, yyVal, yyVals, yyTop) -> { - support.compile_error("Can't assign to nil"); - yyVal = null; - return yyVal; -}; -states[551] = (support, lexer, yyVal, yyVals, yyTop) -> { - support.compile_error("Can't change the value of self"); - yyVal = null; - return yyVal; -}; -states[552] = (support, lexer, yyVal, yyVals, yyTop) -> { - support.compile_error("Can't assign to true"); - yyVal = null; + ParserSupport.value_expr(lexer, ((ParseNode)yyVals[0+yyTop])); + boolean isLiteral = ((ParseNode)yyVals[0+yyTop]) instanceof FixnumParseNode; + yyVal = new DotParseNode(support.getPosition(((TruffleString)yyVals[-1+yyTop])), NilImplicitParseNode.NIL, support.makeNullNil(((ParseNode)yyVals[0+yyTop])), true, isLiteral); return yyVal; }; states[553] = (support, lexer, yyVal, yyVals, yyTop) -> { - support.compile_error("Can't assign to false"); - yyVal = null; + yyVal = ((ParseNode)yyVals[0+yyTop]); return yyVal; }; states[554] = (support, lexer, yyVal, yyVals, yyTop) -> { - support.compile_error("Can't assign to __FILE__"); - yyVal = null; + yyVal = ((ParseNode)yyVals[0+yyTop]); return yyVal; }; states[555] = (support, lexer, yyVal, yyVals, yyTop) -> { - support.compile_error("Can't assign to __LINE__"); - yyVal = null; + yyVal = ((ListParseNode)yyVals[0+yyTop]); return yyVal; }; states[556] = (support, lexer, yyVal, yyVals, yyTop) -> { - support.compile_error("Can't assign to __ENCODING__"); - yyVal = null; + yyVal = ((ListParseNode)yyVals[0+yyTop]); return yyVal; }; states[557] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = ((ParseNode)yyVals[0+yyTop]); + yyVal = new NilParseNode(lexer.tokline); return yyVal; }; states[558] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = ((ParseNode)yyVals[0+yyTop]); + yyVal = new SelfParseNode(lexer.tokline); return yyVal; }; states[559] = (support, lexer, yyVal, yyVals, yyTop) -> { - lexer.setState(EXPR_BEG); - lexer.commandStart = true; + yyVal = new TrueParseNode(lexer.tokline); return yyVal; }; states[560] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = ((ParseNode)yyVals[-1+yyTop]); + yyVal = new FalseParseNode(lexer.tokline); return yyVal; }; states[561] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = null; + /* TODO: make a helper for this since it is used twice now*/ + Encoding encoding = support.getConfiguration().getContext() == null ? UTF8Encoding.INSTANCE : support.getConfiguration().getContext().getEncodingManager().getLocaleEncoding().jcoding; + yyVal = new FileParseNode(lexer.getPosition(), TruffleString.fromByteArrayUncached(lexer.getFile().getBytes(), lexer.tencoding , true), lexer.encoding); return yyVal; }; states[562] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = ((ArgsParseNode)yyVals[-1+yyTop]); - lexer.setState(EXPR_BEG); - lexer.commandStart = true; + yyVal = new FixnumParseNode(lexer.tokline, lexer.getRubySourceLine()); return yyVal; }; states[563] = (support, lexer, yyVal, yyVals, yyTop) -> { - yyVal = lexer.inKwarg; - lexer.inKwarg = true; - lexer.setState(lexer.getState() | EXPR_LABEL); + yyVal = new EncodingParseNode(lexer.tokline, lexer.getEncoding()); return yyVal; }; states[564] = (support, lexer, yyVal, yyVals, yyTop) -> { - lexer.inKwarg = ((Boolean)yyVals[-2+yyTop]); - yyVal = ((ArgsParseNode)yyVals[-1+yyTop]); - lexer.setState(EXPR_BEG); - lexer.commandStart = true; + yyVal = ((LambdaParseNode)yyVals[0+yyTop]); return yyVal; }; states[565] = (support, lexer, yyVal, yyVals, yyTop) -> { + support.error_duplicate_pattern_variable(((TruffleString)yyVals[0+yyTop])); + yyVal = support.assignableInCurr(((TruffleString)yyVals[0+yyTop]), null); + return yyVal; +}; +states[566] = (support, lexer, yyVal, yyVals, yyTop) -> { + ParseNode n = support.gettable(((TruffleString)yyVals[0+yyTop])); + if (!(n instanceof LocalVarParseNode || n instanceof DVarParseNode)) { + support.compile_error("" + ((TruffleString)yyVals[0+yyTop]) + ": no such local variable"); + } + yyVal = n; + return yyVal; +}; +states[567] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = support.gettable(((TruffleString)yyVals[0+yyTop])); + if (yyVal == null) yyVal = new BeginParseNode(lexer.tokline, NilImplicitParseNode.NIL); + return yyVal; +}; +states[568] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = new BeginParseNode(lexer.tokline, ((ParseNode)yyVals[-1+yyTop])); + return yyVal; +}; +states[569] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = support.new_colon3(lexer.tokline, ((TruffleString)yyVals[0+yyTop])); + return yyVal; +}; +states[570] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = support.new_colon2(lexer.tokline, ((ParseNode)yyVals[-2+yyTop]), ((TruffleString)yyVals[0+yyTop])); + return yyVal; +}; +states[571] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = new ConstParseNode(lexer.tokline, support.symbolID(((TruffleString)yyVals[0+yyTop]))); + return yyVal; +}; +states[572] = (support, lexer, yyVal, yyVals, yyTop) -> { + ParseNode node; + if (((ParseNode)yyVals[-3+yyTop]) != null) { + node = support.appendToBlock(support.node_assign(((ParseNode)yyVals[-3+yyTop]), new GlobalVarParseNode(((SourceIndexLength)yyVals[-5+yyTop]), support.symbolID(TStringConstants.DOLLAR_BANG))), ((ParseNode)yyVals[-1+yyTop])); + if (((ParseNode)yyVals[-1+yyTop]) != null) { + node.extendPosition(((SourceIndexLength)yyVals[-5+yyTop])); + } + } else { + node = ((ParseNode)yyVals[-1+yyTop]); + } + ParseNode body = support.makeNullNil(node); + yyVal = new RescueBodyParseNode(((SourceIndexLength)yyVals[-5+yyTop]), ((ParseNode)yyVals[-4+yyTop]), body, ((RescueBodyParseNode)yyVals[0+yyTop])); + return yyVal; +}; +states[573] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = null; + return yyVal; +}; +states[574] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = support.newArrayNode(((ParseNode)yyVals[0+yyTop]).getPosition(), ((ParseNode)yyVals[0+yyTop])); + return yyVal; +}; +states[575] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = support.splat_array(((ParseNode)yyVals[0+yyTop])); + if (yyVal == null) yyVal = ((ParseNode)yyVals[0+yyTop]); /* ArgsCat or ArgsPush*/ + return yyVal; +}; +states[577] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = ((ParseNode)yyVals[0+yyTop]); + return yyVal; +}; +states[579] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = ((ParseNode)yyVals[0+yyTop]); + return yyVal; +}; +states[581] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = ((NumericParseNode)yyVals[0+yyTop]); + return yyVal; +}; +states[582] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = support.asSymbol(lexer.getPosition(), ((TruffleString)yyVals[0+yyTop])); + return yyVal; +}; +states[584] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = ((ParseNode)yyVals[0+yyTop]) instanceof EvStrParseNode ? new DStrParseNode(((ParseNode)yyVals[0+yyTop]).getPosition(), lexer.getEncoding()).add(((ParseNode)yyVals[0+yyTop])) : ((ParseNode)yyVals[0+yyTop]); + /* + NODE *node = $1; + if (!node) { + node = NEW_STR(STR_NEW0()); + } else { + node = evstr2dstr(node); + } + $$ = node; + */ + return yyVal; +}; +states[585] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = ((StrParseNode)yyVals[0+yyTop]); + return yyVal; +}; +states[586] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = ((ParseNode)yyVals[0+yyTop]); + return yyVal; +}; +states[587] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = support.literal_concat(((ParseNode)yyVals[-1+yyTop]), ((ParseNode)yyVals[0+yyTop])); + return yyVal; +}; +states[588] = (support, lexer, yyVal, yyVals, yyTop) -> { + lexer.heredoc_dedent(((ParseNode)yyVals[-1+yyTop])); + lexer.setHeredocIndent(0); + yyVal = ((ParseNode)yyVals[-1+yyTop]); + return yyVal; +}; +states[589] = (support, lexer, yyVal, yyVals, yyTop) -> { + SourceIndexLength position = support.getPosition(((ParseNode)yyVals[-1+yyTop])); + + lexer.heredoc_dedent(((ParseNode)yyVals[-1+yyTop])); + lexer.setHeredocIndent(0); + + if (((ParseNode)yyVals[-1+yyTop]) == null) { + yyVal = new XStrParseNode(position, null); + } else if (((ParseNode)yyVals[-1+yyTop]) instanceof StrParseNode) { + yyVal = new XStrParseNode(position, ((StrParseNode)yyVals[-1+yyTop])); + } else if (((ParseNode)yyVals[-1+yyTop]) instanceof DStrParseNode) { + yyVal = new DXStrParseNode(position, ((DStrParseNode)yyVals[-1+yyTop])); + } else { + yyVal = new DXStrParseNode(position).add(((ParseNode)yyVals[-1+yyTop])); + } + return yyVal; +}; +states[590] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = support.newRegexpNode(support.getPosition(((ParseNode)yyVals[-1+yyTop])), ((ParseNode)yyVals[-1+yyTop]), ((RegexpParseNode)yyVals[0+yyTop])); + return yyVal; +}; +states[591] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = ((ListParseNode)yyVals[-1+yyTop]); + return yyVal; +}; +states[592] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = new ArrayParseNode(lexer.getPosition()); + return yyVal; +}; +states[593] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = ((ListParseNode)yyVals[-2+yyTop]).add(((ParseNode)yyVals[-1+yyTop]) instanceof EvStrParseNode ? new DStrParseNode(((ListParseNode)yyVals[-2+yyTop]).getPosition(), lexer.getEncoding()).add(((ParseNode)yyVals[-1+yyTop])) : ((ParseNode)yyVals[-1+yyTop])); + return yyVal; +}; +states[594] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = yyVals[0+yyTop]; + return yyVal; +}; +states[595] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = support.literal_concat(((ParseNode)yyVals[-1+yyTop]), ((ParseNode)yyVals[0+yyTop])); + return yyVal; +}; +states[596] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = ((ListParseNode)yyVals[-1+yyTop]); + return yyVal; +}; +states[597] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = new ArrayParseNode(lexer.getPosition()); + return yyVal; +}; +states[598] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = ((ListParseNode)yyVals[-2+yyTop]).add(((ParseNode)yyVals[-1+yyTop]) instanceof EvStrParseNode ? new DSymbolParseNode(((ListParseNode)yyVals[-2+yyTop]).getPosition()).add(((ParseNode)yyVals[-1+yyTop])) : support.asSymbol(((ListParseNode)yyVals[-2+yyTop]).getPosition(), ((ParseNode)yyVals[-1+yyTop]))); + return yyVal; +}; +states[599] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = ((ListParseNode)yyVals[-1+yyTop]); + return yyVal; +}; +states[600] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = ((ListParseNode)yyVals[-1+yyTop]); + return yyVal; +}; +states[601] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = new ArrayParseNode(lexer.getPosition()); + return yyVal; +}; +states[602] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = ((ListParseNode)yyVals[-2+yyTop]).add(((ParseNode)yyVals[-1+yyTop])); + return yyVal; +}; +states[603] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = new ArrayParseNode(lexer.getPosition()); + return yyVal; +}; +states[604] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = ((ListParseNode)yyVals[-2+yyTop]).add(support.asSymbol(((ListParseNode)yyVals[-2+yyTop]).getPosition(), ((ParseNode)yyVals[-1+yyTop]))); + return yyVal; +}; +states[605] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = lexer.createStr(lexer.encoding.tencoding.getEmpty(), lexer.encoding, 0); + return yyVal; +}; +states[606] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = support.literal_concat(((ParseNode)yyVals[-1+yyTop]), ((ParseNode)yyVals[0+yyTop])); + return yyVal; +}; +states[607] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = null; + return yyVal; +}; +states[608] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = support.literal_concat(((ParseNode)yyVals[-1+yyTop]), ((ParseNode)yyVals[0+yyTop])); + return yyVal; +}; +states[609] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = null; + return yyVal; +}; +states[610] = (support, lexer, yyVal, yyVals, yyTop) -> { + /* FIXME: mri is different here.*/ + yyVal = support.literal_concat(((ParseNode)yyVals[-1+yyTop]), ((ParseNode)yyVals[0+yyTop])); + return yyVal; +}; +states[611] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = ((ParseNode)yyVals[0+yyTop]); + return yyVal; +}; +states[612] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = lexer.getStrTerm(); + lexer.setStrTerm(null); + lexer.setState(EXPR_BEG); + return yyVal; +}; +states[613] = (support, lexer, yyVal, yyVals, yyTop) -> { + lexer.setStrTerm(((StrTerm)yyVals[-1+yyTop])); + yyVal = new EvStrParseNode(support.getPosition(((ParseNode)yyVals[0+yyTop])), ((ParseNode)yyVals[0+yyTop])); + return yyVal; +}; +states[614] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = lexer.getStrTerm(); + lexer.setStrTerm(null); + lexer.getConditionState().stop(); + return yyVal; +}; +states[615] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = lexer.getCmdArgumentState().getStack(); + lexer.getCmdArgumentState().reset(); + return yyVal; +}; +states[616] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = lexer.getState(); + lexer.setState(EXPR_BEG); + return yyVal; +}; +states[617] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = lexer.getBraceNest(); + lexer.setBraceNest(0); + return yyVal; +}; +states[618] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = lexer.getHeredocIndent(); + lexer.setHeredocIndent(0); + return yyVal; +}; +states[619] = (support, lexer, yyVal, yyVals, yyTop) -> { + lexer.getConditionState().restart(); + lexer.setStrTerm(((StrTerm)yyVals[-6+yyTop])); + lexer.getCmdArgumentState().reset(((Long)yyVals[-5+yyTop]).longValue()); + lexer.setState(((Integer)yyVals[-4+yyTop])); + lexer.setBraceNest(((Integer)yyVals[-3+yyTop])); + lexer.setHeredocIndent(((Integer)yyVals[-2+yyTop])); + lexer.setHeredocLineIndent(-1); + + yyVal = support.newEvStrNode(support.getPosition(((ParseNode)yyVals[-1+yyTop])), ((ParseNode)yyVals[-1+yyTop])); + return yyVal; +}; +states[620] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = new GlobalVarParseNode(lexer.getPosition(), support.symbolID(((TruffleString)yyVals[0+yyTop]))); + return yyVal; +}; +states[621] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = new InstVarParseNode(lexer.getPosition(), support.symbolID(((TruffleString)yyVals[0+yyTop]))); + return yyVal; +}; +states[622] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = new ClassVarParseNode(lexer.getPosition(), support.symbolID(((TruffleString)yyVals[0+yyTop]))); + return yyVal; +}; +states[624] = (support, lexer, yyVal, yyVals, yyTop) -> { + lexer.setState(EXPR_END|EXPR_ENDARG); + yyVal = ((TruffleString)yyVals[0+yyTop]); + return yyVal; +}; +states[626] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = ((TruffleString)yyVals[0+yyTop]); + return yyVal; +}; +states[627] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = ((TruffleString)yyVals[0+yyTop]); + return yyVal; +}; +states[628] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = ((TruffleString)yyVals[0+yyTop]); + return yyVal; +}; +states[629] = (support, lexer, yyVal, yyVals, yyTop) -> { + lexer.setState(EXPR_END|EXPR_ENDARG); + + /* DStrNode: :"some text #{some expression}"*/ + /* StrNode: :"some text"*/ + /* EvStrNode :"#{some expression}"*/ + /* Ruby 1.9 allows empty strings as symbols*/ + if (((ParseNode)yyVals[-1+yyTop]) == null) { + yyVal = support.asSymbol(lexer.getPosition(), TStringConstants.EMPTY_US_ASCII); + } else if (((ParseNode)yyVals[-1+yyTop]) instanceof DStrParseNode) { + yyVal = new DSymbolParseNode(((ParseNode)yyVals[-1+yyTop]).getPosition(), ((DStrParseNode)yyVals[-1+yyTop])); + } else if (((ParseNode)yyVals[-1+yyTop]) instanceof StrParseNode) { + yyVal = support.asSymbol(((ParseNode)yyVals[-1+yyTop]).getPosition(), ((ParseNode)yyVals[-1+yyTop])); + } else { + yyVal = new DSymbolParseNode(((ParseNode)yyVals[-1+yyTop]).getPosition()); + ((DSymbolParseNode)yyVal).add(((ParseNode)yyVals[-1+yyTop])); + } + return yyVal; +}; +states[630] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = ((NumericParseNode)yyVals[0+yyTop]); + return yyVal; +}; +states[631] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = support.negateNumeric(((NumericParseNode)yyVals[0+yyTop])); + return yyVal; +}; +states[635] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = ((ParseNode)yyVals[0+yyTop]); + return yyVal; +}; +states[636] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = ((FloatParseNode)yyVals[0+yyTop]); + return yyVal; +}; +states[637] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = ((RationalParseNode)yyVals[0+yyTop]); + return yyVal; +}; +states[638] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = ((ParseNode)yyVals[0+yyTop]); + return yyVal; +}; +states[639] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = support.declareIdentifier(((TruffleString)yyVals[0+yyTop])); + return yyVal; +}; +states[640] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = new InstVarParseNode(lexer.tokline, support.symbolID(((TruffleString)yyVals[0+yyTop]))); + return yyVal; +}; +states[641] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = new GlobalVarParseNode(lexer.tokline, support.symbolID(((TruffleString)yyVals[0+yyTop]))); + return yyVal; +}; +states[642] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = new ConstParseNode(lexer.tokline, support.symbolID(((TruffleString)yyVals[0+yyTop]))); + return yyVal; +}; +states[643] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = new ClassVarParseNode(lexer.tokline, support.symbolID(((TruffleString)yyVals[0+yyTop]))); + return yyVal; +}; +states[644] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = new NilParseNode(lexer.tokline); + return yyVal; +}; +states[645] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = new SelfParseNode(lexer.tokline); + return yyVal; +}; +states[646] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = new TrueParseNode((SourceIndexLength) yyVal); + return yyVal; +}; +states[647] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = new FalseParseNode((SourceIndexLength) yyVal); + return yyVal; +}; +states[648] = (support, lexer, yyVal, yyVals, yyTop) -> { + RubyEncoding encoding = support.getConfiguration().getContext() == null ? Encodings.UTF_8 : support.getConfiguration().getContext().getEncodingManager().getLocaleEncoding(); + yyVal = new FileParseNode(lexer.tokline, TStringUtils.fromJavaString(lexer.getFile(), encoding), encoding); + return yyVal; +}; +states[649] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = new FixnumParseNode(lexer.tokline, lexer.tokline.toSourceSection(lexer.getSource()).getStartLine() + lexer.getLineOffset()); + return yyVal; +}; +states[650] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = new EncodingParseNode(lexer.tokline, lexer.getEncoding()); + return yyVal; +}; +states[651] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = support.assignableLabelOrIdentifier(((TruffleString)yyVals[0+yyTop]), null); + return yyVal; +}; +states[652] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = new InstAsgnParseNode(lexer.tokline, support.symbolID(((TruffleString)yyVals[0+yyTop])), NilImplicitParseNode.NIL); + return yyVal; +}; +states[653] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = new GlobalAsgnParseNode(lexer.tokline, support.symbolID(((TruffleString)yyVals[0+yyTop])), NilImplicitParseNode.NIL); + return yyVal; +}; +states[654] = (support, lexer, yyVal, yyVals, yyTop) -> { + if (support.isInDef()) support.compile_error("dynamic constant assignment"); + + yyVal = new ConstDeclParseNode(lexer.tokline, support.symbolID(((TruffleString)yyVals[0+yyTop])), null, NilImplicitParseNode.NIL); + return yyVal; +}; +states[655] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = new ClassVarAsgnParseNode(lexer.tokline, support.symbolID(((TruffleString)yyVals[0+yyTop])), NilImplicitParseNode.NIL); + return yyVal; +}; +states[656] = (support, lexer, yyVal, yyVals, yyTop) -> { + support.compile_error("Can't assign to nil"); + yyVal = null; + return yyVal; +}; +states[657] = (support, lexer, yyVal, yyVals, yyTop) -> { + support.compile_error("Can't change the value of self"); + yyVal = null; + return yyVal; +}; +states[658] = (support, lexer, yyVal, yyVals, yyTop) -> { + support.compile_error("Can't assign to true"); + yyVal = null; + return yyVal; +}; +states[659] = (support, lexer, yyVal, yyVals, yyTop) -> { + support.compile_error("Can't assign to false"); + yyVal = null; + return yyVal; +}; +states[660] = (support, lexer, yyVal, yyVals, yyTop) -> { + support.compile_error("Can't assign to __FILE__"); + yyVal = null; + return yyVal; +}; +states[661] = (support, lexer, yyVal, yyVals, yyTop) -> { + support.compile_error("Can't assign to __LINE__"); + yyVal = null; + return yyVal; +}; +states[662] = (support, lexer, yyVal, yyVals, yyTop) -> { + support.compile_error("Can't assign to __ENCODING__"); + yyVal = null; + return yyVal; +}; +states[663] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = ((ParseNode)yyVals[0+yyTop]); + return yyVal; +}; +states[664] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = ((ParseNode)yyVals[0+yyTop]); + return yyVal; +}; +states[665] = (support, lexer, yyVal, yyVals, yyTop) -> { + lexer.setState(EXPR_BEG); + lexer.commandStart = true; + return yyVal; +}; +states[666] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = ((ParseNode)yyVals[-1+yyTop]); + return yyVal; +}; +states[667] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = null; + return yyVal; +}; +states[668] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = ((ArgsParseNode)yyVals[-1+yyTop]); + lexer.setState(EXPR_BEG); + lexer.commandStart = true; + return yyVal; +}; +states[669] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = lexer.inKwarg; + lexer.inKwarg = true; + lexer.setState(lexer.getState() | EXPR_LABEL); + return yyVal; +}; +states[670] = (support, lexer, yyVal, yyVals, yyTop) -> { + lexer.inKwarg = ((Boolean)yyVals[-2+yyTop]); + yyVal = ((ArgsParseNode)yyVals[-1+yyTop]); + lexer.setState(EXPR_BEG); + lexer.commandStart = true; + return yyVal; +}; +states[671] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = support.new_args_tail(((ListParseNode)yyVals[-3+yyTop]).getPosition(), ((ListParseNode)yyVals[-3+yyTop]), ((TruffleString)yyVals[-1+yyTop]), ((BlockArgParseNode)yyVals[0+yyTop])); return yyVal; }; -states[566] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[672] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = support.new_args_tail(((ListParseNode)yyVals[-1+yyTop]).getPosition(), ((ListParseNode)yyVals[-1+yyTop]), (TruffleString) null, ((BlockArgParseNode)yyVals[0+yyTop])); return yyVal; }; -states[567] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[673] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = support.new_args_tail(lexer.getPosition(), null, ((TruffleString)yyVals[-1+yyTop]), ((BlockArgParseNode)yyVals[0+yyTop])); return yyVal; }; -states[568] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[674] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = support.new_args_tail(lexer.getPosition(), null, RubyLexer.Keyword.NIL.bytes, ((BlockArgParseNode)yyVals[0+yyTop])); return yyVal; }; -states[569] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[675] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = support.new_args_tail(((BlockArgParseNode)yyVals[0+yyTop]).getPosition(), null, (TruffleString) null, ((BlockArgParseNode)yyVals[0+yyTop])); return yyVal; }; -states[570] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[676] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = ((ArgsTailHolder)yyVals[0+yyTop]); return yyVal; }; -states[571] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[677] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = support.new_args_tail(lexer.getPosition(), null, (TruffleString) null, null); return yyVal; }; -states[572] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[678] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = ((ArgsParseNode)yyVals[0+yyTop]); return yyVal; }; -states[573] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[679] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = support.new_args(lexer.getPosition(), null, null, null, null, (ArgsTailHolder) null); return yyVal; }; -states[574] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[680] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = support.new_args(((ListParseNode)yyVals[-5+yyTop]).getPosition(), ((ListParseNode)yyVals[-5+yyTop]), ((ListParseNode)yyVals[-3+yyTop]), ((RestArgParseNode)yyVals[-1+yyTop]), null, ((ArgsTailHolder)yyVals[0+yyTop])); return yyVal; }; -states[575] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[681] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = support.new_args(((ListParseNode)yyVals[-7+yyTop]).getPosition(), ((ListParseNode)yyVals[-7+yyTop]), ((ListParseNode)yyVals[-5+yyTop]), ((RestArgParseNode)yyVals[-3+yyTop]), ((ListParseNode)yyVals[-1+yyTop]), ((ArgsTailHolder)yyVals[0+yyTop])); return yyVal; }; -states[576] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[682] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = support.new_args(((ListParseNode)yyVals[-3+yyTop]).getPosition(), ((ListParseNode)yyVals[-3+yyTop]), ((ListParseNode)yyVals[-1+yyTop]), null, null, ((ArgsTailHolder)yyVals[0+yyTop])); return yyVal; }; -states[577] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[683] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = support.new_args(((ListParseNode)yyVals[-5+yyTop]).getPosition(), ((ListParseNode)yyVals[-5+yyTop]), ((ListParseNode)yyVals[-3+yyTop]), null, ((ListParseNode)yyVals[-1+yyTop]), ((ArgsTailHolder)yyVals[0+yyTop])); return yyVal; }; -states[578] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[684] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = support.new_args(((ListParseNode)yyVals[-3+yyTop]).getPosition(), ((ListParseNode)yyVals[-3+yyTop]), null, ((RestArgParseNode)yyVals[-1+yyTop]), null, ((ArgsTailHolder)yyVals[0+yyTop])); return yyVal; }; -states[579] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[685] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = support.new_args(((ListParseNode)yyVals[-5+yyTop]).getPosition(), ((ListParseNode)yyVals[-5+yyTop]), null, ((RestArgParseNode)yyVals[-3+yyTop]), ((ListParseNode)yyVals[-1+yyTop]), ((ArgsTailHolder)yyVals[0+yyTop])); return yyVal; }; -states[580] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[686] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = support.new_args(((ListParseNode)yyVals[-1+yyTop]).getPosition(), ((ListParseNode)yyVals[-1+yyTop]), null, null, null, ((ArgsTailHolder)yyVals[0+yyTop])); return yyVal; }; -states[581] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[687] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = support.new_args(((ListParseNode)yyVals[-3+yyTop]).getPosition(), null, ((ListParseNode)yyVals[-3+yyTop]), ((RestArgParseNode)yyVals[-1+yyTop]), null, ((ArgsTailHolder)yyVals[0+yyTop])); return yyVal; }; -states[582] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[688] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = support.new_args(((ListParseNode)yyVals[-5+yyTop]).getPosition(), null, ((ListParseNode)yyVals[-5+yyTop]), ((RestArgParseNode)yyVals[-3+yyTop]), ((ListParseNode)yyVals[-1+yyTop]), ((ArgsTailHolder)yyVals[0+yyTop])); return yyVal; }; -states[583] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[689] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = support.new_args(((ListParseNode)yyVals[-1+yyTop]).getPosition(), null, ((ListParseNode)yyVals[-1+yyTop]), null, null, ((ArgsTailHolder)yyVals[0+yyTop])); return yyVal; }; -states[584] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[690] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = support.new_args(((ListParseNode)yyVals[-3+yyTop]).getPosition(), null, ((ListParseNode)yyVals[-3+yyTop]), null, ((ListParseNode)yyVals[-1+yyTop]), ((ArgsTailHolder)yyVals[0+yyTop])); return yyVal; }; -states[585] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[691] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = support.new_args(((RestArgParseNode)yyVals[-1+yyTop]).getPosition(), null, null, ((RestArgParseNode)yyVals[-1+yyTop]), null, ((ArgsTailHolder)yyVals[0+yyTop])); return yyVal; }; -states[586] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[692] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = support.new_args(((RestArgParseNode)yyVals[-3+yyTop]).getPosition(), null, null, ((RestArgParseNode)yyVals[-3+yyTop]), ((ListParseNode)yyVals[-1+yyTop]), ((ArgsTailHolder)yyVals[0+yyTop])); return yyVal; }; -states[587] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[693] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = support.new_args(((ArgsTailHolder)yyVals[0+yyTop]).getPosition(), null, null, null, null, ((ArgsTailHolder)yyVals[0+yyTop])); return yyVal; }; -states[588] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[694] = (support, lexer, yyVal, yyVals, yyTop) -> { SourceIndexLength position = support.getPosition(null); RestArgParseNode splat = new RestArgParseNode(position, ParserSupport.FORWARD_ARGS_REST_VAR, 0); BlockArgParseNode block = new BlockArgParseNode(position, 1, ParserSupport.FORWARD_ARGS_BLOCK_VAR); @@ -3650,7 +4146,7 @@ public Object yyparse (RubyLexer yyLex) { yyVal = support.new_args(position, ((ListParseNode)yyVals[-2+yyTop]), null, splat, null, argsTail); return yyVal; }; -states[589] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[695] = (support, lexer, yyVal, yyVals, yyTop) -> { SourceIndexLength position = support.getPosition(null); RestArgParseNode splat = new RestArgParseNode(position, ParserSupport.FORWARD_ARGS_REST_VAR, 0); BlockArgParseNode block = new BlockArgParseNode(position, 1, ParserSupport.FORWARD_ARGS_BLOCK_VAR); @@ -3658,41 +4154,41 @@ public Object yyparse (RubyLexer yyLex) { yyVal = support.new_args(position, null, null, splat, null, argsTail); return yyVal; }; -states[591] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[697] = (support, lexer, yyVal, yyVals, yyTop) -> { support.yyerror("formal argument cannot be a constant"); return yyVal; }; -states[592] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[698] = (support, lexer, yyVal, yyVals, yyTop) -> { support.yyerror("formal argument cannot be an instance variable"); return yyVal; }; -states[593] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[699] = (support, lexer, yyVal, yyVals, yyTop) -> { support.yyerror("formal argument cannot be a global variable"); return yyVal; }; -states[594] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[700] = (support, lexer, yyVal, yyVals, yyTop) -> { support.yyerror("formal argument cannot be a class variable"); return yyVal; }; -states[595] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[701] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = ((TruffleString)yyVals[0+yyTop]); /* Not really reached*/ return yyVal; }; -states[596] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[702] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = support.formal_argument(((TruffleString)yyVals[0+yyTop])); return yyVal; }; -states[597] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[703] = (support, lexer, yyVal, yyVals, yyTop) -> { lexer.setCurrentArg(((TruffleString)yyVals[0+yyTop])); yyVal = support.arg_var(((TruffleString)yyVals[0+yyTop])); return yyVal; }; -states[598] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[704] = (support, lexer, yyVal, yyVals, yyTop) -> { lexer.setCurrentArg(null); yyVal = ((ArgumentParseNode)yyVals[0+yyTop]); return yyVal; }; -states[599] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[705] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = ((ParseNode)yyVals[-1+yyTop]); /* { ID tid = internal_id(); @@ -3707,107 +4203,107 @@ public Object yyparse (RubyLexer yyLex) { $$->nd_next = $2;*/ return yyVal; }; -states[600] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[706] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = new ArrayParseNode(lexer.getPosition(), ((ParseNode)yyVals[0+yyTop])); return yyVal; }; -states[601] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[707] = (support, lexer, yyVal, yyVals, yyTop) -> { ((ListParseNode)yyVals[-2+yyTop]).add(((ParseNode)yyVals[0+yyTop])); yyVal = ((ListParseNode)yyVals[-2+yyTop]); return yyVal; }; -states[602] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[708] = (support, lexer, yyVal, yyVals, yyTop) -> { support.arg_var(support.formal_argument(((TruffleString)yyVals[0+yyTop]))); lexer.setCurrentArg(((TruffleString)yyVals[0+yyTop])); yyVal = ((TruffleString)yyVals[0+yyTop]); return yyVal; }; -states[603] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[709] = (support, lexer, yyVal, yyVals, yyTop) -> { lexer.setCurrentArg(null); yyVal = support.keyword_arg(((ParseNode)yyVals[0+yyTop]).getPosition(), support.assignableKeyword(((TruffleString)yyVals[-1+yyTop]), ((ParseNode)yyVals[0+yyTop]))); return yyVal; }; -states[604] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[710] = (support, lexer, yyVal, yyVals, yyTop) -> { lexer.setCurrentArg(null); yyVal = support.keyword_arg(lexer.getPosition(), support.assignableKeyword(((TruffleString)yyVals[0+yyTop]), RequiredKeywordArgumentValueParseNode.INSTANCE)); return yyVal; }; -states[605] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[711] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = support.keyword_arg(support.getPosition(((ParseNode)yyVals[0+yyTop])), support.assignableKeyword(((TruffleString)yyVals[-1+yyTop]), ((ParseNode)yyVals[0+yyTop]))); return yyVal; }; -states[606] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[712] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = support.keyword_arg(lexer.getPosition(), support.assignableKeyword(((TruffleString)yyVals[0+yyTop]), RequiredKeywordArgumentValueParseNode.INSTANCE)); return yyVal; }; -states[607] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[713] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = new ArrayParseNode(((ParseNode)yyVals[0+yyTop]).getPosition(), ((ParseNode)yyVals[0+yyTop])); return yyVal; }; -states[608] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[714] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = ((ListParseNode)yyVals[-2+yyTop]).add(((ParseNode)yyVals[0+yyTop])); return yyVal; }; -states[609] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[715] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = new ArrayParseNode(((ParseNode)yyVals[0+yyTop]).getPosition(), ((ParseNode)yyVals[0+yyTop])); return yyVal; }; -states[610] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[716] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = ((ListParseNode)yyVals[-2+yyTop]).add(((ParseNode)yyVals[0+yyTop])); return yyVal; }; -states[611] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[717] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = ((TruffleString)yyVals[0+yyTop]); return yyVal; }; -states[612] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[718] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = ((TruffleString)yyVals[0+yyTop]); return yyVal; }; -states[614] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[720] = (support, lexer, yyVal, yyVals, yyTop) -> { support.shadowing_lvar(((TruffleString)yyVals[0+yyTop])); yyVal = ((TruffleString)yyVals[0+yyTop]); return yyVal; }; -states[615] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[721] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = ParserSupport.INTERNAL_ID; return yyVal; }; -states[616] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[722] = (support, lexer, yyVal, yyVals, yyTop) -> { lexer.setCurrentArg(null); yyVal = new OptArgParseNode(support.getPosition(((ParseNode)yyVals[0+yyTop])), support.assignableLabelOrIdentifier(((ArgumentParseNode)yyVals[-2+yyTop]).getName(), ((ParseNode)yyVals[0+yyTop]))); return yyVal; }; -states[617] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[723] = (support, lexer, yyVal, yyVals, yyTop) -> { lexer.setCurrentArg(null); yyVal = new OptArgParseNode(support.getPosition(((ParseNode)yyVals[0+yyTop])), support.assignableLabelOrIdentifier(((ArgumentParseNode)yyVals[-2+yyTop]).getName(), ((ParseNode)yyVals[0+yyTop]))); return yyVal; }; -states[618] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[724] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = new BlockParseNode(((ParseNode)yyVals[0+yyTop]).getPosition()).add(((ParseNode)yyVals[0+yyTop])); return yyVal; }; -states[619] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[725] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = support.appendToBlock(((ListParseNode)yyVals[-2+yyTop]), ((ParseNode)yyVals[0+yyTop])); return yyVal; }; -states[620] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[726] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = new BlockParseNode(((ParseNode)yyVals[0+yyTop]).getPosition()).add(((ParseNode)yyVals[0+yyTop])); return yyVal; }; -states[621] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[727] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = support.appendToBlock(((ListParseNode)yyVals[-2+yyTop]), ((ParseNode)yyVals[0+yyTop])); return yyVal; }; -states[622] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[728] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = ((TruffleString)yyVals[0+yyTop]); return yyVal; }; -states[623] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[729] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = ((TruffleString)yyVals[0+yyTop]); return yyVal; }; -states[624] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[730] = (support, lexer, yyVal, yyVals, yyTop) -> { if (!support.is_local_id(((TruffleString)yyVals[0+yyTop]))) { support.yyerror("rest argument must be local variable"); } @@ -3815,20 +4311,20 @@ public Object yyparse (RubyLexer yyLex) { yyVal = new RestArgParseNode(support.arg_var(support.shadowing_lvar(((TruffleString)yyVals[0+yyTop])))); return yyVal; }; -states[625] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[731] = (support, lexer, yyVal, yyVals, yyTop) -> { /* FIXME: bytelist_love: somewhat silly to remake the empty bytelist over and over but this type should change (using null vs "" is a strange distinction).*/ yyVal = new UnnamedRestArgParseNode(lexer.getPosition(), Layouts.TEMP_PREFIX + "unnamed_rest", support.getCurrentScope().addVariable("*"), true); return yyVal; }; -states[626] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[732] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = ((TruffleString)yyVals[0+yyTop]); return yyVal; }; -states[627] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[733] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = ((TruffleString)yyVals[0+yyTop]); return yyVal; }; -states[628] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[734] = (support, lexer, yyVal, yyVals, yyTop) -> { if (!support.is_local_id(((TruffleString)yyVals[0+yyTop]))) { support.yyerror("block argument must be local variable"); } @@ -3836,28 +4332,28 @@ public Object yyparse (RubyLexer yyLex) { yyVal = new BlockArgParseNode(support.arg_var(support.shadowing_lvar(((TruffleString)yyVals[0+yyTop])))); return yyVal; }; -states[629] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[735] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = new BlockArgParseNode(support.arg_var(support.shadowing_lvar(ParserSupport.FORWARD_ARGS_BLOCK_VAR_TSTRING))); return yyVal; }; -states[630] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[736] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = ((BlockArgParseNode)yyVals[0+yyTop]); return yyVal; }; -states[631] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[737] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = null; return yyVal; }; -states[632] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[738] = (support, lexer, yyVal, yyVals, yyTop) -> { value_expr(lexer, ((ParseNode)yyVals[0+yyTop])); yyVal = ((ParseNode)yyVals[0+yyTop]); return yyVal; }; -states[633] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[739] = (support, lexer, yyVal, yyVals, yyTop) -> { lexer.setState(EXPR_BEG); return yyVal; }; -states[634] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[740] = (support, lexer, yyVal, yyVals, yyTop) -> { if (((ParseNode)yyVals[-1+yyTop]) == null) { support.yyerror("can't define single method for ()."); } else if (((ParseNode)yyVals[-1+yyTop]) instanceof ILiteralNode) { @@ -3867,38 +4363,38 @@ public Object yyparse (RubyLexer yyLex) { yyVal = ((ParseNode)yyVals[-1+yyTop]); return yyVal; }; -states[635] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[741] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = new HashParseNode(lexer.getPosition()); return yyVal; }; -states[636] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[742] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = support.remove_duplicate_keys(((HashParseNode)yyVals[-1+yyTop])); return yyVal; }; -states[637] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[743] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = new HashParseNode(lexer.getPosition(), ((ParseNodeTuple)yyVals[0+yyTop])); return yyVal; }; -states[638] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[744] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = ((HashParseNode)yyVals[-2+yyTop]).add(((ParseNodeTuple)yyVals[0+yyTop])); return yyVal; }; -states[639] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[745] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = support.createKeyValue(((ParseNode)yyVals[-2+yyTop]), ((ParseNode)yyVals[0+yyTop])); return yyVal; }; -states[640] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[746] = (support, lexer, yyVal, yyVals, yyTop) -> { ParseNode label = support.asSymbol(support.getPosition(((ParseNode)yyVals[0+yyTop])), ((TruffleString)yyVals[-1+yyTop])); yyVal = support.createKeyValue(label, ((ParseNode)yyVals[0+yyTop])); return yyVal; }; -states[641] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[747] = (support, lexer, yyVal, yyVals, yyTop) -> { ParseNode val = support.declareIdentifier(((TruffleString)yyVals[0+yyTop])); ParseNode label = support.asSymbol(support.getPosition(null), ((TruffleString)yyVals[0+yyTop])); yyVal = support.createKeyValue(label, val); return yyVal; }; -states[642] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[748] = (support, lexer, yyVal, yyVals, yyTop) -> { if (((ParseNode)yyVals[-2+yyTop]) instanceof StrParseNode) { DStrParseNode dnode = new DStrParseNode(support.getPosition(((ParseNode)yyVals[-2+yyTop])), lexer.getEncoding()); dnode.add(((ParseNode)yyVals[-2+yyTop])); @@ -3911,88 +4407,92 @@ public Object yyparse (RubyLexer yyLex) { return yyVal; }; -states[643] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[749] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = support.createKeyValue(null, ((ParseNode)yyVals[0+yyTop])); return yyVal; }; -states[644] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[750] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = ((TruffleString)yyVals[0+yyTop]); return yyVal; }; -states[645] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[751] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = ((TruffleString)yyVals[0+yyTop]); return yyVal; }; -states[646] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[752] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = ((TruffleString)yyVals[0+yyTop]); return yyVal; }; -states[647] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[753] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = ((TruffleString)yyVals[0+yyTop]); return yyVal; }; -states[648] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[754] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = ((TruffleString)yyVals[0+yyTop]); return yyVal; }; -states[649] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[755] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = ((TruffleString)yyVals[0+yyTop]); return yyVal; }; -states[650] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[756] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = ((TruffleString)yyVals[0+yyTop]); return yyVal; }; -states[651] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[757] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = ((TruffleString)yyVals[0+yyTop]); return yyVal; }; -states[652] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[758] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = ((TruffleString)yyVals[0+yyTop]); return yyVal; }; -states[653] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[759] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = ((TruffleString)yyVals[0+yyTop]); return yyVal; }; -states[654] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[760] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = ((TruffleString)yyVals[0+yyTop]); return yyVal; }; -states[655] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[761] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = ((TruffleString)yyVals[0+yyTop]); return yyVal; }; -states[656] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[762] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = ((TruffleString)yyVals[0+yyTop]); return yyVal; }; -states[657] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[763] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = ((TruffleString)yyVals[0+yyTop]); return yyVal; }; -states[659] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[765] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = ((TruffleString)yyVals[0+yyTop]); return yyVal; }; -states[664] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[770] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = ((TruffleString)yyVals[0+yyTop]); return yyVal; }; -states[665] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[771] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = ((TruffleString)yyVals[0+yyTop]); return yyVal; }; -states[673] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[772] = (support, lexer, yyVal, yyVals, yyTop) -> { + yyVal = TStringConstants.RCURLY; + return yyVal; +}; +states[780] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = null; return yyVal; }; -states[674] = (support, lexer, yyVal, yyVals, yyTop) -> { +states[781] = (support, lexer, yyVal, yyVals, yyTop) -> { yyVal = null; return yyVal; }; } -// line 2838 "RubyParser.y" +// line 3249 "RubyParser.y" /** The parse method use an lexer stream and parse it to an AST node * structure @@ -4002,11 +4502,11 @@ public RubyParserResult parse(ParserConfiguration configuration) { support.setConfiguration(configuration); support.setResult(new RubyParserResult()); - yyparse(lexer, null); + yyparse(lexer, new org.truffleruby.parser.parser.YYDebug()); return support.getResult(); } } // CheckStyle: stop generated // @formatter:on -// line 10943 "-" +// line 12094 "-" diff --git a/src/main/java/org/truffleruby/parser/parser/RubyParser.y b/src/main/java/org/truffleruby/parser/parser/RubyParser.y index b9878c9ea09e..b729b4530ff7 100644 --- a/src/main/java/org/truffleruby/parser/parser/RubyParser.y +++ b/src/main/java/org/truffleruby/parser/parser/RubyParser.y @@ -3,6 +3,10 @@ package org.truffleruby.parser.parser; import com.oracle.truffle.api.strings.TruffleString; +import java.util.Set; +import org.jcodings.Encoding; +import org.jcodings.specific.UTF8Encoding; + import org.truffleruby.Layouts; import org.truffleruby.annotations.SuppressFBWarnings; import org.truffleruby.core.encoding.Encodings; @@ -14,6 +18,7 @@ import org.truffleruby.parser.RubyDeferredWarnings; import org.truffleruby.parser.ast.ArgsParseNode; import org.truffleruby.parser.ast.ArgumentParseNode; import org.truffleruby.parser.ast.ArrayParseNode; +import org.truffleruby.parser.ast.ArrayPatternParseNode; import org.truffleruby.parser.ast.AssignableParseNode; import org.truffleruby.parser.ast.BackRefParseNode; import org.truffleruby.parser.ast.BeginParseNode; @@ -34,19 +39,23 @@ import org.truffleruby.parser.ast.DXStrParseNode; import org.truffleruby.parser.ast.DefnParseNode; import org.truffleruby.parser.ast.DefsParseNode; import org.truffleruby.parser.ast.DotParseNode; +import org.truffleruby.parser.ast.DVarParseNode; import org.truffleruby.parser.ast.EncodingParseNode; import org.truffleruby.parser.ast.EnsureParseNode; import org.truffleruby.parser.ast.EvStrParseNode; import org.truffleruby.parser.ast.FCallParseNode; import org.truffleruby.parser.ast.FalseParseNode; import org.truffleruby.parser.ast.FileParseNode; +import org.truffleruby.parser.ast.FindPatternParseNode; import org.truffleruby.parser.ast.FixnumParseNode; import org.truffleruby.parser.ast.FloatParseNode; import org.truffleruby.parser.ast.ForParseNode; import org.truffleruby.parser.ast.GlobalAsgnParseNode; import org.truffleruby.parser.ast.GlobalVarParseNode; import org.truffleruby.parser.ast.HashParseNode; +import org.truffleruby.parser.ast.HashPatternParseNode; import org.truffleruby.parser.ast.IfParseNode; +import org.truffleruby.parser.ast.InParseNode; import org.truffleruby.parser.ast.InstAsgnParseNode; import org.truffleruby.parser.ast.InstVarParseNode; import org.truffleruby.parser.ast.IterParseNode; @@ -124,7 +133,7 @@ public class RubyParser { keyword_begin keyword_rescue keyword_ensure keyword_end keyword_if keyword_unless keyword_then keyword_elsif keyword_else keyword_case keyword_when keyword_while keyword_until keyword_for keyword_break - keyword_next keyword_redo keyword_retry keyword_in keyword_do + keyword_next keyword_redo keyword_retry keyword_do keyword_do_cond keyword_do_block keyword_return keyword_yield keyword_super keyword_self keyword_nil keyword_true keyword_false keyword_and keyword_or keyword_not modifier_if modifier_unless modifier_while modifier_until @@ -164,7 +173,7 @@ public class RubyParser { %token tLPAREN_ARG /* ( */ %token tLBRACK /* [ */ %token tRBRACK /* ] */ -%token tLBRACE /* { */ +%token tLBRACE /* { */ %token tLBRACE_ARG /* { */ %token tSTAR /* * */ %token tSTAR2 /* * Is just '*' in ruby and not a token */ @@ -209,7 +218,7 @@ public class RubyParser { %type string_dvar backref %type f_args f_args_any f_larglist block_param block_param_def opt_block_param %type f_arglist -%type mrhs mlhs_item mlhs_node arg_value case_body p_case_body exc_list aref_args +%type mrhs mlhs_item mlhs_node arg_value case_body exc_list aref_args %type lhs none args %type qword_list word_list %type f_arg f_optarg @@ -253,6 +262,24 @@ public class RubyParser { %type fcall %token tLABEL_END %type k_return k_class k_module +%type p_case_body +%type p_cases p_top_expr p_top_expr_body +%type p_expr p_as p_alt p_expr_basic +%type p_find +%type p_args +%type p_args_head +%type p_args_tail +%type p_args_post p_arg +%type p_value p_primitive p_variable p_var_ref p_expr_ref p_const +%type p_kwargs +%type p_kwarg +%type p_kw +%type p_rest p_kwrest p_kwnorest p_any_kwrest p_kw_label +%type p_lparen p_lbracket +%type nonlocal_var +%type rbrace +%token keyword_in + /* * precedence table @@ -1242,7 +1269,7 @@ arg : lhs '=' arg_rhs { $$ = support.newAndNode($1.getPosition(), $1, $3); } | arg tOROP arg { - $$ = support.newOrNode($1.getPosition(), $1, $3); + $$ = support.newOrNode(support.getPosition($1), $1, $3); } | keyword_defined opt_nl arg { $$ = support.new_defined($1, $3); @@ -1549,8 +1576,8 @@ primary : literal $$ = $1.setIterNode($2); $$.extendPosition($1); } - | tLAMBDA lambda { - $$ = $2; + | lambda { + $$ = $1; } | keyword_if expr_value then compstmt if_tail keyword_end { $$ = new IfParseNode($1, support.getConditionNode($2), $4, $5); @@ -1715,7 +1742,7 @@ if_tail : opt_else opt_else : none | keyword_else compstmt { - $$ = $2; + $$ = $2 == null ? NilImplicitParseNode.NIL : $2; } // [!null] @@ -1882,7 +1909,7 @@ bvar : tIDENTIFIER { $$ = null; } -lambda : /* none */ { +lambda : tLAMBDA { support.pushBlockScope(); $$ = lexer.getLeftParenBegin(); lexer.setLeftParenBegin(lexer.incrementParenNest()); @@ -1890,10 +1917,10 @@ lambda : /* none */ { $$ = Long.valueOf(lexer.getCmdArgumentState().getStack()); lexer.getCmdArgumentState().reset(); } lambda_body { - lexer.getCmdArgumentState().reset($3.longValue()); + lexer.getCmdArgumentState().reset($4.longValue()); lexer.getCmdArgumentState().restart(); - $$ = new LambdaParseNode($2.getPosition(), $2, $4, support.getCurrentScope()); - lexer.setLeftParenBegin($1); + $$ = new LambdaParseNode($3.getPosition(), $3, $5, support.getCurrentScope()); + lexer.setLeftParenBegin($2); support.popCurrentScope(); } @@ -2024,11 +2051,388 @@ case_body : keyword_when args then compstmt cases { cases : opt_else | case_body -p_case_body : keyword_in args then compstmt p_cases { - $$ = support.newInNode($1, $2, $4, $5); +p_case_body : keyword_in { + lexer.setState(EXPR_BEG|EXPR_LABEL); + lexer.commandStart = false; + // Lexcontext object is not used in favour of lexer.inKwarg + // LexContext ctxt = (LexContext) lexer.getLexContext(); + $1 = lexer.inKwarg; + lexer.inKwarg = true; + $$ = support.push_pvtbl(); + } { + $$ = support.push_pktbl(); // after in + } p_top_expr then { + support.pop_pktbl($3); + support.pop_pvtbl($2); + lexer.inKwarg = $1; + } compstmt p_cases { + $$ = support.newInNode(support.getPosition($1), $4, $7, $8); + } + +p_cases : opt_else + | p_case_body { + $$ = $1; + } + +p_top_expr : p_top_expr_body + | p_top_expr_body modifier_if expr_value { + $$ = new IfParseNode(support.getPosition($1), support.getConditionNode($3), $1, null); + $$.extendPosition($3); + } + | p_top_expr_body modifier_unless expr_value { + $$ = new IfParseNode(support.getPosition($1), support.getConditionNode($3), null, $1); + $$.extendPosition($3); + } + +p_top_expr_body : p_expr + | p_expr ',' { + $$ = support.new_array_pattern(support.getPosition($1), null, $1, + support.new_array_pattern_tail(support.getPosition($1), null, true, null, null)); + } + | p_expr ',' p_args { + $$ = support.new_array_pattern(support.getPosition($1), null, $1, $3); + // the following line is a no-op. May or many not require an impl + support.nd_set_first_loc($$, support.getPosition($1)); + } + | p_find { + $$ = support.new_find_pattern(null, $1); + } + | p_args_tail { + $$ = support.new_array_pattern(support.getPosition($1), null, null, $1); + } + | p_kwargs { + $$ = support.new_hash_pattern(null, $1); // new_hash_pattern + } + +p_expr : p_as + +p_as : p_expr tASSOC p_variable { + $$ = new HashParseNode(support.getPosition($1), new ParseNodeTuple($1, $3)); // p_as + } + | p_alt + +p_alt : p_alt '|' p_expr_basic { + $$ = support.newOrNode(support.getPosition($1), $1, $3); + } + | p_expr_basic + +p_lparen : '(' { + $$ = support.push_pktbl(); + } +p_lbracket : '[' { + $$ = support.push_pktbl(); + } +p_expr_basic : p_value + | p_variable + | p_const p_lparen p_args rparen { + support.pop_pktbl($2); + $$ = support.new_array_pattern(support.getPosition($1), $1, null, $3); + support.nd_set_first_loc($$, support.getPosition($1)); + } + | p_const p_lparen p_find rparen { + support.pop_pktbl($2); + $$ = support.new_find_pattern($1, $3); + support.nd_set_first_loc($$, support.getPosition($1)); + } + | p_const p_lparen p_kwargs rparen { + support.pop_pktbl($2); + $$ = support.new_hash_pattern($1, $3); + support.nd_set_first_loc($$, support.getPosition($1)); + } + | p_const '(' rparen { + $$ = support.new_array_pattern(support.getPosition($1), $1, null, + support.new_array_pattern_tail(support.getPosition($1), null, false, null, null)); + } + | p_const p_lbracket p_args rbracket { + support.pop_pktbl($2); + $$ = support.new_array_pattern(support.getPosition($1), $1, null, $3); + support.nd_set_first_loc($$, support.getPosition($1)); + } + | p_const p_lbracket p_find rbracket { + support.pop_pktbl($2); + $$ = support.new_find_pattern($1, $3); + support.nd_set_first_loc($$, support.getPosition($1)); + } + | p_const p_lbracket p_kwargs rbracket { + support.pop_pktbl($2); + $$ = support.new_hash_pattern($1, $3); + support.nd_set_first_loc($$, support.getPosition($1)); + } + | p_const '[' rbracket { + $$ = support.new_array_pattern(support.getPosition($1), $1, null, + support.new_array_pattern_tail(support.getPosition($1), null, false, null, null)); + } + | tLBRACK p_args rbracket { + $$ = support.new_array_pattern(support.getPosition($1), null, null, $2); + } + | tLBRACK p_find rbracket { + $$ = support.new_find_pattern(null, $2); + } + | tLBRACK rbracket { + $$ = support.new_array_pattern(support.getPosition($1), null, null, + support.new_array_pattern_tail(support.getPosition($1), null, false, null, null)); + } + | tLBRACE { + $$ = support.push_pktbl(); // p_expr_basic last production + $1 = lexer.inKwarg; + lexer.inKwarg = false; + } p_kwargs rbrace { + support.pop_pktbl($2); // p_expr_basic last production 1 + lexer.inKwarg = $1; + $$ = support.new_hash_pattern(null, $3); + } + | tLBRACE rbrace { // p_expr_basic last production 2 + $$ = support.new_hash_pattern(null, support.new_hash_pattern_tail(support.getPosition($1), null, null)); + } + | tLPAREN { + $$ = support.push_pktbl(); + } p_expr rparen { + support.pop_pktbl($2); + $$ = $3; + } + +p_args : p_expr { + ListParseNode preArgs = support.newArrayNode(support.getPosition($1), $1); // p_expr + $$ = support.new_array_pattern_tail(support.getPosition($1), preArgs, false, null, null); + } + | p_args_head { + $$ = support.new_array_pattern_tail(support.getPosition($1), $1, true, null, null); + } + | p_args_head p_arg { + $$ = support.new_array_pattern_tail(support.getPosition($1), support.list_concat($1, $2), false, null, null); + } + | p_args_head tSTAR tIDENTIFIER { + $$ = support.new_array_pattern_tail(support.getPosition($1), $1, true, $3, null); + } + | p_args_head tSTAR tIDENTIFIER ',' p_args_post { + $$ = support.new_array_pattern_tail(support.getPosition($1), $1, true, $3, $5); + } + | p_args_head tSTAR { + $$ = support.new_array_pattern_tail(support.getPosition($1), $1, true, null, null); + } + | p_args_head tSTAR ',' p_args_post { + $$ = support.new_array_pattern_tail(support.getPosition($1), $1, true, null, $4); + } + | p_args_tail { + $$ = $1; + } + +p_args_head : p_arg ',' { + $$ = $1; + } + | p_args_head p_arg ',' { + $$ = support.list_concat($1, $2); + } + +p_args_tail : p_rest { + $$ = support.new_array_pattern_tail(support.getPosition($1), null, true, $1, null); // p_args_tail + } + | p_rest ',' p_args_post { + $$ = support.new_array_pattern_tail(support.getPosition($1), null, true, $1, $3); // p_args_tail_2 + } + +p_find : p_rest ',' p_args_post ',' p_rest { + $$ = support.new_find_pattern_tail(support.getPosition($1), $1, $3, $5); // p_find + support.warn(support.getPosition($1), "Find pattern is experimental, and the behavior may change in future versions of Ruby!"); + } + +p_rest : tSTAR tIDENTIFIER { + $$ = $2; // p_rest + } + | tSTAR { + $$ = null; // p_rest_2 + } + +// ListNode - [!null] +p_args_post : p_arg + | p_args_post ',' p_arg { + $$ = support.list_concat($1, $3); // p_args_post + } + +// ListNode - [!null] +p_arg : p_expr { + $$ = support.newArrayNode($1.getPosition(), $1); // p_arg + } + +// HashPatternNode - [!null] +p_kwargs : p_kwarg ',' p_any_kwrest { + $$ = support.new_hash_pattern_tail(support.getPosition($1), $1, $3); // p_kwargs_1 + } + | p_kwarg { + $$ = support.new_hash_pattern_tail(support.getPosition($1), $1, null); // p_kwargs_2 + } + | p_kwarg ',' { + $$ = support.new_hash_pattern_tail(support.getPosition($1), $1, null); // p_kwargs_3 + } + | p_any_kwrest { + $$ = support.new_hash_pattern_tail(support.getPosition($1), null, $1); // p_kwargs_4 + } + +// HashParseNode - [!null] +p_kwarg : p_kw { + $$ = new HashParseNode(support.getPosition($1), $1); // p_kwarg + } + | p_kwarg ',' p_kw { + $1.add($3); // p_kwarg 2 + $$ = $1; + } + +// KeyValuePair - [!null] +p_kw : p_kw_label p_expr { + support.error_duplicate_pattern_key($1); // p_kw. + + ParseNode label = support.asSymbol(support.getPosition($1), $1); + + $$ = new ParseNodeTuple(label, $2); + } + | p_kw_label { + support.error_duplicate_pattern_key($1); // p_kw_label. + if ($1 != null && !support.is_local_id($1)) { + support.yyerror("key must be valid as local variables"); + } + support.error_duplicate_pattern_variable($1); + + ParseNode label = support.asSymbol(support.getPosition($1), $1); + $$ = new ParseNodeTuple(label, support.assignableLabelOrIdentifier($1, null)); + } + +// Rope +p_kw_label : tLABEL + | tSTRING_BEG string_contents tLABEL_END { + if ($2 == null || $2 instanceof StrParseNode) { + $$ = $2.getValue(); + } else { + support.yyerror("symbol literal with interpolation is not allowed"); + $$ = null; + } + } + +p_kwrest : kwrest_mark tIDENTIFIER { + $$ = $2; + } + | kwrest_mark { + $$ = null; + } + +p_kwnorest : kwrest_mark keyword_nil { + $$ = null; + } + +p_any_kwrest : p_kwrest + | p_kwnorest { + $$ = ParserSupport.KWNOREST; + } + +p_value : p_primitive + | p_primitive tDOT2 p_primitive { + ParserSupport.value_expr(lexer, $1); + ParserSupport.value_expr(lexer, $3); + boolean isLiteral = $1 instanceof FixnumParseNode && $3 instanceof FixnumParseNode; + $$ = new DotParseNode(support.getPosition($1), support.makeNullNil($1), support.makeNullNil($3), false, isLiteral); + } + | p_primitive tDOT3 p_primitive { + ParserSupport.value_expr(lexer, $1); + ParserSupport.value_expr(lexer, $3); + boolean isLiteral = $1 instanceof FixnumParseNode && $3 instanceof FixnumParseNode; + $$ = new DotParseNode(support.getPosition($1), support.makeNullNil($1), support.makeNullNil($3), true, isLiteral); + } + | p_primitive tDOT2 { + ParserSupport.value_expr(lexer, $1); + boolean isLiteral = $1 instanceof FixnumParseNode; + $$ = new DotParseNode(support.getPosition($1), support.makeNullNil($1), NilImplicitParseNode.NIL, false, isLiteral); + } + | p_primitive tDOT3 { + ParserSupport.value_expr(lexer, $1); + boolean isLiteral = $1 instanceof FixnumParseNode; + $$ = new DotParseNode(support.getPosition($1), support.makeNullNil($1), NilImplicitParseNode.NIL, true, isLiteral); + } + | p_var_ref + | p_expr_ref + | p_const + | tBDOT2 p_primitive { + ParserSupport.value_expr(lexer, $2); + boolean isLiteral = $2 instanceof FixnumParseNode; + $$ = new DotParseNode(support.getPosition($1), NilImplicitParseNode.NIL, support.makeNullNil($2), false, isLiteral); + } + | tBDOT3 p_primitive { + ParserSupport.value_expr(lexer, $2); + boolean isLiteral = $2 instanceof FixnumParseNode; + $$ = new DotParseNode(support.getPosition($1), NilImplicitParseNode.NIL, support.makeNullNil($2), true, isLiteral); + } + +p_primitive : literal + | strings + | xstring + | regexp + | words { + $$ = $1; + } + | qwords { + $$ = $1; + } + | symbols { + $$ = $1; + } + | qsymbols { + $$ = $1; + } + | /*mri:keyword_variable*/ keyword_nil { + $$ = new NilParseNode(lexer.tokline); + } + | keyword_self { + $$ = new SelfParseNode(lexer.tokline); + } + | keyword_true { + $$ = new TrueParseNode(lexer.tokline); + } + | keyword_false { + $$ = new FalseParseNode(lexer.tokline); + } + | keyword__FILE__ { + // TODO: make a helper for this since it is used twice now + Encoding encoding = support.getConfiguration().getContext() == null ? UTF8Encoding.INSTANCE : support.getConfiguration().getContext().getEncodingManager().getLocaleEncoding().jcoding; + $$ = new FileParseNode(lexer.getPosition(), TruffleString.fromByteArrayUncached(lexer.getFile().getBytes(), lexer.tencoding , true), lexer.encoding); + } + | keyword__LINE__ { + $$ = new FixnumParseNode(lexer.tokline, lexer.getRubySourceLine()); + } + | keyword__ENCODING__ { + $$ = new EncodingParseNode(lexer.tokline, lexer.getEncoding()); + } /*mri:keyword_variable*/ + | lambda { + $$ = $1; + } + +p_variable : tIDENTIFIER { + support.error_duplicate_pattern_variable($1); + $$ = support.assignableInCurr($1, null); + } + +p_var_ref : '^' tIDENTIFIER { + ParseNode n = support.gettable($2); + if (!(n instanceof LocalVarParseNode || n instanceof DVarParseNode)) { + support.compile_error("" + $2 + ": no such local variable"); + } + $$ = n; + } + | '^' nonlocal_var { + $$ = support.gettable($2); + if ($$ == null) $$ = new BeginParseNode(lexer.tokline, NilImplicitParseNode.NIL); } -p_cases : opt_else | p_case_body +p_expr_ref : '^' tLPAREN expr_value ')' { + $$ = new BeginParseNode(lexer.tokline, $3); + } + +p_const : tCOLON3 cname { + $$ = support.new_colon3(lexer.tokline, $2); + } + | p_const tCOLON2 cname { + $$ = support.new_colon2(lexer.tokline, $1, $3); + } + | tCONSTANT { + $$ = new ConstParseNode(lexer.tokline, support.symbolID($1)); + } opt_rescue : keyword_rescue exc_list exc_var then compstmt opt_rescue { ParseNode node; @@ -2137,7 +2541,7 @@ word_list : /* none */ { } word : string_content { - $$ = $1; + $$ = $1; } | word string_content { $$ = support.literal_concat($1, $2); @@ -2293,6 +2697,10 @@ numeric : simple_numeric { $$ = support.negateNumeric($2); } +nonlocal_var : tIVAR + | tGVAR + | tCVAR + simple_numeric : tINTEGER { $$ = $1; } @@ -2818,6 +3226,9 @@ rparen : opt_nl tRPAREN { rbracket : opt_nl tRBRACK { $$ = $2; } +rbrace : opt_nl tRCURLY { + $$ = TStringConstants.RCURLY; + } trailer : /* none */ | '\n' | ',' term : ';' @@ -2844,7 +3255,7 @@ none_block_pass : /* none */ { support.setConfiguration(configuration); support.setResult(new RubyParserResult()); - yyparse(lexer, null); + yyparse(lexer, new org.truffleruby.parser.parser.YYDebug()); return support.getResult(); } diff --git a/src/main/java/org/truffleruby/parser/parser/YYDebug.java b/src/main/java/org/truffleruby/parser/parser/YYDebug.java new file mode 100644 index 000000000000..1510c4370e2e --- /dev/null +++ b/src/main/java/org/truffleruby/parser/parser/YYDebug.java @@ -0,0 +1,66 @@ +/* + ***** BEGIN LICENSE BLOCK ***** + * Version: EPL 2.0/GPL 2.0/LGPL 2.1 + * + * The contents of this file are subject to the Eclipse Public + * License Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.eclipse.org/legal/epl-v20.html + * + * Software distributed under the License is distributed on an "AS + * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or + * implied. See the License for the specific language governing + * rights and limitations under the License. + * + * + * Alternatively, the contents of this file may be used under the terms of + * either of the GNU General Public License Version 2 or later (the "GPL"), + * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), + * in which case the provisions of the GPL or the LGPL are applicable instead + * of those above. If you wish to allow use of your version of this file only + * under the terms of either the GPL or the LGPL, and not to allow others to + * use your version of this file under the terms of the EPL, indicate your + * decision by deleting the provisions above and replace them with the notice + * and other provisions required by the GPL or the LGPL. If you do not delete + * the provisions above, a recipient may use your version of this file under + * the terms of any one of the EPL, the GPL or the LGPL. + ***** END LICENSE BLOCK *****/ + +package org.truffleruby.parser.parser; + +public class YYDebug { + public void accept(Object a) { + System.err.println("Accept: " + a); + } + + public void discard(int a, int b, String c, Object d) { + System.err.println("Discard: " + c + " " + d); + } + + public void error(String a) { + System.err.println("Err: " + a); + } + + public void lex(int a, int b, String c, Object d) { + System.err.println("Lex: " + c + " " + d); + } + + public void pop(int a) { + } + + public void push(int a, Object b) { + } + + public void reduce(int a, int b, int c, String d, short e) { + System.err.println("Reduce: " + d); + } + + public void reject() { + } + + public void shift(int a, short b, int c) { + } + + public void shift(int a, int b) { + } +} diff --git a/src/main/java/org/truffleruby/parser/parser/YyTables.java b/src/main/java/org/truffleruby/parser/parser/YyTables.java index 941a1452b8f6..a44b092f8222 100644 --- a/src/main/java/org/truffleruby/parser/parser/YyTables.java +++ b/src/main/java/org/truffleruby/parser/parser/YyTables.java @@ -54,2146 +54,2321 @@ public static final short[] yyCheck() { private static final short[] yyTable1() { return new short[] { - 90, 90, 459, 294, 365, 297, 291, 230, 230, 230, - 207, 416, 264, 230, 230, 345, 406, 748, 263, 409, - 193, 193, 296, 209, 483, 659, 240, 494, 194, 504, - 207, 343, 85, 85, 113, 673, 660, 594, 278, 278, - 524, 193, 844, 209, 526, 90, 626, 673, 74, 341, - 673, 230, 959, 662, 681, 263, 680, 674, 363, 680, - 315, 662, 674, 604, 955, 286, 1014, 282, 193, 290, - 303, 661, 8, 540, 1055, 543, 351, 814, 1109, 282, - 282, 636, 8, 363, 673, 236, 654, 234, 237, 99, - 87, 609, 666, 825, 422, 681, 673, 604, 628, 72, - 341, 293, 670, 228, 228, 228, 263, 73, 230, 438, - 438, 738, 604, 322, 326, 263, 263, 236, 281, 281, - 706, 606, 240, 512, 84, 605, 837, 605, 419, 1109, - 598, 8, 605, 278, 235, 598, 320, 324, 605, 284, - 403, 420, 364, 1033, 75, 236, 289, 289, 617, 673, - 631, 409, 321, 283, 849, 606, 455, 421, 1055, 293, - 355, 673, 298, 703, 598, 573, 235, 364, 521, 598, - 606, 673, 605, 521, 282, 84, 673, 1014, 87, 598, - 590, 471, 617, 748, 598, 963, 589, 605, 598, 403, - 471, 875, 604, 674, 235, 73, 540, 617, 673, 631, - 409, 673, 520, 299, 321, 1066, 1011, 523, 784, 355, - 571, 90, 293, 281, 573, 296, 282, 911, 306, 955, - 673, 964, 573, 443, 573, 90, 850, 507, 620, 466, - 471, 625, 395, 444, 483, 589, 388, 598, 806, 230, - 230, 393, 807, 356, 396, 391, 1091, 394, 658, 528, - 673, 817, 240, 673, 631, 959, 389, 681, 460, 571, - 868, 680, 680, 392, 710, 625, 748, 532, 748, 710, - 390, 573, 794, 76, 425, 1057, 802, 738, 629, 869, - 625, 615, 293, 82, 230, 793, 230, 230, 467, 673, - 230, 425, 230, 357, 290, 668, 90, 90, 95, 95, - 461, 360, 634, 631, 55, 90, 635, 90, 658, 278, - 265, 278, 278, 668, 673, 615, 90, 421, 464, 465, - 361, 1093, 315, 970, 76, 73, 240, 629, 85, 411, - 615, 748, 514, 748, 82, 228, 228, 510, 341, 371, - 372, 680, 886, 95, 263, 515, 662, 342, 518, 893, - 282, 660, 282, 412, 80, 662, 663, 1116, 604, 660, - 738, 662, 738, 661, 230, 230, 230, 230, 90, 230, - 230, 661, 905, 606, 450, 606, 490, 400, 662, 624, - 606, 413, 74, 534, 535, 99, 495, 673, 497, 281, - 537, 281, 491, 84, 674, 622, 674, 604, 342, 674, - 559, 660, 673, 230, 282, 80, 417, 439, 439, 608, - 900, 608, 90, 341, 673, 230, 608, 835, 90, 263, - 599, 829, 831, 673, 599, 598, 833, 315, 278, 822, - 604, 845, 230, 1037, 292, 323, 661, 8, 471, 230, - 882, 884, 528, 555, 556, 557, 558, 889, 891, 90, - 85, 630, 230, 933, 600, 673, 418, 90, 84, 673, - 228, 228, 228, 228, 598, 560, 561, 446, 230, 599, - 449, 845, 606, 284, 605, 605, 284, 278, 75, 665, - 665, 605, 605, 673, 310, 599, 598, 283, 748, 605, - 283, 403, 490, 278, 605, 1001, 689, 598, 673, 617, - 230, 631, 409, 600, 207, 571, 681, 1113, 673, 95, - 673, 680, 471, 90, 590, 193, 619, 209, 456, 600, - 619, 599, 457, 95, 999, 458, 625, 674, 633, 230, - 528, 341, 534, 535, 779, 643, 1037, 263, 321, 537, - 1037, 490, 76, 679, 571, 461, 599, 673, 77, 631, - 282, 463, 82, 123, 278, 600, 573, 490, 573, 589, - 758, 598, 371, 372, 661, 625, 395, 969, 809, 806, - 388, 766, 829, 629, 763, 393, 615, 571, 396, 391, - 600, 394, 625, 770, 699, 806, 928, 461, 631, 773, - 389, 1037, 1047, 943, 95, 95, 690, 392, 625, 77, - 953, 605, 123, 95, 390, 95, 472, 76, 712, 836, - 292, 854, 629, 713, 95, 615, 673, 82, 490, 341, - 913, 631, 915, 80, 468, 263, 85, 673, 78, 629, - 498, 766, 615, 952, 454, 478, 342, 762, 230, 752, - 90, 801, 727, 728, 753, 629, 769, 766, 615, 207, - 673, 479, 769, 482, 83, 599, 473, 474, 475, 193, - 193, 477, 209, 278, 310, 673, 95, 800, 373, 1058, - 673, 673, 230, 293, 508, 1084, 673, 85, 509, 78, - 766, 513, 519, 673, 525, 772, 995, 81, 80, 600, - 79, 772, 997, 90, 528, 533, 534, 535, 341, 673, - 499, 500, 895, 537, 263, 83, 527, 611, 542, 611, - 95, 342, 546, 673, 611, 104, 95, 762, 673, 623, - 236, 769, 606, 606, 631, 85, 637, 490, 673, 606, - 606, 647, 673, 651, 805, 808, 505, 808, 81, 854, - 944, 79, 606, 649, 808, 502, 310, 95, 830, 662, - 619, 826, 673, 683, 821, 95, 673, 673, 608, 608, - 772, 818, 454, 684, 685, 608, 608, 695, 228, 235, - 691, 766, 700, 90, 373, 692, 230, 754, 608, 279, - 285, 756, 99, 341, 90, 759, 952, 230, 90, 263, - 405, 673, 760, 599, 761, 764, 90, 775, 618, 378, - 379, 278, 627, 908, 90, 896, 780, 230, 388, 402, - 123, 95, 390, 391, 392, 393, 906, 77, 403, 408, - 90, 90, 90, 454, 939, 786, 673, 600, 830, 342, - 854, 871, 854, 470, 470, 874, 394, 395, 952, 470, - 673, 665, 878, 304, 878, 767, 618, 90, 90, 606, - 768, 310, 782, 304, 785, 716, 806, 717, 718, 719, - 720, 797, 812, 676, 678, 490, 909, 323, 819, 813, - 815, 454, 816, 673, 424, 90, 846, 766, 90, 820, - 454, 454, 77, 228, 673, 608, 924, 297, 650, 952, - 858, 919, 859, 860, 923, 85, 657, 78, 862, 854, - 1059, 864, 304, 228, 673, 678, 90, 454, 323, 673, - 866, 673, 870, 873, 454, 992, 876, 342, 1044, 90, - 610, 263, 881, 83, 973, 887, 90, 629, 888, 111, - 977, 716, 907, 717, 718, 719, 720, 673, 95, 109, - 109, 939, 673, 854, 917, 854, 109, 109, 109, 912, - 123, 454, 109, 109, 863, 865, 81, 114, 673, 79, - 85, 921, 78, 926, 925, 610, 927, 629, 934, 716, - 936, 717, 718, 719, 720, 721, 90, 450, 111, 945, - 722, 854, 974, 1006, 109, 534, 535, 536, 83, 976, - 109, 95, 537, 90, 1002, 90, 342, 1003, 781, 454, - 1007, 1008, 90, 939, 843, 724, 114, 1009, 454, 454, - 533, 1012, 1015, 725, 726, 727, 728, 808, 694, 1017, - 1019, 81, 1021, 1039, 79, 839, 840, 402, 841, 869, - 1092, 1041, 803, 795, 1078, 454, 403, 404, 536, 1056, - 263, 230, 1064, 618, 673, 673, 1024, 109, 1067, 90, - 484, 729, 487, 1069, 1071, 1073, 611, 611, 599, 1081, - 827, 766, 828, 611, 611, 1089, 278, 1079, 1094, 678, - 323, 95, 1096, 1102, 673, 108, 611, 1112, 1110, 1114, - 1118, 342, 95, 263, 1120, 808, 95, 1122, 1125, 1136, - 110, 110, 600, 660, 95, 61, 62, 110, 110, 110, - 673, 673, 95, 110, 110, 304, 304, 304, 662, 108, - 304, 304, 304, 662, 304, 666, 1070, 666, 95, 95, - 95, 1074, 304, 673, 1080, 668, 108, 534, 535, 539, - 490, 872, 373, 808, 537, 110, 304, 304, 304, 304, - 304, 110, 662, 662, 675, 95, 95, 673, 362, 678, - 109, 402, 443, 476, 721, 354, 324, 751, 440, 722, - 403, 453, 443, 697, 109, 1016, 388, 904, 1018, 1020, - 390, 391, 1022, 95, 1023, 196, 95, 1088, 109, 109, - 950, 910, 954, 611, 304, 735, 111, 304, 880, 914, - 98, 978, 1124, 774, 727, 728, 1049, 957, 110, 644, - 534, 535, 539, 951, 95, 1028, 929, 537, 304, 496, - 787, 443, 1104, 993, 114, 1105, 97, 95, 366, 367, - 368, 369, 370, 109, 95, 109, 109, 645, 894, 109, - 729, 109, 304, 516, 517, 109, 109, 539, 585, 267, - 940, 1087, 942, 920, 109, 470, 109, 533, 63, 64, - 65, 66, 98, 98, 407, 109, 533, 533, 961, 930, - 931, 932, 644, 538, 266, 1115, 454, 0, 962, 883, - 885, 0, 0, 0, 95, 536, 890, 892, 1095, 1097, - 1098, 1099, 1025, 644, 536, 536, 0, 941, 971, 0, - 645, 95, 16, 95, 0, 0, 0, 98, 0, 972, - 95, 110, 641, 109, 109, 109, 109, 109, 109, 109, - 0, 645, 641, 0, 0, 110, 0, 966, 0, 323, - 0, 883, 885, 0, 890, 892, 673, 673, 673, 110, - 110, 0, 439, 673, 0, 1130, 0, 1061, 0, 531, - 0, 16, 109, 108, 108, 99, 641, 95, 109, 0, - 109, 109, 0, 0, 109, 109, 0, 109, 996, 0, - 0, 641, 1036, 0, 0, 998, 92, 640, 0, 1040, - 0, 109, 0, 0, 110, 439, 110, 110, 109, 0, - 110, 0, 110, 0, 0, 1103, 110, 110, 109, 1107, - 324, 109, 540, 324, 778, 110, 109, 110, 1043, 0, - 0, 682, 324, 324, 324, 0, 110, 109, 648, 108, - 686, 687, 688, 533, 443, 443, 443, 0, 0, 443, - 443, 443, 0, 443, 15, 117, 0, 0, 0, 696, - 0, 443, 1045, 443, 1046, 0, 0, 0, 324, 109, - 1132, 1050, 443, 443, 0, 443, 443, 443, 443, 443, - 0, 116, 109, 324, 110, 110, 110, 110, 110, 110, - 110, 0, 1036, 98, 0, 1036, 0, 1036, 109, 1036, - 0, 0, 0, 15, 539, 0, 0, 98, 0, 100, - 443, 98, 402, 539, 539, 324, 0, 0, 1090, 443, - 443, 403, 469, 110, 207, 0, 443, 0, 0, 110, - 538, 110, 110, 402, 0, 110, 110, 0, 110, 538, - 538, 0, 403, 506, 0, 98, 1036, 443, 1036, 0, - 1036, 0, 110, 1036, 0, 0, 541, 0, 0, 110, - 640, 0, 98, 0, 1036, 0, 0, 783, 0, 110, - 0, 443, 110, 207, 16, 16, 16, 110, 98, 98, - 16, 16, 0, 16, 0, 105, 105, 98, 110, 98, - 796, 16, 539, 0, 641, 641, 641, 0, 98, 641, - 641, 641, 0, 641, 0, 127, 402, 109, 127, 109, - 118, 641, 0, 641, 641, 403, 530, 534, 535, 541, - 110, 0, 641, 641, 537, 641, 641, 641, 641, 641, - 105, 111, 644, 110, 402, 0, 0, 832, 0, 0, - 0, 109, 0, 403, 639, 834, 534, 535, 709, 110, - 98, 97, 0, 537, 127, 0, 16, 324, 0, 540, - 0, 402, 109, 0, 0, 402, 324, 324, 540, 540, - 403, 777, 648, 0, 403, 1042, 641, 16, 0, 641, - 533, 641, 0, 0, 0, 97, 324, 0, 0, 533, - 533, 612, 0, 612, 98, 644, 0, 641, 612, 0, - 98, 16, 97, 92, 0, 0, 15, 15, 15, 0, - 0, 0, 15, 15, 0, 15, 644, 99, 0, 0, - 302, 641, 0, 15, 0, 0, 0, 109, 109, 0, - 302, 98, 538, 0, 109, 109, 0, 92, 0, 98, - 0, 0, 109, 0, 119, 109, 0, 109, 534, 535, - 750, 99, 324, 109, 92, 537, 109, 109, 110, 0, - 110, 324, 324, 0, 298, 109, 0, 648, 99, 0, - 504, 504, 504, 109, 102, 0, 109, 504, 935, 302, - 98, 0, 0, 0, 533, 324, 0, 101, 15, 109, - 109, 109, 110, 541, 0, 98, 105, 402, 540, 0, - 0, 0, 541, 541, 946, 0, 403, 1111, 0, 15, - 105, 0, 0, 110, 0, 0, 109, 109, 0, 117, - 207, 543, 207, 207, 207, 207, 207, 0, 0, 539, - 103, 207, 0, 15, 542, 0, 0, 0, 539, 539, - 0, 0, 539, 0, 109, 98, 207, 109, 0, 0, - 125, 0, 539, 0, 109, 0, 207, 207, 0, 95, - 975, 0, 127, 0, 207, 207, 207, 207, 117, 716, - 45, 717, 718, 719, 720, 109, 0, 544, 110, 110, - 45, 105, 105, 0, 0, 110, 110, 0, 109, 1010, - 105, 0, 105, 110, 0, 109, 110, 0, 110, 125, - 539, 105, 207, 0, 110, 852, 536, 110, 110, 0, - 0, 0, 0, 853, 0, 0, 110, 0, 0, 0, - 97, 0, 98, 324, 110, 0, 0, 110, 0, 45, - 0, 651, 324, 324, 0, 0, 0, 0, 648, 0, - 110, 110, 110, 0, 0, 109, 0, 0, 230, 0, - 0, 0, 1052, 105, 717, 718, 719, 720, 230, 0, - 0, 0, 109, 0, 109, 0, 0, 110, 110, 538, - 0, 109, 92, 644, 0, 98, 0, 0, 538, 538, - 0, 0, 302, 302, 302, 97, 99, 302, 302, 302, - 0, 302, 230, 0, 105, 110, 105, 105, 110, 302, - 0, 105, 0, 105, 0, 110, 230, 230, 0, 121, - 109, 230, 94, 302, 302, 302, 302, 302, 109, 0, - 0, 533, 120, 0, 0, 0, 110, 0, 0, 0, - 533, 533, 0, 0, 105, 540, 644, 92, 95, 110, - 612, 612, 105, 0, 540, 540, 110, 612, 612, 0, - 533, 99, 0, 35, 0, 98, 0, 644, 543, 535, - 612, 302, 0, 35, 302, 122, 98, 543, 543, 0, - 98, 542, 95, 0, 0, 0, 117, 0, 98, 0, - 542, 542, 960, 0, 533, 302, 98, 0, 0, 95, - 0, 301, 0, 0, 114, 645, 110, 0, 105, 533, - 0, 301, 98, 98, 98, 0, 0, 125, 0, 302, - 0, 0, 35, 110, 544, 110, 0, 0, 0, 536, - 651, 0, 110, 544, 544, 106, 0, 0, 0, 98, - 98, 533, 45, 45, 45, 296, 0, 539, 45, 45, - 0, 45, 0, 536, 0, 0, 539, 539, 0, 45, - 301, 0, 536, 536, 0, 277, 277, 98, 645, 106, - 98, 110, 0, 45, 45, 45, 45, 612, 651, 110, - 0, 100, 0, 106, 0, 0, 106, 651, 651, 645, - 1035, 300, 302, 647, 304, 305, 0, 0, 98, 277, - 277, 116, 344, 346, 0, 0, 0, 994, 0, 0, - 0, 98, 0, 0, 651, 100, 651, 0, 98, 0, - 230, 230, 230, 0, 45, 230, 230, 230, 0, 230, - 651, 0, 100, 0, 0, 105, 0, 230, 0, 230, - 230, 0, 0, 0, 0, 45, 0, 105, 230, 230, - 116, 230, 230, 230, 230, 230, 0, 113, 0, 0, - 277, 0, 541, 230, 0, 0, 0, 0, 98, 45, - 0, 0, 0, 716, 0, 717, 718, 719, 720, 721, - 0, 105, 538, 0, 722, 98, 0, 98, 105, 0, - 1035, 0, 0, 1035, 98, 1106, 118, 1035, 105, 230, - 0, 0, 230, 0, 0, 230, 535, 230, 0, 724, - 0, 0, 0, 0, 0, 535, 535, 95, 645, 727, - 728, 0, 0, 230, 0, 35, 35, 35, 647, 0, - 644, 35, 35, 0, 35, 230, 0, 0, 0, 0, - 0, 98, 35, 0, 1035, 118, 1035, 230, 1035, 0, - 102, 1035, 0, 105, 105, 729, 35, 35, 35, 35, - 105, 105, 1035, 301, 301, 301, 536, 0, 105, 301, - 301, 0, 301, 105, 0, 536, 536, 540, 533, 105, - 301, 645, 95, 105, 102, 0, 0, 533, 533, 0, - 0, 105, 0, 644, 301, 301, 301, 301, 301, 105, - 0, 102, 645, 0, 106, 651, 0, 35, 0, 0, - 0, 533, 0, 0, 644, 105, 105, 105, 125, 651, - 0, 277, 277, 277, 346, 0, 277, 0, 35, 0, - 0, 543, 0, 0, 673, 0, 277, 0, 277, 277, - 0, 0, 105, 105, 673, 301, 0, 503, 0, 0, - 100, 0, 35, 651, 0, 0, 0, 0, 116, 0, - 0, 0, 651, 651, 0, 0, 301, 651, 647, 106, - 105, 0, 0, 105, 0, 0, 651, 651, 0, 0, - 105, 0, 647, 0, 0, 0, 0, 0, 0, 651, - 301, 0, 0, 673, 0, 0, 0, 0, 0, 541, - 0, 105, 0, 651, 0, 0, 0, 0, 541, 541, - 0, 124, 0, 126, 105, 100, 105, 647, 0, 538, - 0, 105, 0, 562, 563, 564, 565, 566, 538, 538, - 567, 568, 569, 570, 571, 572, 573, 574, 575, 576, - 577, 578, 579, 580, 0, 0, 581, 582, 583, 584, - 119, 0, 0, 118, 0, 277, 0, 601, 93, 0, - 124, 607, 126, 614, 0, 647, 0, 277, 607, 0, - 0, 105, 0, 121, 647, 647, 120, 0, 0, 107, - 647, 105, 716, 0, 717, 718, 719, 720, 105, 0, - 105, 0, 647, 233, 648, 0, 0, 105, 0, 119, - 0, 647, 0, 233, 277, 534, 607, 607, 607, 0, - 0, 277, 0, 107, 540, 96, 0, 0, 852, 102, - 277, 0, 121, 540, 540, 120, 1013, 0, 277, 277, - 107, 541, 277, 0, 0, 0, 0, 233, 305, 0, - 0, 0, 0, 716, 105, 717, 718, 719, 720, 0, - 0, 233, 233, 0, 543, 0, 233, 542, 693, 607, - 648, 0, 537, 0, 0, 0, 0, 0, 543, 0, - 277, 0, 0, 277, 0, 0, 0, 543, 543, 852, - 0, 277, 0, 0, 102, 105, 122, 0, 0, 0, - 0, 290, 290, 290, 0, 290, 673, 673, 673, 290, - 290, 673, 673, 673, 290, 673, 290, 290, 290, 290, - 290, 290, 290, 673, 673, 673, 0, 290, 290, 290, - 290, 290, 290, 290, 673, 673, 290, 673, 673, 673, - 673, 673, 647, 290, 0, 122, 290, 290, 290, 0, - 290, 290, 290, 290, 290, 290, 290, 290, 290, 290, - 290, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 200, 0, 673, 277, 0, 290, 290, 544, 124, 0, - 126, 673, 673, 290, 0, 0, 290, 104, 673, 290, - 290, 647, 290, 648, 290, 0, 290, 0, 290, 0, - 277, 0, 0, 112, 0, 0, 290, 277, 673, 673, - 0, 290, 290, 290, 290, 290, 290, 119, 277, 200, - 290, 104, 290, 290, 0, 290, 290, 290, 290, 0, - 290, 290, 290, 673, 0, 277, 0, 277, 104, 647, - 121, 648, 0, 120, 277, 277, 0, 0, 647, 647, - 648, 648, 534, 0, 647, 1038, 648, 0, 107, 648, - 115, 534, 534, 0, 0, 233, 233, 233, 454, 0, - 233, 233, 233, 0, 233, 647, 0, 648, 541, 0, - 0, 0, 233, 0, 233, 233, 958, 541, 541, 0, - 958, 0, 0, 233, 233, 0, 233, 233, 233, 233, - 233, 543, 533, 0, 542, 0, 277, 648, 233, 537, - 543, 543, 533, 542, 542, 0, 648, 648, 537, 537, - 607, 607, 648, 107, 277, 0, 0, 607, 607, 0, - 124, 647, 0, 0, 0, 0, 897, 0, 277, 0, - 607, 0, 277, 648, 233, 0, 533, 233, 0, 0, - 233, 0, 233, 122, 0, 1038, 0, 0, 1038, 0, - 533, 533, 1038, 111, 0, 533, 0, 0, 233, 0, - 0, 0, 607, 607, 0, 607, 607, 0, 0, 647, - 233, 277, 0, 0, 1032, 0, 0, 0, 647, 647, - 0, 0, 233, 533, 647, 0, 0, 0, 0, 0, - 0, 660, 660, 660, 0, 0, 0, 660, 660, 1038, - 660, 1038, 373, 1038, 544, 647, 1038, 0, 660, 0, - 0, 0, 0, 544, 544, 0, 0, 1038, 0, 0, - 386, 387, 0, 277, 0, 0, 0, 0, 536, 0, - 373, 967, 0, 0, 0, 0, 388, 968, 536, 0, - 390, 391, 392, 393, 0, 0, 104, 454, 386, 387, - 0, 0, 0, 277, 0, 0, 200, 0, 200, 200, - 200, 200, 200, 0, 388, 0, 389, 200, 390, 391, - 392, 393, 536, 660, 1032, 0, 968, 1032, 538, 958, - 0, 1032, 200, 0, 277, 0, 536, 536, 538, 114, - 0, 536, 200, 200, 660, 454, 0, 0, 0, 0, - 200, 200, 200, 200, 454, 454, 0, 0, 0, 0, - 0, 104, 0, 0, 0, 0, 0, 0, 660, 536, - 0, 0, 0, 0, 0, 0, 0, 0, 1032, 0, - 1032, 454, 1032, 0, 0, 1032, 0, 0, 200, 0, - 0, 210, 0, 0, 0, 0, 1032, 0, 0, 644, - 644, 644, 0, 644, 533, 533, 533, 644, 644, 533, - 533, 533, 644, 533, 644, 644, 644, 644, 644, 644, - 644, 533, 644, 533, 533, 644, 644, 644, 644, 644, - 644, 644, 533, 533, 644, 533, 533, 533, 533, 533, - 210, 644, 0, 277, 644, 644, 644, 533, 644, 644, - 644, 644, 644, 644, 644, 644, 644, 644, 644, 533, - 533, 533, 533, 533, 533, 533, 533, 533, 533, 533, - 533, 533, 533, 644, 644, 0, 0, 533, 533, 533, - 533, 644, 545, 533, 644, 644, 533, 644, 644, 533, - 644, 533, 644, 533, 644, 533, 644, 533, 533, 533, - 533, 533, 533, 533, 644, 533, 644, 533, 0, 644, - 644, 644, 644, 644, 644, 0, 0, 398, 644, 533, - 644, 644, 0, 644, 644, 644, 644, 0, 644, 644, - 644, 533, 107, 0, 0, 645, 645, 645, 0, 645, - 536, 536, 536, 645, 645, 536, 536, 536, 645, 536, - 645, 645, 645, 645, 645, 645, 645, 536, 645, 536, - 536, 645, 645, 645, 645, 645, 645, 645, 536, 536, - 645, 536, 536, 536, 536, 536, 0, 645, 0, 648, - 645, 645, 645, 536, 645, 645, 645, 645, 645, 645, - 645, 645, 645, 645, 645, 536, 536, 536, 536, 536, - 536, 536, 536, 536, 536, 536, 536, 536, 536, 645, - 645, 110, 0, 536, 536, 536, 536, 645, 548, 536, - 645, 645, 536, 645, 645, 536, 645, 536, 645, 536, - 645, 536, 645, 536, 536, 536, 536, 536, 536, 536, - 645, 536, 645, 536, 0, 645, 645, 645, 645, 645, - 645, 0, 0, 651, 645, 536, 645, 645, 314, 645, - 645, 645, 645, 651, 645, 645, 645, 536, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 661, - 661, 661, 0, 0, 0, 661, 661, 210, 661, 210, - 210, 210, 210, 210, 0, 0, 661, 651, 210, 0, - 0, 0, 373, 0, 0, 0, 0, 0, 0, 540, - 0, 651, 651, 210, 125, 0, 651, 0, 0, 540, - 386, 387, 0, 210, 210, 0, 0, 0, 0, 0, - 0, 210, 210, 210, 210, 0, 388, 0, 389, 0, - 390, 391, 392, 393, 651, 0, 396, 0, 397, 0, - 0, 776, 0, 0, 0, 0, 1068, 0, 0, 0, - 1072, 661, 0, 0, 0, 0, 0, 126, 648, 210, - 0, 373, 374, 375, 376, 377, 378, 379, 380, 381, - 382, 383, 661, 384, 385, 0, 647, 0, 0, 386, - 387, 0, 0, 0, 0, 0, 647, 0, 0, 0, - 0, 0, 0, 0, 0, 388, 661, 389, 0, 390, - 391, 392, 393, 394, 395, 396, 648, 397, 0, 0, - 0, 0, 0, 0, 0, 648, 648, 0, 0, 1119, - 647, 648, 1121, 1123, 0, 0, 1126, 1127, 0, 0, - 0, 0, 0, 0, 647, 647, 129, 124, 373, 647, - 0, 0, 648, 378, 379, 0, 0, 0, 0, 0, - 1135, 1137, 1138, 1139, 0, 0, 386, 387, 0, 1141, - 0, 0, 0, 0, 0, 0, 0, 647, 0, 0, + 99, 264, 476, 459, 807, 297, 365, 494, 406, 292, + 636, 409, 195, 817, 416, 659, 680, 483, 504, 680, + 283, 283, 952, 90, 90, 114, 780, 609, 780, 854, + 231, 231, 231, 208, 628, 265, 231, 231, 264, 235, + 238, 84, 681, 194, 194, 210, 344, 321, 325, 229, + 229, 229, 594, 208, 323, 327, 1143, 304, 768, 806, + 352, 1238, 768, 766, 194, 210, 626, 74, 90, 85, + 85, 295, 342, 298, 231, 780, 8, 279, 279, 521, + 871, 524, 767, 681, 874, 526, 8, 666, 589, 264, + 598, 194, 84, 316, 604, 955, 780, 521, 422, 264, + 264, 654, 294, 403, 1064, 420, 287, 294, 781, 1126, + 780, 291, 87, 520, 237, 1194, 283, 670, 72, 512, + 737, 634, 1104, 342, 294, 635, 780, 461, 237, 73, + 849, 523, 231, 438, 438, 8, 409, 589, 766, 598, + 679, 1213, 1083, 863, 865, 780, 282, 712, 704, 455, + 75, 538, 403, 538, 543, 673, 710, 854, 944, 780, + 711, 1231, 821, 236, 723, 290, 780, 363, 294, 737, + 346, 712, 950, 279, 954, 780, 713, 236, 703, 748, + 658, 712, 704, 471, 87, 409, 696, 294, 963, 679, + 710, 673, 1097, 1098, 711, 363, 712, 704, 723, 886, + 421, 73, 850, 299, 76, 710, 893, 95, 95, 711, + 82, 767, 1143, 723, 793, 1132, 673, 781, 237, 266, + 507, 680, 680, 620, 964, 952, 483, 80, 868, 77, + 290, 605, 781, 605, 85, 90, 300, 311, 605, 321, + 1275, 282, 844, 1201, 1204, 681, 658, 869, 854, 90, + 854, 364, 95, 528, 1154, 76, 343, 766, 284, 443, + 532, 82, 1231, 231, 231, 307, 1131, 236, 679, 444, + 395, 464, 465, 78, 1075, 241, 467, 735, 80, 364, + 77, 357, 229, 229, 388, 85, 1049, 794, 490, 875, + 780, 358, 283, 83, 283, 1074, 802, 99, 466, 393, + 955, 680, 360, 1064, 731, 775, 55, 343, 231, 515, + 231, 231, 1196, 1197, 231, 952, 231, 439, 439, 396, + 90, 90, 1237, 775, 78, 673, 735, 391, 264, 90, + 767, 90, 913, 495, 915, 497, 394, 291, 731, 780, + 90, 283, 710, 81, 83, 748, 768, 710, 389, 279, + 780, 279, 279, 731, 1066, 780, 316, 1068, 1070, 768, + 421, 1072, 342, 1073, 780, 392, 85, 854, 1147, 371, + 372, 450, 241, 677, 84, 510, 882, 884, 361, 1149, + 79, 371, 372, 889, 891, 450, 518, 231, 231, 231, + 231, 90, 231, 231, 81, 555, 556, 557, 558, 411, + 74, 831, 264, 490, 780, 1125, 229, 229, 229, 229, + 622, 560, 561, 829, 833, 1158, 952, 737, 311, 95, + 1162, 84, 677, 1168, 390, 900, 231, 766, 748, 822, + 748, 79, 608, 95, 608, 90, 342, 559, 231, 608, + 8, 90, 630, 599, 781, 528, 767, 599, 933, 854, + 710, 854, 490, 403, 98, 231, 293, 835, 73, 780, + 316, 589, 231, 598, 780, 1225, 737, 279, 490, 1229, + 737, 680, 90, 679, 633, 231, 780, 282, 282, 689, + 90, 643, 282, 75, 679, 1051, 409, 85, 663, 710, + 505, 231, 599, 748, 681, 748, 600, 712, 704, 780, + 311, 645, 241, 969, 95, 95, 98, 98, 599, 845, + 711, 322, 1130, 95, 723, 95, 279, 1125, 267, 696, + 264, 854, 710, 231, 95, 699, 779, 208, 606, 490, + 606, 425, 279, 528, 624, 606, 90, 76, 194, 210, + 1120, 412, 690, 82, 599, 600, 343, 780, 425, 845, + 781, 98, 231, 781, 342, 1217, 1219, 1220, 1221, 1121, + 80, 600, 77, 1262, 829, 781, 400, 85, 108, 599, + 1278, 735, 321, 282, 282, 95, 241, 763, 413, 953, + 605, 605, 534, 535, 76, 1100, 770, 605, 605, 537, + 82, 284, 773, 279, 284, 1087, 772, 600, 731, 1270, + 605, 679, 772, 395, 311, 417, 78, 80, 264, 77, + 735, 806, 836, 461, 85, 324, 611, 388, 611, 95, + 343, 418, 600, 611, 801, 95, 83, 735, 758, 534, + 535, 721, 393, 496, 706, 324, 537, 731, 490, 766, + 446, 650, 342, 735, 419, 805, 808, 456, 808, 657, + 449, 800, 396, 78, 731, 808, 95, 516, 517, 237, + 391, 231, 1276, 90, 95, 721, 457, 677, 1186, 394, + 731, 772, 208, 83, 283, 704, 81, 283, 599, 762, + 721, 389, 194, 194, 210, 780, 995, 264, 769, 830, + 1203, 1206, 997, 99, 769, 231, 475, 528, 392, 766, + 748, 738, 279, 826, 895, 1198, 677, 605, 236, 704, + 768, 737, 355, 79, 229, 766, 90, 780, 98, 458, + 95, 342, 784, 81, 704, 105, 105, 768, 665, 665, + 461, 600, 98, 463, 780, 780, 293, 645, 343, 677, + 1172, 1113, 679, 472, 468, 475, 645, 645, 766, 282, + 737, 282, 491, 878, 472, 878, 478, 390, 780, 762, + 79, 355, 85, 769, 1061, 479, 780, 373, 780, 830, + 105, 634, 264, 97, 460, 1099, 490, 508, 673, 531, + 1007, 608, 608, 737, 780, 722, 1087, 482, 608, 608, + 1087, 679, 472, 498, 99, 1122, 90, 280, 286, 231, + 117, 608, 919, 98, 98, 923, 342, 90, 534, 535, + 231, 90, 98, 531, 98, 537, 599, 780, 909, 90, + 644, 809, 806, 98, 682, 1187, 343, 90, 531, 229, + 231, 574, 780, 686, 687, 688, 1185, 509, 924, 766, + 279, 646, 896, 90, 90, 90, 519, 95, 514, 229, + 780, 324, 696, 906, 727, 728, 729, 473, 474, 475, + 324, 324, 477, 499, 500, 296, 754, 738, 752, 600, + 90, 90, 513, 753, 98, 619, 1269, 606, 606, 619, + 574, 780, 1273, 1145, 606, 606, 905, 1193, 527, 378, + 379, 1087, 939, 424, 1202, 1205, 108, 606, 90, 780, + 95, 90, 1123, 1124, 264, 343, 1281, 98, 608, 525, + 1094, 1240, 539, 843, 127, 612, 947, 612, 98, 814, + 956, 476, 612, 661, 98, 721, 394, 395, 808, 90, + 108, 501, 1128, 1129, 533, 825, 501, 105, 992, 780, + 546, 98, 90, 623, 516, 766, 539, 108, 780, 780, + 738, 105, 738, 475, 104, 98, 631, 780, 98, 637, + 783, 539, 647, 98, 721, 611, 611, 1215, 837, 704, + 476, 780, 611, 611, 649, 780, 780, 324, 475, 475, + 95, 721, 651, 796, 768, 611, 662, 501, 645, 780, + 343, 95, 502, 516, 780, 95, 920, 721, 618, 90, + 472, 454, 627, 95, 606, 683, 780, 501, 704, 939, + 684, 95, 930, 931, 932, 402, 90, 685, 90, 98, + 1077, 691, 105, 105, 403, 408, 539, 95, 95, 95, + 832, 105, 692, 105, 695, 700, 531, 1254, 834, 754, + 941, 704, 105, 756, 958, 759, 618, 97, 958, 104, + 960, 760, 908, 761, 95, 95, 644, 766, 1110, 911, + 764, 531, 531, 676, 678, 644, 644, 324, 530, 484, + 966, 487, 775, 264, 767, 90, 768, 646, 573, 573, + 780, 97, 95, 104, 573, 95, 646, 646, 574, 780, + 665, 490, 611, 105, 808, 782, 785, 786, 97, 797, + 104, 806, 530, 780, 780, 678, 812, 1166, 324, 619, + 813, 996, 531, 95, 231, 531, 815, 530, 816, 116, + 819, 939, 993, 1148, 820, 1150, 95, 1151, 644, 846, + 454, 599, 405, 531, 105, 858, 105, 105, 859, 231, + 118, 105, 1082, 105, 231, 231, 98, 1188, 1085, 766, + 766, 795, 1190, 1191, 264, 279, 860, 862, 229, 864, + 90, 574, 780, 229, 229, 970, 866, 943, 870, 539, + 873, 935, 876, 973, 105, 881, 766, 887, 476, 977, + 888, 907, 105, 95, 600, 1095, 1214, 1096, 1234, 454, + 1146, 912, 917, 921, 539, 539, 925, 946, 781, 98, + 95, 516, 95, 476, 476, 99, 926, 610, 1222, 927, + 90, 780, 934, 324, 629, 1230, 780, 766, 780, 936, + 945, 974, 324, 324, 645, 976, 516, 516, 754, 108, + 454, 1110, 803, 645, 645, 1052, 1053, 454, 105, 99, + 98, 808, 539, 1056, 1138, 539, 454, 454, 539, 766, + 766, 766, 610, 975, 629, 1057, 99, 1058, 1059, 95, + 827, 1062, 828, 1065, 612, 612, 539, 1067, 517, 678, + 324, 612, 612, 454, 1255, 1069, 108, 1102, 1071, 98, + 869, 1089, 1060, 1091, 612, 1112, 646, 98, 470, 1127, + 98, 439, 1135, 1136, 98, 1144, 535, 1152, 304, 910, + 123, 1155, 98, 1157, 1159, 694, 1161, 914, 304, 1169, + 98, 1167, 100, 1183, 1277, 1184, 1279, 517, 454, 1280, + 63, 64, 65, 66, 102, 530, 98, 98, 98, 1212, + 1082, 872, 1125, 1082, 1005, 958, 1085, 1082, 1211, 1085, + 1288, 1228, 297, 1085, 95, 535, 1216, 721, 1218, 678, + 530, 530, 722, 98, 98, 1224, 101, 304, 940, 647, + 1239, 1244, 270, 1232, 644, 105, 454, 904, 402, 1178, + 1179, 649, 439, 644, 644, 454, 454, 403, 404, 1243, + 97, 98, 104, 1242, 98, 1251, 962, 727, 728, 270, + 270, 612, 270, 270, 95, 1252, 1199, 270, 270, 270, + 270, 530, 454, 648, 530, 273, 929, 534, 535, 539, + 1256, 454, 98, 1258, 537, 273, 959, 972, 105, 1260, + 103, 994, 530, 729, 675, 98, 1263, 97, 716, 104, + 717, 718, 719, 720, 1082, 531, 1082, 1235, 1082, 1268, + 1085, 1082, 1085, 1282, 1085, 100, 1284, 1085, 766, 268, + 270, 716, 780, 717, 718, 719, 720, 780, 961, 127, + 270, 270, 1082, 102, 273, 773, 402, 650, 1085, 1248, + 1249, 1250, 1200, 373, 768, 403, 453, 768, 1026, 100, + 773, 640, 98, 105, 105, 768, 780, 1090, 971, 775, + 105, 105, 768, 534, 535, 539, 100, 102, 105, 98, + 537, 98, 768, 105, 362, 751, 355, 388, 127, 105, + 1187, 390, 391, 105, 102, 697, 440, 1236, 1176, 324, + 197, 105, 646, 774, 402, 517, 647, 880, 978, 105, + 735, 646, 646, 403, 469, 951, 373, 778, 99, 301, + 324, 1245, 1246, 1247, 649, 105, 105, 105, 1078, 301, + 517, 517, 639, 535, 386, 387, 883, 885, 98, 957, + 304, 304, 304, 890, 892, 304, 304, 304, 1227, 304, + 388, 894, 105, 105, 390, 391, 392, 393, 535, 535, + 1226, 839, 840, 296, 841, 99, 639, 585, 268, 787, + 304, 304, 304, 304, 304, 647, 631, 1175, 301, 942, + 105, 639, 1253, 105, 647, 647, 631, 649, 883, 885, + 105, 890, 892, 407, 1272, 1195, 649, 649, 1034, 1207, + 270, 270, 270, 270, 1192, 270, 1208, 1241, 0, 535, + 0, 105, 535, 639, 0, 0, 0, 631, 304, 648, + 631, 304, 780, 98, 105, 0, 270, 402, 648, 648, + 535, 61, 62, 0, 631, 631, 403, 506, 119, 631, + 0, 1026, 304, 0, 0, 534, 535, 273, 273, 273, + 121, 402, 537, 273, 273, 0, 273, 542, 0, 0, + 403, 530, 0, 1026, 1026, 1026, 304, 631, 304, 270, + 0, 780, 1093, 98, 273, 273, 94, 273, 273, 273, + 273, 105, 120, 650, 534, 535, 536, 959, 546, 0, + 525, 537, 650, 650, 93, 0, 127, 402, 105, 0, + 105, 270, 270, 270, 270, 270, 403, 639, 270, 270, + 270, 270, 270, 270, 270, 270, 270, 270, 270, 270, + 270, 270, 546, 641, 270, 270, 270, 270, 273, 0, + 0, 16, 0, 0, 0, 270, 0, 546, 36, 525, + 0, 640, 647, 270, 101, 0, 122, 0, 36, 273, + 0, 647, 647, 402, 526, 0, 324, 105, 100, 0, + 649, 0, 403, 777, 0, 324, 324, 0, 0, 649, + 649, 754, 0, 273, 0, 273, 102, 0, 101, 0, + 16, 301, 301, 301, 270, 270, 270, 301, 301, 270, + 301, 271, 534, 535, 539, 101, 0, 36, 0, 537, + 0, 750, 546, 526, 0, 100, 270, 270, 0, 0, + 270, 301, 301, 301, 301, 301, 270, 0, 271, 271, + 0, 271, 271, 102, 0, 648, 271, 271, 271, 271, + 1140, 0, 717, 718, 719, 720, 270, 270, 631, 631, + 631, 0, 105, 631, 631, 631, 0, 631, 270, 639, + 0, 270, 0, 640, 0, 0, 631, 631, 639, 639, + 0, 270, 301, 0, 750, 631, 631, 0, 631, 631, + 631, 631, 631, 0, 780, 780, 780, 0, 0, 271, + 631, 780, 639, 301, 0, 750, 0, 0, 0, 271, + 271, 0, 105, 631, 631, 631, 631, 631, 631, 631, + 631, 631, 631, 631, 631, 631, 96, 301, 402, 301, + 631, 631, 631, 631, 0, 0, 631, 403, 1092, 631, + 0, 0, 631, 0, 631, 516, 631, 0, 631, 0, + 631, 631, 631, 631, 631, 631, 631, 0, 631, 0, + 631, 270, 0, 0, 0, 546, 0, 525, 0, 270, + 0, 0, 631, 643, 0, 0, 0, 103, 716, 641, + 717, 718, 719, 720, 631, 0, 631, 0, 641, 641, + 546, 546, 525, 525, 516, 270, 373, 640, 366, 367, + 368, 369, 370, 16, 16, 16, 640, 640, 0, 16, + 16, 103, 16, 1114, 852, 1115, 1116, 0, 1117, 0, + 36, 36, 36, 270, 0, 270, 36, 36, 103, 36, + 388, 526, 270, 270, 390, 391, 392, 393, 546, 0, + 110, 546, 113, 525, 546, 454, 525, 0, 270, 1118, + 36, 36, 36, 36, 36, 454, 526, 526, 650, 0, + 112, 0, 546, 0, 525, 0, 534, 535, 541, 271, + 271, 271, 271, 537, 271, 534, 535, 709, 0, 0, + 0, 648, 537, 45, 16, 1182, 454, 314, 0, 454, + 648, 648, 0, 45, 270, 271, 0, 101, 0, 0, + 0, 36, 0, 454, 454, 16, 123, 526, 454, 402, + 526, 0, 270, 0, 0, 1210, 373, 0, 403, 1233, + 0, 0, 36, 0, 270, 534, 535, 750, 526, 16, + 270, 16, 537, 270, 386, 387, 454, 0, 271, 0, + 0, 0, 45, 0, 101, 0, 36, 0, 36, 0, + 388, 0, 389, 109, 390, 391, 392, 393, 0, 0, + 270, 270, 0, 270, 270, 0, 0, 0, 0, 270, + 271, 271, 271, 271, 271, 0, 0, 271, 271, 271, + 271, 271, 271, 271, 271, 271, 271, 271, 271, 271, + 271, 0, 0, 271, 271, 271, 271, 15, 747, 642, + 325, 0, 516, 0, 271, 0, 0, 0, 747, 643, + 0, 0, 271, 92, 0, 0, 0, 1210, 643, 643, + 507, 270, 0, 1210, 607, 607, 607, 516, 516, 270, + 1274, 607, 0, 642, 0, 0, 0, 0, 111, 747, + 0, 117, 747, 0, 0, 0, 15, 1210, 642, 0, + 0, 270, 0, 271, 271, 271, 0, 747, 271, 0, + 639, 1274, 278, 278, 0, 270, 0, 94, 0, 507, + 0, 0, 115, 0, 270, 271, 271, 0, 516, 271, + 642, 516, 270, 0, 0, 271, 0, 111, 301, 303, + 117, 305, 306, 0, 650, 0, 278, 278, 0, 345, + 347, 94, 0, 650, 650, 271, 271, 454, 454, 454, + 103, 0, 454, 454, 454, 0, 454, 271, 94, 639, + 271, 0, 645, 314, 454, 454, 454, 0, 0, 0, + 271, 0, 314, 314, 454, 454, 0, 454, 454, 454, + 454, 454, 0, 0, 0, 45, 45, 45, 641, 454, + 0, 45, 45, 0, 45, 0, 0, 103, 278, 0, + 93, 454, 454, 454, 454, 454, 454, 454, 454, 454, + 454, 454, 454, 454, 454, 45, 45, 45, 45, 454, + 454, 454, 454, 0, 0, 454, 129, 0, 454, 0, + 0, 454, 0, 454, 93, 454, 0, 454, 0, 454, + 454, 454, 454, 454, 454, 454, 0, 454, 454, 454, + 271, 93, 0, 0, 0, 0, 0, 0, 271, 92, + 0, 454, 0, 0, 0, 0, 45, 0, 0, 0, + 0, 0, 0, 454, 270, 454, 325, 0, 0, 0, + 0, 640, 0, 0, 271, 325, 325, 45, 750, 15, + 15, 15, 0, 92, 0, 15, 15, 0, 15, 0, + 747, 747, 747, 0, 0, 747, 747, 747, 751, 747, + 92, 45, 271, 45, 271, 0, 0, 507, 747, 747, + 0, 271, 271, 0, 0, 0, 0, 747, 747, 0, + 747, 747, 747, 747, 747, 111, 639, 271, 117, 128, + 639, 0, 507, 507, 0, 639, 639, 750, 0, 0, + 0, 750, 0, 645, 0, 270, 642, 0, 0, 278, + 278, 278, 347, 645, 278, 642, 642, 0, 0, 0, + 15, 751, 750, 0, 278, 0, 278, 278, 0, 0, + 0, 747, 0, 271, 747, 503, 747, 0, 0, 642, + 0, 15, 751, 507, 645, 639, 507, 645, 645, 111, + 0, 271, 747, 0, 639, 639, 0, 645, 645, 0, + 750, 645, 645, 271, 117, 15, 645, 15, 0, 271, + 0, 0, 271, 0, 641, 0, 747, 0, 747, 0, + 0, 750, 0, 641, 641, 0, 0, 0, 294, 0, + 94, 116, 0, 0, 645, 0, 0, 0, 0, 271, + 271, 0, 271, 271, 0, 0, 0, 95, 271, 0, + 562, 563, 564, 565, 566, 118, 0, 567, 568, 569, + 570, 571, 572, 573, 574, 575, 576, 577, 578, 579, + 580, 96, 0, 581, 582, 583, 584, 94, 0, 0, + 116, 95, 278, 0, 601, 0, 0, 0, 607, 0, + 614, 0, 0, 0, 278, 607, 0, 0, 95, 0, + 271, 0, 0, 0, 118, 96, 0, 640, 271, 0, + 0, 0, 644, 0, 0, 0, 640, 640, 750, 0, + 0, 0, 96, 93, 0, 0, 0, 0, 642, 520, + 271, 278, 0, 607, 607, 607, 646, 110, 278, 268, + 0, 0, 0, 0, 271, 0, 0, 278, 0, 268, + 109, 0, 643, 271, 0, 278, 278, 0, 0, 278, + 0, 271, 0, 520, 0, 306, 639, 0, 0, 0, + 93, 110, 0, 0, 0, 639, 639, 0, 520, 0, + 268, 750, 92, 268, 109, 693, 607, 0, 110, 0, + 0, 0, 106, 0, 0, 119, 0, 278, 268, 0, + 278, 109, 750, 0, 0, 645, 645, 645, 278, 0, + 645, 645, 645, 0, 645, 0, 0, 0, 314, 0, + 0, 0, 0, 645, 645, 0, 106, 0, 0, 92, + 0, 325, 645, 645, 0, 645, 645, 645, 645, 645, + 95, 0, 0, 106, 119, 0, 0, 645, 0, 766, + 766, 766, 0, 0, 0, 766, 766, 114, 766, 645, + 645, 645, 645, 645, 645, 645, 645, 645, 645, 645, + 645, 645, 645, 757, 0, 0, 647, 645, 645, 645, + 645, 0, 657, 645, 0, 0, 645, 642, 116, 645, + 278, 645, 0, 645, 0, 645, 0, 645, 645, 645, + 645, 645, 645, 645, 0, 645, 114, 645, 0, 0, + 0, 0, 118, 271, 0, 0, 751, 278, 0, 645, + 0, 0, 0, 716, 278, 717, 718, 719, 720, 721, + 766, 645, 0, 645, 722, 0, 0, 0, 642, 0, + 767, 767, 767, 0, 0, 0, 767, 767, 644, 767, + 0, 766, 278, 0, 278, 639, 0, 644, 644, 724, + 0, 278, 278, 0, 642, 639, 0, 725, 726, 727, + 728, 0, 646, 642, 642, 766, 0, 766, 0, 751, + 95, 646, 646, 0, 0, 0, 520, 0, 643, 0, + 0, 1156, 0, 0, 271, 1160, 639, 643, 643, 639, + 751, 268, 268, 268, 96, 729, 268, 268, 268, 0, + 268, 520, 520, 639, 639, 0, 111, 0, 639, 268, + 268, 767, 0, 278, 0, 0, 0, 95, 268, 268, + 0, 268, 268, 268, 268, 268, 0, 607, 607, 0, + 0, 278, 767, 268, 607, 607, 639, 0, 0, 0, + 0, 96, 119, 897, 314, 278, 0, 607, 0, 278, + 0, 757, 520, 314, 314, 520, 767, 325, 767, 716, + 110, 717, 718, 719, 720, 751, 325, 325, 0, 268, + 0, 0, 268, 109, 0, 268, 0, 268, 0, 607, + 607, 0, 607, 607, 0, 0, 0, 0, 278, 0, + 0, 0, 0, 268, 0, 852, 0, 0, 0, 757, + 642, 0, 647, 853, 114, 268, 0, 110, 757, 757, + 642, 647, 647, 642, 753, 106, 751, 268, 0, 268, + 109, 0, 642, 642, 0, 0, 1257, 0, 751, 1259, + 1261, 0, 0, 1264, 1265, 757, 0, 0, 0, 0, + 278, 642, 0, 0, 642, 0, 0, 0, 967, 751, + 0, 0, 0, 0, 968, 0, 0, 0, 642, 642, + 0, 114, 106, 642, 642, 0, 0, 0, 0, 0, + 278, 0, 0, 642, 642, 0, 114, 0, 0, 751, + 0, 1283, 1285, 1286, 1287, 0, 0, 0, 0, 0, + 0, 642, 1289, 968, 0, 0, 0, 0, 0, 0, + 751, 278, 750, 750, 750, 0, 750, 639, 639, 639, + 750, 750, 639, 639, 639, 750, 639, 750, 750, 750, + 750, 750, 750, 750, 750, 639, 639, 750, 750, 750, + 750, 750, 750, 750, 639, 639, 750, 639, 639, 639, + 639, 639, 0, 750, 0, 0, 750, 750, 750, 639, + 750, 750, 750, 750, 750, 750, 750, 750, 750, 750, + 750, 639, 639, 639, 639, 639, 639, 639, 639, 639, + 639, 639, 639, 639, 639, 750, 750, 106, 0, 639, + 639, 639, 639, 750, 651, 639, 750, 750, 639, 750, + 750, 639, 750, 639, 750, 639, 750, 639, 750, 639, + 639, 639, 639, 639, 639, 639, 750, 639, 750, 639, + 0, 750, 750, 750, 750, 750, 750, 0, 1086, 0, + 750, 639, 750, 750, 757, 750, 750, 750, 750, 0, + 750, 750, 750, 639, 0, 639, 0, 0, 24, 0, + 0, 0, 0, 1088, 0, 0, 0, 0, 24, 0, + 0, 0, 0, 0, 0, 0, 0, 751, 751, 751, + 278, 751, 642, 642, 642, 751, 751, 642, 642, 642, + 751, 642, 751, 751, 751, 751, 751, 751, 751, 751, + 642, 642, 751, 751, 751, 751, 751, 751, 751, 642, + 642, 751, 642, 642, 642, 642, 642, 24, 751, 0, + 0, 751, 751, 751, 642, 751, 751, 751, 751, 751, + 751, 751, 751, 751, 751, 751, 642, 642, 642, 642, + 642, 642, 642, 642, 642, 642, 642, 642, 642, 642, + 751, 751, 0, 0, 642, 642, 642, 642, 751, 654, + 642, 751, 751, 642, 751, 751, 642, 751, 642, 751, + 642, 751, 642, 751, 642, 642, 642, 642, 642, 642, + 642, 751, 642, 751, 642, 0, 751, 751, 751, 751, + 751, 751, 1029, 0, 757, 751, 642, 751, 751, 0, + 751, 751, 751, 751, 757, 751, 751, 751, 642, 0, + 642, 0, 0, 0, 716, 0, 717, 718, 719, 720, + 721, 0, 0, 0, 0, 722, 1086, 0, 373, 1086, + 0, 1086, 757, 1086, 0, 757, 438, 436, 757, 436, + 436, 436, 436, 436, 0, 0, 386, 387, 436, 0, + 724, 1088, 757, 757, 1088, 125, 0, 757, 1088, 0, + 727, 728, 388, 436, 389, 0, 390, 391, 392, 393, + 0, 0, 396, 436, 397, 0, 1103, 0, 0, 0, + 757, 436, 436, 436, 436, 757, 0, 0, 0, 757, + 757, 0, 0, 0, 0, 753, 729, 0, 0, 0, + 716, 0, 717, 718, 719, 720, 721, 0, 438, 0, + 0, 722, 1137, 0, 0, 0, 757, 0, 0, 436, + 24, 24, 24, 0, 0, 0, 24, 24, 753, 24, + 1086, 0, 1086, 0, 1086, 0, 724, 1086, 753, 0, + 0, 0, 0, 125, 725, 726, 727, 728, 0, 0, + 24, 24, 24, 24, 24, 1088, 0, 1088, 1086, 1088, + 0, 0, 1088, 0, 0, 1177, 0, 0, 0, 753, + 0, 716, 753, 717, 718, 719, 720, 0, 0, 0, + 0, 0, 729, 1088, 0, 0, 753, 753, 0, 124, + 1103, 753, 0, 0, 373, 0, 0, 1103, 1103, 378, + 379, 24, 0, 0, 0, 0, 0, 852, 0, 0, + 0, 0, 386, 387, 0, 1063, 0, 0, 0, 753, + 0, 0, 24, 0, 0, 0, 0, 0, 388, 0, + 389, 0, 390, 391, 392, 393, 394, 395, 396, 0, + 397, 0, 0, 0, 0, 0, 24, 0, 24, 294, + 0, 753, 753, 753, 0, 753, 757, 757, 757, 753, + 753, 757, 757, 757, 753, 757, 753, 753, 753, 753, + 753, 753, 753, 757, 757, 757, 753, 753, 753, 753, + 753, 753, 753, 757, 757, 753, 757, 757, 757, 757, + 757, 0, 753, 0, 0, 753, 753, 753, 757, 753, + 753, 753, 753, 753, 753, 753, 753, 753, 753, 753, + 757, 757, 757, 757, 757, 757, 757, 757, 757, 757, + 757, 757, 757, 757, 753, 753, 0, 0, 757, 757, + 757, 757, 753, 1016, 757, 753, 753, 757, 753, 753, + 757, 753, 757, 753, 757, 753, 757, 753, 757, 757, + 757, 757, 757, 757, 757, 753, 757, 757, 757, 0, + 753, 753, 753, 753, 753, 753, 0, 0, 0, 753, + 757, 753, 753, 0, 753, 753, 753, 753, 105, 753, + 753, 753, 757, 0, 757, 753, 753, 753, 0, 753, + 753, 753, 753, 753, 753, 753, 753, 753, 753, 753, + 753, 753, 753, 753, 753, 753, 753, 753, 753, 753, + 753, 753, 753, 753, 753, 753, 753, 753, 753, 753, + 753, 753, 753, 753, 753, 753, 753, 0, 0, 753, + 753, 753, 753, 753, 753, 753, 753, 753, 753, 753, + 753, 753, 753, 753, 753, 753, 753, 753, 753, 753, + 753, 753, 753, 753, 753, 753, 753, 753, 753, 753, + 0, 0, 753, 753, 753, 753, 753, 0, 753, 753, + 753, 753, 753, 753, 753, 753, 753, 753, 753, 753, + 753, 753, 753, 753, 753, 753, 753, 753, 753, 753, + 753, 753, 753, 0, 753, 753, 753, 753, 753, 753, + 0, 0, 754, 753, 753, 753, 753, 0, 753, 753, + 753, 753, 754, 753, 753, 753, 753, 0, 753, 0, + 0, 0, 0, 0, 998, 999, 1000, 1001, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1002, 1003, 1004, 754, 1005, 0, 754, 0, 1006, 0, + 0, 40, 0, 716, 262, 717, 718, 719, 720, 721, + 754, 754, 0, 126, 722, 754, 0, 0, 0, 1008, + 1009, 0, 0, 0, 0, 0, 0, 1010, 0, 723, + 1011, 0, 0, 0, 1012, 0, 1013, 0, 1014, 724, + 0, 0, 0, 754, 0, 0, 0, 725, 726, 727, + 728, 0, 0, 0, 0, 54, 55, 56, 57, 58, + 59, 0, 0, 753, 60, 0, 0, 0, 0, 63, + 64, 65, 66, 0, 67, 68, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 729, 315, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 315, 0, 998, 999, + 1000, 1001, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 753, 0, 0, 1002, 1003, 1004, 0, 0, 0, + 753, 753, 0, 0, 0, 40, 753, 315, 262, 0, + 315, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 315, 315, 0, 753, 0, 315, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 124, 0, 0, 315, 0, 54, + 55, 56, 57, 58, 59, 0, 0, 0, 60, 0, + 0, 0, 0, 63, 64, 65, 66, 0, 67, 68, + 0, 0, 511, 0, 0, 0, 0, 0, 0, 754, + 754, 754, 0, 754, 754, 754, 754, 754, 754, 754, + 754, 754, 754, 754, 754, 754, 754, 754, 754, 754, + 754, 754, 754, 754, 754, 754, 754, 754, 754, 754, + 754, 754, 754, 754, 754, 754, 754, 754, 754, 0, + 754, 511, 0, 754, 754, 754, 754, 754, 754, 754, + 754, 754, 754, 754, 754, 754, 754, 754, 754, 754, + 754, 754, 754, 754, 754, 754, 754, 754, 754, 754, + 754, 754, 754, 754, 0, 0, 754, 754, 754, 754, + 754, 0, 754, 754, 754, 754, 754, 754, 754, 754, + 754, 754, 754, 754, 754, 754, 754, 754, 754, 754, + 754, 754, 754, 754, 754, 754, 754, 0, 754, 754, + 754, 754, 754, 754, 0, 0, 0, 754, 754, 754, + 754, 0, 754, 754, 754, 754, 107, 754, 754, 754, + 754, 0, 754, 752, 752, 752, 0, 752, 315, 315, + 315, 752, 752, 315, 315, 315, 752, 315, 752, 752, + 752, 752, 752, 752, 752, 752, 315, 315, 752, 752, + 752, 752, 752, 752, 752, 315, 315, 752, 315, 315, + 315, 315, 315, 754, 752, 0, 0, 752, 752, 752, + 315, 752, 752, 752, 752, 752, 752, 752, 752, 752, + 752, 752, 315, 315, 315, 315, 315, 315, 315, 315, + 315, 315, 315, 315, 315, 315, 752, 752, 0, 0, + 315, 315, 315, 315, 752, 0, 315, 752, 752, 315, + 752, 752, 315, 752, 315, 752, 315, 752, 315, 752, + 315, 315, 315, 315, 315, 315, 315, 752, 315, 752, + 315, 0, 752, 752, 752, 752, 752, 752, 0, 511, + 758, 752, 315, 752, 752, 0, 752, 752, 752, 752, + 758, 752, 752, 752, 315, 0, 315, 0, 0, 0, + 0, 0, 0, 0, 511, 511, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 758, 0, 0, 758, 0, 0, 0, 0, 0, + 0, 0, 0, 586, 587, 0, 0, 588, 758, 758, + 0, 162, 163, 758, 164, 165, 166, 167, 168, 169, + 170, 0, 0, 171, 172, 511, 0, 0, 511, 0, + 173, 174, 175, 176, 0, 0, 0, 0, 0, 0, + 290, 758, 0, 0, 0, 0, 0, 178, 179, 0, + 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, + 190, 754, 0, 191, 373, 374, 375, 376, 377, 378, + 379, 380, 381, 382, 383, 0, 0, 0, 0, 0, + 0, 0, 386, 387, 759, 192, 0, 0, 0, 0, + 0, 0, 0, 0, 759, 0, 0, 0, 388, 0, + 389, 0, 390, 391, 392, 393, 394, 395, 396, 754, + 397, 0, 0, 0, 0, 0, 0, 0, 754, 754, + 0, 0, 0, 0, 754, 759, 0, 0, 759, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 759, 759, 0, 754, 0, 759, 373, 374, + 375, 376, 377, 378, 379, 380, 0, 382, 383, 0, + 0, 0, 0, 0, 0, 0, 386, 387, 0, 0, + 0, 0, 126, 0, 0, 759, 0, 0, 0, 0, 0, 0, 388, 0, 389, 0, 390, 391, 392, 393, - 394, 395, 396, 0, 397, 314, 0, 0, 0, 0, - 0, 0, 0, 0, 314, 314, 0, 0, 0, 0, - 647, 647, 647, 0, 647, 651, 651, 651, 647, 647, - 651, 651, 651, 647, 651, 647, 647, 647, 647, 647, - 647, 647, 651, 651, 651, 651, 647, 647, 647, 647, - 647, 647, 647, 651, 651, 647, 651, 651, 651, 651, - 651, 0, 647, 0, 0, 647, 647, 647, 651, 647, - 647, 647, 647, 647, 647, 647, 647, 647, 647, 647, - 651, 651, 651, 651, 651, 651, 651, 651, 651, 651, - 651, 651, 651, 651, 647, 647, 0, 398, 651, 651, - 651, 651, 647, 0, 651, 647, 647, 651, 647, 647, - 651, 647, 651, 647, 651, 647, 651, 647, 651, 651, - 651, 651, 651, 651, 651, 647, 651, 651, 651, 0, - 647, 647, 647, 647, 647, 647, 0, 0, 293, 647, - 651, 647, 647, 0, 647, 647, 647, 647, 293, 647, - 647, 647, 651, 647, 647, 647, 0, 647, 647, 647, - 647, 647, 647, 647, 647, 647, 647, 647, 647, 647, - 647, 647, 647, 647, 647, 647, 647, 647, 647, 647, - 647, 647, 647, 647, 647, 647, 647, 647, 647, 647, - 647, 647, 647, 647, 0, 647, 0, 293, 647, 647, - 647, 647, 647, 647, 647, 647, 647, 647, 647, 647, - 647, 647, 647, 647, 647, 647, 647, 647, 647, 647, - 647, 647, 647, 647, 647, 647, 647, 647, 647, 109, - 0, 647, 647, 647, 647, 647, 0, 647, 647, 647, - 647, 647, 647, 647, 647, 647, 647, 647, 647, 647, - 647, 647, 647, 647, 647, 647, 647, 647, 647, 647, - 647, 647, 0, 647, 647, 647, 647, 647, 647, 0, - 0, 648, 647, 647, 647, 647, 325, 647, 647, 647, - 647, 648, 647, 647, 647, 647, 0, 0, 0, 0, - 0, 0, 0, 0, 438, 436, 0, 436, 436, 436, - 436, 436, 0, 0, 0, 0, 436, 0, 0, 0, - 0, 0, 0, 0, 0, 648, 0, 0, 0, 0, - 0, 436, 0, 0, 0, 0, 0, 0, 0, 648, - 648, 436, 126, 0, 648, 0, 0, 0, 0, 436, - 436, 436, 436, 0, 0, 0, 0, 0, 0, 0, - 0, 373, 374, 375, 376, 377, 378, 379, 380, 381, - 382, 383, 648, 384, 385, 0, 438, 0, 0, 386, - 387, 0, 0, 0, 0, 0, 0, 436, 0, 0, - 0, 0, 0, 0, 0, 388, 0, 389, 0, 390, - 391, 392, 393, 394, 395, 396, 0, 397, 0, 0, - 293, 293, 293, 0, 315, 293, 293, 293, 0, 293, - 0, 0, 0, 0, 315, 0, 0, 293, 0, 293, - 293, 0, 0, 0, 0, 0, 0, 0, 293, 293, - 0, 293, 293, 293, 293, 293, 0, 373, 374, 375, - 376, 377, 378, 379, 380, 381, 382, 383, 315, 0, - 0, 0, 0, 0, 0, 386, 387, 0, 0, 0, - 0, 0, 315, 315, 128, 0, 0, 315, 0, 0, - 0, 388, 0, 389, 0, 390, 391, 392, 393, 394, - 395, 396, 293, 397, 0, 293, 0, 293, 0, 0, - 0, 0, 0, 0, 0, 315, 0, 0, 0, 0, - 0, 0, 0, 293, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 325, 0, 0, 0, 0, 0, 0, - 0, 0, 325, 325, 0, 0, 0, 293, 648, 648, - 648, 0, 648, 648, 648, 648, 648, 648, 648, 648, - 648, 648, 648, 648, 648, 648, 648, 648, 648, 648, - 648, 648, 648, 648, 648, 648, 648, 648, 648, 648, - 648, 648, 648, 648, 648, 648, 648, 648, 648, 0, - 648, 0, 0, 648, 648, 648, 648, 648, 648, 648, - 648, 648, 648, 648, 648, 648, 648, 648, 648, 648, - 648, 648, 648, 648, 648, 648, 648, 648, 648, 648, - 648, 648, 648, 648, 0, 0, 648, 648, 648, 648, - 648, 0, 648, 648, 648, 648, 648, 648, 648, 648, - 648, 648, 648, 648, 648, 648, 648, 648, 648, 648, - 648, 648, 648, 648, 648, 648, 648, 0, 648, 648, - 648, 648, 648, 648, 0, 0, 674, 648, 648, 648, - 648, 0, 648, 648, 648, 648, 674, 648, 648, 648, - 648, 646, 646, 646, 0, 646, 315, 315, 315, 646, - 646, 315, 315, 315, 646, 315, 646, 646, 646, 646, - 646, 646, 646, 315, 646, 315, 315, 646, 646, 646, - 646, 646, 646, 646, 315, 315, 646, 315, 315, 315, - 315, 315, 0, 646, 0, 674, 646, 646, 646, 315, - 646, 646, 646, 646, 646, 646, 646, 646, 646, 646, - 646, 315, 315, 315, 315, 315, 315, 315, 315, 315, - 315, 315, 315, 315, 315, 646, 646, 0, 0, 315, - 315, 315, 315, 646, 0, 315, 646, 646, 315, 646, - 646, 315, 646, 315, 646, 315, 646, 315, 646, 315, - 315, 315, 315, 315, 315, 315, 646, 315, 646, 315, - 0, 646, 646, 646, 646, 646, 646, 0, 0, 652, - 646, 315, 646, 646, 0, 646, 646, 646, 646, 652, - 646, 646, 646, 315, 0, 0, 0, 0, 0, 586, - 587, 0, 0, 588, 0, 0, 0, 162, 163, 0, - 164, 165, 166, 167, 168, 169, 170, 0, 0, 171, - 172, 0, 0, 652, 0, 0, 173, 174, 175, 176, - 0, 0, 0, 0, 0, 0, 289, 652, 652, 0, - 0, 0, 652, 178, 179, 0, 180, 181, 182, 183, - 184, 185, 186, 187, 188, 189, 190, 0, 0, 191, + 394, 395, 396, 0, 397, 0, 0, 0, 0, 0, + 508, 0, 0, 0, 0, 0, 0, 755, 755, 755, + 0, 755, 758, 758, 758, 755, 755, 758, 758, 758, + 755, 758, 755, 755, 755, 755, 755, 755, 755, 758, + 758, 758, 755, 755, 755, 755, 755, 755, 755, 758, + 758, 755, 758, 758, 758, 758, 758, 0, 755, 508, + 0, 755, 755, 755, 758, 755, 755, 755, 755, 755, + 755, 755, 755, 755, 755, 755, 758, 758, 758, 758, + 758, 758, 758, 758, 758, 758, 758, 758, 758, 758, + 755, 755, 0, 0, 758, 758, 758, 758, 755, 0, + 758, 755, 755, 758, 755, 755, 758, 755, 758, 755, + 758, 755, 758, 755, 758, 758, 758, 758, 758, 758, + 758, 755, 758, 758, 758, 0, 755, 755, 755, 755, + 755, 755, 0, 0, 0, 755, 758, 755, 755, 0, + 755, 755, 755, 755, 517, 755, 755, 755, 758, 0, + 758, 756, 756, 756, 0, 756, 759, 759, 759, 756, + 756, 759, 759, 759, 756, 759, 756, 756, 756, 756, + 756, 756, 756, 759, 759, 759, 756, 756, 756, 756, + 756, 756, 756, 759, 759, 756, 759, 759, 759, 759, + 759, 0, 756, 517, 0, 756, 756, 756, 759, 756, + 756, 756, 756, 756, 756, 756, 756, 756, 756, 756, + 759, 759, 759, 759, 759, 759, 759, 759, 759, 759, + 759, 759, 759, 759, 756, 756, 0, 0, 759, 759, + 759, 759, 756, 0, 759, 756, 756, 759, 756, 756, + 759, 756, 759, 756, 759, 756, 759, 756, 759, 759, + 759, 759, 759, 759, 759, 756, 759, 759, 759, 0, + 756, 756, 756, 756, 756, 756, 0, 508, 324, 756, + 759, 756, 756, 0, 756, 756, 756, 756, 324, 756, + 756, 756, 759, 0, 759, 0, 0, 0, 0, 0, + 0, 0, 508, 508, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 324, + 0, 0, 324, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 595, 596, 324, 324, 597, 127, + 0, 324, 162, 163, 0, 164, 165, 166, 167, 168, + 169, 170, 0, 508, 171, 172, 508, 0, 0, 0, + 0, 173, 174, 175, 176, 0, 0, 0, 0, 324, + 0, 290, 0, 0, 0, 0, 0, 0, 178, 179, + 0, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 190, 0, 0, 191, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 652, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 192, 0, 0, 0, 716, 0, 717, 718, 719, - 720, 721, 0, 0, 0, 0, 722, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 674, 674, - 674, 723, 653, 674, 674, 674, 0, 674, 0, 0, - 0, 724, 653, 0, 0, 674, 0, 674, 674, 725, - 726, 727, 728, 0, 0, 0, 674, 674, 0, 674, - 674, 674, 674, 674, 0, 373, 374, 375, 376, 377, - 378, 379, 380, 0, 382, 383, 653, 0, 0, 0, - 0, 0, 0, 386, 387, 0, 0, 729, 0, 0, - 653, 653, 0, 0, 0, 653, 0, 0, 0, 388, - 0, 389, 0, 390, 391, 392, 393, 394, 395, 396, - 674, 397, 0, 674, 0, 674, 0, 0, 0, 0, - 0, 0, 0, 653, 0, 0, 0, 0, 0, 0, - 0, 674, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 674, 649, 649, 649, 0, - 649, 652, 652, 652, 649, 649, 652, 652, 652, 649, - 652, 649, 649, 649, 649, 649, 649, 649, 652, 652, - 652, 652, 649, 649, 649, 649, 649, 649, 649, 652, - 652, 649, 652, 652, 652, 652, 652, 0, 649, 0, - 0, 649, 649, 649, 652, 649, 649, 649, 649, 649, - 649, 649, 649, 649, 649, 649, 652, 652, 652, 652, - 652, 652, 652, 652, 652, 652, 652, 652, 652, 652, - 649, 649, 0, 0, 652, 652, 652, 652, 649, 0, - 652, 649, 649, 652, 649, 649, 652, 649, 652, 649, - 652, 649, 652, 649, 652, 652, 652, 652, 652, 652, - 652, 649, 652, 652, 652, 0, 649, 649, 649, 649, - 649, 649, 0, 0, 61, 649, 652, 649, 649, 0, - 649, 649, 649, 649, 61, 649, 649, 649, 652, 650, - 650, 650, 0, 650, 653, 653, 653, 650, 650, 653, - 653, 653, 650, 653, 650, 650, 650, 650, 650, 650, - 650, 653, 653, 653, 653, 650, 650, 650, 650, 650, - 650, 650, 653, 653, 650, 653, 653, 653, 653, 653, - 0, 650, 0, 61, 650, 650, 650, 653, 650, 650, - 650, 650, 650, 650, 650, 650, 650, 650, 650, 653, - 653, 653, 653, 653, 653, 653, 653, 653, 653, 653, - 653, 653, 653, 650, 650, 0, 0, 653, 653, 653, - 653, 650, 0, 653, 650, 650, 653, 650, 650, 653, - 650, 653, 650, 653, 650, 653, 650, 653, 653, 653, - 653, 653, 653, 653, 650, 653, 653, 653, 0, 650, - 650, 650, 650, 650, 650, 0, 0, 324, 650, 653, - 650, 650, 0, 650, 650, 650, 650, 324, 650, 650, - 650, 653, 0, 0, 0, 0, 0, 595, 596, 0, - 0, 597, 0, 0, 0, 162, 163, 0, 164, 165, - 166, 167, 168, 169, 170, 0, 0, 171, 172, 0, - 0, 324, 0, 0, 173, 174, 175, 176, 0, 0, - 0, 0, 0, 0, 289, 324, 324, 0, 127, 0, - 324, 178, 179, 0, 180, 181, 182, 183, 184, 185, - 186, 187, 188, 189, 190, 0, 0, 191, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 324, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 192, - 0, 0, 0, 716, 0, 717, 718, 719, 720, 721, - 0, 0, 0, 0, 722, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 61, 61, 61, 0, - 453, 61, 61, 61, 0, 61, 0, 0, 0, 724, - 453, 0, 0, 61, 0, 61, 61, 725, 726, 727, - 728, 0, 0, 0, 61, 61, 0, 61, 61, 61, - 61, 61, 0, 373, 374, 375, 376, 377, 378, 379, - 0, 0, 382, 383, 453, 0, 0, 0, 0, 0, - 0, 386, 387, 0, 0, 729, 0, 0, 0, 453, - 0, 0, 0, 453, 0, 0, 0, 388, 0, 389, - 0, 390, 391, 392, 393, 394, 395, 396, 61, 397, - 0, 61, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 453, 0, 0, 0, 0, 0, 0, 0, 61, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 195, 0, 0, 0, - 0, 0, 0, 61, 648, 648, 648, 0, 648, 324, - 324, 324, 648, 648, 324, 324, 324, 648, 324, 648, - 648, 648, 648, 648, 648, 648, 324, 0, 324, 324, - 648, 648, 648, 648, 648, 648, 648, 324, 324, 648, - 324, 324, 324, 324, 324, 195, 648, 0, 0, 648, - 648, 648, 324, 648, 648, 648, 648, 648, 648, 648, - 648, 648, 648, 648, 324, 324, 324, 324, 324, 324, - 324, 324, 324, 324, 324, 324, 324, 324, 648, 648, - 0, 0, 324, 324, 324, 324, 648, 0, 324, 648, - 648, 324, 648, 648, 324, 648, 324, 648, 324, 648, - 324, 648, 324, 324, 324, 324, 324, 324, 324, 648, - 324, 0, 324, 0, 648, 648, 648, 648, 648, 648, - 0, 0, 0, 648, 324, 648, 648, 0, 648, 648, - 648, 648, 0, 648, 648, 648, 324, 290, 290, 290, - 0, 290, 453, 453, 453, 290, 290, 453, 453, 453, - 290, 453, 290, 290, 290, 290, 290, 290, 290, 453, - 453, 453, 453, 290, 290, 290, 290, 290, 290, 290, - 453, 453, 290, 453, 453, 453, 453, 453, 0, 290, - 0, 0, 290, 290, 290, 0, 290, 290, 290, 290, - 290, 290, 290, 290, 290, 290, 290, 453, 453, 453, + 0, 517, 453, 0, 0, 0, 192, 0, 0, 0, + 0, 0, 453, 373, 374, 375, 376, 377, 378, 379, + 0, 0, 382, 383, 0, 0, 517, 517, 0, 0, + 0, 386, 387, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 453, 0, 0, 453, 388, 0, 389, + 0, 390, 391, 392, 393, 394, 395, 396, 0, 397, + 0, 453, 0, 0, 0, 453, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 517, 0, 0, + 517, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 453, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 207, 0, 0, 121, + 0, 0, 0, 0, 0, 754, 754, 754, 0, 754, + 324, 324, 324, 754, 754, 324, 324, 324, 754, 324, + 754, 754, 754, 754, 754, 754, 754, 0, 324, 324, + 754, 754, 754, 754, 754, 754, 754, 324, 324, 754, + 324, 324, 324, 324, 324, 207, 754, 0, 121, 754, + 754, 754, 324, 754, 754, 754, 754, 754, 754, 754, + 754, 754, 754, 754, 324, 324, 324, 324, 324, 324, + 324, 324, 324, 324, 324, 324, 324, 324, 754, 754, + 649, 0, 324, 324, 324, 324, 754, 0, 324, 754, + 754, 324, 754, 754, 324, 754, 324, 754, 324, 754, + 324, 754, 324, 324, 324, 324, 324, 324, 324, 754, + 324, 0, 324, 0, 754, 754, 754, 754, 754, 754, + 0, 0, 0, 754, 324, 754, 754, 0, 754, 754, + 754, 754, 0, 754, 754, 754, 324, 0, 324, 290, + 290, 290, 0, 290, 453, 453, 453, 290, 290, 453, + 453, 453, 290, 453, 290, 290, 290, 290, 290, 290, + 290, 453, 453, 453, 290, 290, 290, 290, 290, 290, + 290, 453, 453, 290, 453, 453, 453, 453, 453, 0, + 290, 0, 0, 290, 290, 290, 0, 290, 290, 290, + 290, 290, 290, 290, 290, 290, 290, 290, 453, 453, 453, 453, 453, 453, 453, 453, 453, 453, 453, 453, - 453, 290, 290, 673, 0, 453, 453, 453, 453, 290, - 0, 453, 290, 673, 453, 290, 290, 453, 290, 453, - 290, 453, 290, 453, 290, 453, 453, 453, 453, 453, - 453, 453, 290, 453, 453, 453, 0, 290, 290, 290, - 290, 290, 290, 0, 0, 0, 290, 673, 290, 290, - 0, 290, 290, 290, 290, 0, 290, 290, 290, 453, - 0, 0, 673, 0, 0, 0, 673, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 195, 0, 195, 195, 195, 195, 195, 0, - 0, 0, 0, 195, 673, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 541, 0, 0, 0, 195, 0, - 0, 0, 0, 0, 541, 0, 0, 0, 195, 195, - 0, 0, 0, 0, 0, 0, 195, 195, 195, 195, - 0, 0, 0, 0, 0, 0, 331, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 331, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 652, 587, 0, - 0, 653, 0, 0, 195, 162, 163, 0, 164, 165, - 166, 167, 168, 169, 170, 0, 0, 171, 172, 0, - 331, 0, 0, 0, 173, 174, 175, 176, 0, 0, - 0, 0, 0, 0, 289, 331, 0, 0, 0, 331, - 0, 178, 179, 0, 180, 181, 182, 183, 184, 185, - 186, 187, 188, 189, 190, 0, 0, 191, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 331, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 192, + 453, 453, 290, 290, 780, 0, 453, 453, 453, 453, + 290, 0, 453, 290, 780, 453, 290, 290, 453, 290, + 453, 290, 453, 290, 453, 290, 453, 453, 453, 453, + 453, 453, 453, 290, 453, 453, 453, 0, 290, 290, + 290, 290, 290, 290, 0, 780, 121, 290, 780, 290, + 290, 0, 290, 290, 290, 290, 0, 290, 290, 290, + 453, 0, 453, 780, 0, 0, 0, 780, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 177, 0, 0, 0, 0, 0, 0, 0, - 290, 290, 290, 0, 290, 673, 673, 673, 290, 290, - 673, 673, 673, 290, 673, 290, 290, 290, 290, 290, - 290, 290, 673, 673, 673, 673, 290, 290, 290, 290, - 290, 290, 290, 673, 673, 290, 673, 673, 673, 673, - 673, 177, 290, 0, 0, 290, 290, 290, 0, 290, + 0, 207, 0, 207, 207, 207, 207, 207, 0, 0, + 0, 0, 207, 0, 0, 780, 0, 0, 0, 0, + 0, 0, 0, 645, 0, 0, 649, 207, 0, 0, + 0, 0, 0, 645, 0, 649, 649, 207, 207, 0, + 0, 0, 0, 0, 0, 207, 207, 207, 207, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 331, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 331, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 602, 596, 0, 207, 603, 0, 0, 0, 162, 163, + 0, 164, 165, 166, 167, 168, 169, 170, 0, 331, + 171, 172, 331, 0, 0, 0, 0, 173, 174, 175, + 176, 0, 0, 0, 0, 0, 0, 331, 0, 0, + 0, 331, 0, 0, 178, 179, 0, 180, 181, 182, + 183, 184, 185, 186, 187, 188, 189, 190, 0, 0, + 191, 0, 0, 0, 0, 0, 0, 0, 0, 331, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 192, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 200, 0, 509, 120, 0, 0, 0, 0, + 0, 290, 290, 290, 0, 290, 780, 780, 780, 290, + 290, 780, 780, 780, 290, 780, 290, 290, 290, 290, + 290, 290, 290, 780, 780, 780, 290, 290, 290, 290, + 290, 290, 290, 780, 780, 290, 780, 780, 780, 780, + 780, 200, 290, 509, 120, 290, 290, 290, 0, 290, 290, 290, 290, 290, 290, 290, 290, 290, 290, 290, - 673, 673, 673, 673, 673, 673, 673, 673, 673, 673, - 673, 673, 673, 673, 290, 290, 0, 0, 673, 673, - 673, 673, 290, 0, 673, 290, 0, 673, 290, 290, - 673, 290, 673, 290, 673, 290, 673, 290, 673, 673, - 673, 673, 673, 673, 673, 290, 673, 673, 673, 0, + 780, 780, 780, 780, 780, 780, 780, 780, 780, 780, + 780, 780, 780, 780, 290, 290, 648, 0, 780, 780, + 780, 780, 290, 0, 780, 290, 0, 780, 290, 290, + 780, 290, 780, 290, 780, 290, 780, 290, 780, 780, + 780, 780, 780, 780, 780, 290, 780, 780, 780, 0, 290, 290, 290, 290, 290, 290, 0, 0, 0, 290, - 0, 290, 290, 0, 290, 290, 290, 290, 0, 290, - 290, 290, 673, 290, 290, 290, 0, 290, 331, 331, - 331, 290, 290, 331, 331, 331, 290, 331, 290, 290, - 290, 290, 290, 290, 290, 331, 0, 331, 331, 290, - 290, 290, 290, 290, 290, 290, 331, 331, 290, 331, - 331, 331, 331, 331, 0, 290, 0, 0, 290, 290, - 290, 0, 290, 290, 290, 290, 290, 290, 290, 290, - 290, 290, 290, 331, 331, 331, 331, 331, 331, 331, - 331, 331, 331, 331, 331, 331, 331, 290, 290, 533, - 0, 331, 331, 331, 331, 290, 0, 331, 290, 533, - 331, 290, 290, 331, 290, 331, 290, 331, 290, 331, - 290, 331, 331, 331, 331, 331, 331, 331, 290, 331, - 0, 331, 0, 290, 290, 290, 290, 290, 290, 0, - 0, 0, 290, 92, 290, 290, 0, 290, 290, 290, - 290, 0, 290, 290, 290, 331, 0, 0, 533, 0, - 111, 0, 533, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 177, 0, - 177, 177, 177, 177, 177, 0, 0, 0, 0, 177, - 533, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 543, 0, 0, 0, 177, 0, 0, 0, 0, 0, - 543, 0, 0, 0, 177, 177, 0, 0, 0, 0, - 0, 0, 177, 177, 177, 177, 0, 0, 0, 0, - 0, 0, 536, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 536, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 655, 596, 0, 0, 656, 0, 0, - 177, 162, 163, 0, 164, 165, 166, 167, 168, 169, - 170, 0, 0, 171, 172, 0, 95, 0, 0, 0, - 173, 174, 175, 176, 0, 0, 0, 0, 0, 0, - 289, 536, 0, 114, 0, 536, 0, 178, 179, 0, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 190, 0, 0, 191, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 536, 0, 0, 0, 0, 0, 0, - 0, 178, 0, 0, 0, 192, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 644, 644, 644, 0, - 644, 533, 533, 533, 644, 644, 0, 533, 533, 644, - 533, 644, 644, 644, 644, 644, 644, 644, 533, 644, - 178, 0, 644, 644, 644, 644, 644, 644, 644, 533, - 533, 644, 533, 533, 533, 533, 533, 0, 644, 0, - 0, 644, 644, 644, 0, 644, 644, 644, 644, 644, - 644, 644, 644, 644, 644, 644, 533, 533, 533, 533, - 533, 533, 533, 533, 533, 533, 533, 533, 533, 533, - 644, 644, 0, 0, 533, 533, 533, 533, 644, 545, - 0, 644, 644, 533, 644, 644, 0, 644, 0, 644, - 533, 644, 533, 644, 533, 533, 533, 533, 533, 533, - 533, 644, 533, 644, 533, 0, 644, 644, 644, 644, - 644, 644, 0, 0, 65, 644, 0, 644, 644, 0, - 644, 644, 644, 644, 65, 644, 644, 644, 533, 645, - 645, 645, 0, 645, 536, 536, 536, 645, 645, 0, - 536, 536, 645, 536, 645, 645, 645, 645, 645, 645, - 645, 536, 645, 0, 0, 645, 645, 645, 645, 645, - 645, 645, 536, 536, 645, 536, 536, 536, 536, 536, - 0, 645, 0, 65, 645, 645, 645, 0, 645, 645, - 645, 645, 645, 645, 645, + 0, 290, 290, 0, 290, 290, 290, 290, 512, 290, + 290, 290, 780, 0, 780, 290, 290, 290, 0, 290, + 331, 331, 331, 290, 290, 331, 331, 331, 290, 331, + 290, 290, 290, 290, 290, 290, 290, 0, 331, 331, + 290, 290, 290, 290, 290, 290, 290, 331, 331, 290, + 331, 331, 331, 331, 331, 0, 290, 512, 0, 290, + 290, 290, 0, 290, 290, 290, 290, 290, 290, 290, + 290, 290, 290, 290, 331, 331, 331, 331, 331, 331, + 331, 331, 331, 331, 331, 331, 331, 331, 290, 290, + 639, 0, 331, 331, 331, 331, 290, 0, 331, 290, + 639, 331, 290, 290, 331, 290, 331, 290, 331, 290, + 331, 290, 331, 331, 331, 331, 331, 331, 331, 290, + 331, 0, 331, 0, 290, 290, 290, 290, 290, 290, + 0, 509, 120, 290, 92, 290, 290, 0, 290, 290, + 290, 290, 0, 290, 290, 290, 331, 0, 331, 639, + 0, 111, 0, 639, 0, 0, 509, 509, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 200, 0, 200, + 200, 200, 200, 200, 0, 0, 0, 0, 200, 0, + 0, 639, 0, 0, 0, 0, 0, 0, 0, 644, + 0, 0, 648, 200, 0, 0, 0, 0, 0, 644, + 0, 648, 648, 200, 200, 0, 0, 509, 0, 0, + 509, 200, 200, 200, 200, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 642, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 642, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 200, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 512, 0, 0, 95, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 642, 0, 114, 0, 642, 0, 0, + 512, 512, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 324, 0, + 0, 0, 0, 0, 0, 642, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 512, 324, 0, 512, 0, 0, 750, 750, 750, + 0, 750, 639, 639, 639, 750, 750, 324, 639, 639, + 750, 639, 750, 750, 750, 750, 750, 750, 750, 750, + 0, 0, 750, 750, 750, 750, 750, 750, 750, 639, + 639, 750, 639, 639, 639, 639, 639, 210, 750, 324, + 0, 750, 750, 750, 0, 750, 750, 750, 750, 750, + 750, 750, 750, 750, 750, 750, 639, 639, 639, 639, + 639, 639, 639, 639, 639, 639, 639, 639, 639, 639, + 750, 750, 0, 0, 639, 639, 639, 639, 750, 651, + 0, 750, 750, 639, 750, 750, 210, 750, 294, 750, + 639, 750, 639, 750, 639, 639, 639, 639, 639, 639, + 639, 750, 639, 750, 639, 0, 750, 750, 750, 750, + 750, 750, 0, 0, 0, 750, 0, 750, 750, 0, + 750, 750, 750, 750, 0, 750, 750, 750, 639, 0, + 639, 751, 751, 751, 0, 751, 642, 642, 642, 751, + 751, 398, 642, 642, 751, 642, 751, 751, 751, 751, + 751, 751, 751, 751, 0, 0, 751, 751, 751, 751, + 751, 751, 751, 642, 642, 751, 642, 642, 642, 642, + 642, 0, 751, 0, 0, 751, 751, 751, 0, 751, + 751, 751, 751, 751, 751, 751, 751, 751, 751, 751, + 642, 642, 642, 642, 642, 642, 642, 642, 642, 642, + 642, 642, 642, 642, 751, 751, 0, 0, 642, 642, + 642, 642, 751, 654, 0, 751, 751, 642, 751, 751, + 0, 751, 0, 751, 642, 751, 642, 751, 642, 642, + 642, 642, 642, 642, 642, 751, 642, 751, 642, 0, + 751, 751, 751, 751, 751, 751, 0, 0, 757, 751, + 0, 751, 751, 0, 751, 751, 751, 751, 757, 751, + 751, 751, 642, 0, 642, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 324, 0, 0, 0, 0, + 0, 0, 0, 0, 324, 324, 0, 0, 0, 0, + 754, 0, 106, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 757, 324, 125, + 0, 757, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 210, 0, 210, 210, 210, 210, 210, 757, + 0, 0, 0, 210, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 646, 0, 0, 0, 210, 0, + 0, 0, 0, 0, 646, 0, 0, 0, 210, 210, + 0, 0, 0, 0, 0, 0, 210, 210, 210, 210, + 0, 0, 753, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 753, 0, 373, 374, 375, 376, 377, 378, + 379, 380, 381, 382, 383, 0, 384, 385, 0, 0, + 0, 0, 386, 387, 210, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 105, 0, 388, 0, + 389, 0, 390, 391, 392, 393, 394, 395, 396, 0, + 397, 753, 0, 124, 0, 753, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 753, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 753, 753, 753, 0, 753, + 757, 757, 757, 753, 753, 0, 757, 757, 753, 757, + 753, 753, 753, 753, 753, 753, 753, 757, 0, 0, + 753, 753, 753, 753, 753, 753, 753, 757, 757, 753, + 757, 757, 757, 757, 757, 195, 753, 506, 0, 753, + 753, 753, 0, 753, 753, 753, 753, }; } private static final short[] yyTable2() { return new short[] { - 645, 645, 645, 645, 536, 536, 536, 536, 536, 536, - 536, 536, 536, 536, 536, 536, 536, 536, 645, 645, - 0, 0, 536, 536, 536, 536, 645, 548, 0, 645, - 645, 536, 645, 645, 0, 645, 0, 645, 536, 645, - 536, 645, 536, 536, 536, 536, 536, 536, 536, 645, - 536, 645, 536, 0, 645, 645, 645, 645, 645, 645, - 0, 0, 651, 645, 0, 645, 645, 0, 645, 645, - 645, 645, 651, 645, 645, 645, 536, 0, 0, 0, - 0, 0, 178, 0, 178, 178, 178, 178, 178, 0, - 0, 0, 0, 178, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 542, 0, 106, 0, 178, 0, - 0, 0, 0, 0, 542, 0, 0, 0, 178, 178, - 0, 651, 0, 125, 0, 651, 178, 178, 178, 178, - 667, 587, 0, 0, 668, 0, 0, 0, 162, 163, - 0, 164, 165, 166, 167, 168, 169, 170, 0, 0, - 171, 172, 0, 651, 0, 0, 0, 173, 174, 175, - 176, 0, 0, 0, 178, 0, 0, 289, 0, 0, - 0, 0, 0, 0, 178, 179, 0, 180, 181, 182, - 183, 184, 185, 186, 187, 188, 189, 190, 0, 0, - 191, 65, 65, 65, 0, 647, 65, 65, 65, 0, - 65, 0, 0, 0, 0, 647, 0, 0, 65, 0, - 65, 65, 192, 0, 0, 0, 0, 0, 0, 65, - 65, 0, 65, 65, 65, 65, 65, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 105, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 647, 0, 124, 0, 647, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 65, 0, 0, 65, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 647, 0, 0, 0, - 0, 0, 0, 0, 65, 179, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 65, 647, - 647, 647, 0, 647, 651, 651, 651, 647, 647, 0, - 651, 651, 647, 651, 647, 647, 647, 647, 647, 647, - 647, 651, 651, 293, 179, 647, 647, 647, 647, 647, - 647, 647, 651, 651, 647, 651, 651, 651, 651, 651, - 0, 647, 0, 0, 647, 647, 647, 0, 647, 647, - 647, 647, 647, 647, 647, 647, 647, 647, 647, 651, - 651, 651, 651, 651, 651, 651, 651, 651, 651, 651, - 651, 651, 651, 647, 647, 0, 398, 651, 651, 651, - 651, 647, 0, 0, 647, 647, 651, 647, 647, 0, - 647, 0, 647, 651, 647, 651, 647, 651, 651, 651, - 651, 651, 651, 651, 647, 651, 651, 651, 0, 647, - 647, 647, 647, 647, 647, 0, 0, 63, 647, 0, - 647, 647, 0, 647, 647, 647, 647, 63, 647, 647, - 647, 651, 647, 647, 647, 0, 647, 647, 647, 647, - 647, 647, 0, 647, 647, 647, 647, 647, 647, 647, - 647, 647, 647, 647, 647, 647, 0, 0, 647, 647, - 647, 647, 647, 647, 647, 647, 647, 647, 647, 647, - 647, 647, 647, 0, 647, 0, 63, 647, 647, 647, - 0, 647, 647, 647, 647, 647, 647, 647, 647, 647, - 647, 647, 647, 647, 647, 647, 647, 647, 647, 647, - 647, 647, 647, 647, 647, 647, 647, 647, 0, 0, - 647, 647, 647, 647, 647, 0, 0, 647, 647, 647, - 647, 647, 0, 647, 0, 647, 647, 647, 647, 647, - 647, 647, 647, 647, 647, 647, 647, 647, 647, 647, - 647, 0, 647, 647, 647, 647, 647, 647, 0, 0, - 648, 647, 0, 647, 647, 0, 647, 647, 647, 647, - 648, 647, 647, 647, 647, 0, 0, 0, 0, 0, - 0, 179, 0, 179, 179, 179, 179, 179, 0, 0, - 0, 0, 179, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 544, 107, 0, 0, 179, 0, 0, - 0, 0, 0, 544, 0, 0, 0, 179, 179, 648, - 0, 126, 0, 648, 0, 179, 179, 179, 179, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, - 383, 648, 384, 385, 0, 0, 0, 0, 386, 387, - 0, 0, 0, 179, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 388, 0, 389, 0, 390, 391, - 392, 393, 394, 395, 396, 0, 397, 0, 0, 63, - 63, 63, 0, 651, 63, 63, 63, 0, 63, 0, - 0, 0, 0, 651, 0, 0, 63, 0, 63, 63, - 0, 0, 0, 0, 0, 0, 0, 63, 63, 0, - 63, 63, 63, 63, 63, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 651, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 651, 0, 125, 0, 651, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 63, 0, 0, 63, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 651, 0, 0, 0, 0, 0, - 0, 0, 63, 135, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 63, 648, 648, 648, - 0, 648, 648, 648, 648, 648, 648, 0, 648, 648, - 648, 648, 648, 648, 648, 648, 648, 648, 648, 648, - 648, 0, 135, 648, 648, 648, 648, 648, 648, 648, - 648, 648, 648, 648, 648, 648, 648, 648, 0, 648, - 0, 0, 648, 648, 648, 0, 648, 648, 648, 648, - 648, 648, 648, 648, 648, 648, 648, 648, 648, 648, - 648, 648, 648, 648, 648, 648, 648, 648, 648, 648, - 648, 648, 648, 0, 0, 648, 648, 648, 648, 648, - 0, 0, 648, 648, 648, 648, 648, 0, 648, 0, - 648, 648, 648, 648, 648, 648, 648, 648, 648, 648, - 648, 648, 648, 648, 648, 648, 0, 648, 648, 648, - 648, 648, 648, 0, 0, 53, 648, 0, 648, 648, - 0, 648, 648, 648, 648, 53, 648, 648, 648, 648, - 647, 647, 647, 0, 647, 651, 651, 651, 647, 647, - 0, 651, 651, 647, 651, 647, 647, 647, 647, 647, - 647, 647, 651, 651, 0, 0, 647, 647, 647, 647, - 647, 647, 647, 651, 651, 647, 651, 651, 651, 651, - 651, 0, 647, 0, 53, 647, 647, 647, 0, 647, - 647, 647, 647, 647, 647, 647, 647, 647, 647, 647, - 651, 651, 651, 651, 651, 651, 651, 651, 651, 651, - 651, 651, 651, 651, 647, 647, 0, 0, 651, 651, - 651, 651, 647, 0, 0, 647, 647, 651, 647, 647, - 0, 647, 0, 647, 651, 647, 651, 647, 651, 651, - 651, 651, 651, 651, 651, 647, 651, 651, 651, 0, - 647, 647, 647, 647, 647, 647, 0, 0, 647, 647, - 0, 647, 647, 0, 647, 647, 647, 647, 647, 647, - 647, 647, 651, 0, 0, 0, 0, 0, 0, 135, - 0, 135, 135, 135, 135, 135, 0, 0, 0, 0, - 135, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 533, 647, 0, 0, 135, 0, 0, 0, 0, - 0, 533, 0, 0, 0, 135, 135, 647, 0, 124, - 0, 647, 0, 135, 135, 135, 135, 0, 0, 0, + 753, 753, 753, 753, 753, 753, 753, 757, 757, 757, + 757, 757, 757, 757, 757, 757, 757, 757, 757, 757, + 757, 753, 753, 0, 523, 757, 757, 757, 757, 753, + 0, 0, 753, 753, 757, 753, 753, 195, 753, 506, + 753, 757, 753, 757, 753, 757, 757, 757, 757, 757, + 757, 757, 753, 757, 757, 757, 0, 753, 753, 753, + 753, 753, 753, 0, 0, 0, 753, 0, 753, 753, + 0, 753, 753, 753, 753, 510, 753, 753, 753, 757, + 0, 757, 753, 753, 753, 0, 753, 753, 753, 753, + 753, 753, 0, 753, 753, 753, 753, 753, 753, 753, + 753, 753, 753, 753, 753, 0, 0, 753, 753, 753, + 753, 753, 753, 753, 753, 753, 753, 753, 753, 753, + 753, 753, 0, 753, 510, 0, 753, 753, 753, 0, + 753, 753, 753, 753, 753, 753, 753, 753, 753, 753, + 753, 753, 753, 753, 753, 753, 753, 753, 753, 753, + 753, 753, 753, 753, 753, 753, 753, 0, 0, 753, + 753, 753, 753, 753, 0, 0, 753, 753, 753, 753, + 753, 0, 753, 0, 753, 753, 753, 753, 753, 753, + 753, 753, 753, 753, 753, 753, 753, 753, 753, 753, + 0, 753, 753, 753, 753, 753, 753, 0, 0, 754, + 753, 0, 753, 753, 0, 753, 753, 753, 753, 754, + 753, 753, 753, 753, 0, 753, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 647, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 135, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 107, 0, 0, 0, 506, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 754, 0, + 126, 0, 754, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 506, 506, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 195, 0, 195, 195, 195, 195, 195, + 754, 0, 0, 0, 195, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 647, 0, 0, 0, 195, + 0, 0, 0, 0, 0, 647, 0, 0, 0, 195, + 195, 0, 0, 506, 0, 0, 506, 195, 195, 195, + 195, 0, 510, 757, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 757, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 510, 510, 0, + 0, 0, 0, 0, 0, 195, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 757, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 53, 53, 53, - 0, 648, 53, 53, 53, 0, 53, 0, 0, 0, - 0, 648, 0, 0, 53, 0, 53, 0, 0, 0, - 0, 0, 0, 0, 0, 53, 53, 0, 53, 53, - 53, 53, 53, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 648, 0, 0, 0, 0, + 0, 0, 757, 0, 125, 0, 757, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 510, 0, + 0, 510, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 757, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 648, 0, 126, 0, 648, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 53, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 648, 0, 0, 0, 0, 0, 0, 0, - 53, 136, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 754, 754, 754, 0, + 754, 754, 754, 754, 754, 754, 0, 754, 754, 754, + 754, 754, 754, 754, 754, 754, 754, 754, 754, 0, + 0, 754, 754, 754, 754, 754, 754, 754, 754, 754, + 754, 754, 754, 754, 754, 754, 177, 754, 523, 0, + 754, 754, 754, 0, 754, 754, 754, 754, 754, 754, + 754, 754, 754, 754, 754, 754, 754, 754, 754, 754, + 754, 754, 754, 754, 754, 754, 754, 754, 754, 754, + 754, 0, 523, 754, 754, 754, 754, 754, 0, 0, + 754, 754, 754, 754, 754, 177, 754, 523, 754, 754, + 754, 754, 754, 754, 754, 754, 754, 754, 754, 754, + 754, 754, 754, 754, 0, 754, 754, 754, 754, 754, + 754, 0, 0, 0, 754, 0, 754, 754, 0, 754, + 754, 754, 754, 0, 754, 754, 754, 754, 0, 754, + 753, 753, 753, 0, 753, 757, 757, 757, 753, 753, + 398, 757, 757, 753, 757, 753, 753, 753, 753, 753, + 753, 753, 757, 0, 0, 753, 753, 753, 753, 753, + 753, 753, 757, 757, 753, 757, 757, 757, 757, 757, + 0, 753, 0, 0, 753, 753, 753, 0, 753, 753, + 753, 753, 753, 753, 753, 753, 753, 753, 753, 757, + 757, 757, 757, 757, 757, 757, 757, 757, 757, 757, + 757, 757, 757, 753, 753, 0, 0, 757, 757, 757, + 757, 753, 0, 0, 753, 753, 757, 753, 753, 0, + 753, 0, 753, 757, 753, 757, 753, 757, 757, 757, + 757, 757, 757, 757, 753, 757, 757, 757, 0, 753, + 753, 753, 753, 753, 753, 0, 0, 753, 753, 0, + 753, 753, 0, 753, 753, 753, 753, 753, 753, 753, + 753, 757, 0, 757, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 53, 647, 647, 647, 0, 647, - 647, 647, 647, 647, 647, 0, 647, 647, 647, 647, - 647, 647, 647, 647, 647, 647, 647, 647, 647, 0, - 136, 647, 647, 647, 647, 647, 647, 647, 647, 647, - 647, 647, 647, 647, 647, 647, 0, 647, 0, 0, - 647, 647, 647, 0, 647, 647, 647, 647, 647, 647, - 647, 647, 647, 647, 647, 647, 647, 647, 647, 647, - 647, 647, 647, 647, 647, 647, 647, 647, 647, 647, - 647, 0, 0, 647, 647, 647, 647, 647, 0, 0, - 647, 647, 647, 647, 647, 0, 647, 0, 647, 647, - 647, 647, 647, 647, 647, 647, 647, 647, 647, 647, - 647, 647, 647, 647, 0, 647, 647, 647, 647, 647, - 647, 0, 0, 55, 647, 0, 647, 647, 0, 647, - 647, 647, 647, 55, 647, 647, 647, 647, 648, 648, - 648, 0, 648, 648, 648, 648, 648, 648, 0, 648, - 648, 648, 648, 648, 648, 648, 648, 648, 648, 648, - 648, 648, 0, 0, 648, 648, 648, 648, 648, 648, - 648, 648, 648, 648, 648, 648, 648, 648, 648, 0, - 648, 0, 55, 648, 648, 648, 0, 648, 648, 648, - 648, 648, 648, 648, 648, 648, 648, 648, 648, 648, - 648, 648, 648, 648, 648, 648, 648, 648, 648, 648, - 648, 648, 648, 648, 0, 0, 648, 648, 648, 648, - 648, 0, 0, 648, 648, 648, 648, 648, 0, 648, - 0, 648, 648, 648, 648, 648, 648, 648, 648, 648, - 648, 648, 648, 648, 648, 648, 648, 0, 648, 648, - 648, 648, 648, 648, 0, 0, 324, 648, 0, 648, - 648, 0, 648, 648, 648, 648, 324, 648, 648, 648, - 648, 0, 0, 0, 0, 0, 0, 136, 0, 136, - 136, 136, 136, 136, 0, 0, 0, 0, 136, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 536, - 108, 0, 0, 136, 0, 0, 0, 0, 0, 536, - 0, 0, 0, 136, 136, 324, 0, 127, 0, 324, - 0, 136, 136, 136, 136, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 324, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 136, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 55, 55, 55, 0, 324, - 55, 55, 55, 0, 55, 0, 0, 0, 0, 324, - 0, 0, 55, 0, 55, 0, 0, 0, 0, 0, - 0, 0, 0, 55, 55, 0, 55, 55, 55, 55, - 55, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 324, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 324, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 753, 0, 0, 0, 523, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 753, 0, 124, 0, + 753, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 523, 523, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 177, 0, 177, 177, 177, 177, 177, 753, 0, + 0, 0, 177, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 649, 0, 0, 0, 177, 0, 0, + 0, 0, 0, 649, 0, 0, 0, 177, 177, 0, + 0, 523, 0, 776, 523, 177, 177, 177, 177, 0, + 0, 754, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 754, 0, 373, 374, 375, 376, 377, 378, 379, + 380, 381, 382, 383, 0, 384, 385, 0, 0, 0, + 0, 386, 387, 177, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 754, 0, 388, 0, 389, + 0, 390, 391, 392, 393, 394, 395, 396, 0, 397, + 754, 0, 126, 0, 754, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 754, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 753, 753, 753, 0, 753, 753, + 753, 753, 753, 753, 0, 753, 753, 753, 753, 753, + 753, 753, 753, 753, 753, 753, 753, 0, 0, 753, + 753, 753, 753, 753, 753, 753, 753, 753, 753, 753, + 753, 753, 753, 753, 178, 753, 0, 0, 753, 753, + 753, 0, 753, 753, 753, 753, 753, 753, 753, 753, + 753, 753, 753, 753, 753, 753, 753, 753, 753, 753, + 753, 753, 753, 753, 753, 753, 753, 753, 753, 0, + 0, 753, 753, 753, 753, 753, 0, 0, 753, 753, + 753, 753, 753, 178, 753, 0, 753, 753, 753, 753, + 753, 753, 753, 753, 753, 753, 753, 753, 753, 753, + 753, 753, 0, 753, 753, 753, 753, 753, 753, 0, + 0, 0, 753, 0, 753, 753, 0, 753, 753, 753, + 753, 0, 753, 753, 753, 753, 0, 753, 754, 754, + 754, 0, 754, 754, 754, 754, 754, 754, 398, 754, + 754, 754, 754, 754, 754, 754, 754, 754, 754, 754, + 754, 0, 0, 754, 754, 754, 754, 754, 754, 754, + 754, 754, 754, 754, 754, 754, 754, 754, 0, 754, + 0, 0, 754, 754, 754, 0, 754, 754, 754, 754, + 754, 754, 754, 754, 754, 754, 754, 754, 754, 754, + 754, 754, 754, 754, 754, 754, 754, 754, 754, 754, + 754, 754, 754, 0, 0, 754, 754, 754, 754, 754, + 0, 0, 754, 754, 754, 754, 754, 0, 754, 0, + 754, 754, 754, 754, 754, 754, 754, 754, 754, 754, + 754, 754, 754, 754, 754, 754, 0, 754, 754, 754, + 754, 754, 754, 0, 0, 324, 754, 0, 754, 754, + 0, 754, 754, 754, 754, 324, 754, 754, 754, 754, + 0, 754, 0, 0, 0, 652, 587, 0, 0, 653, + 0, 0, 0, 162, 163, 0, 164, 165, 166, 167, + 168, 169, 170, 0, 0, 171, 172, 0, 0, 108, + 0, 0, 173, 174, 175, 176, 0, 0, 0, 0, + 0, 0, 290, 0, 324, 0, 127, 0, 324, 178, + 179, 0, 180, 181, 182, 183, 184, 185, 186, 187, + 188, 189, 190, 0, 0, 191, 0, 0, 0, 178, + 0, 178, 178, 178, 178, 178, 324, 0, 0, 0, + 178, 0, 0, 0, 0, 0, 0, 192, 0, 0, + 0, 648, 0, 0, 0, 178, 0, 0, 0, 0, + 0, 648, 0, 0, 0, 178, 178, 0, 0, 0, + 0, 0, 0, 178, 178, 178, 178, 0, 0, 324, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 324, + 0, 373, 374, 375, 376, 377, 378, 379, 380, 381, + 382, 383, 0, 384, 385, 0, 0, 0, 0, 386, + 387, 178, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 324, 0, 388, 0, 389, 0, 390, + 391, 392, 393, 394, 395, 396, 0, 397, 324, 0, 127, 0, 324, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 55, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 324, 0, 0, 0, 0, 0, 0, 563, 55, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 55, 648, 648, 648, 0, 648, 324, 324, - 324, 648, 648, 0, 324, 324, 648, 324, 648, 648, - 648, 648, 648, 648, 648, 324, 563, 0, 0, 648, - 648, 648, 648, 648, 648, 648, 324, 324, 648, 324, - 324, 324, 324, 324, 0, 648, 0, 0, 648, 648, - 648, 0, 648, 648, 648, 648, 648, 648, 648, 648, - 648, 648, 648, 324, 324, 324, 324, 324, 324, 324, - 324, 324, 324, 324, 324, 324, 324, 648, 648, 0, - 0, 324, 324, 324, 324, 648, 0, 0, 648, 648, - 324, 648, 648, 0, 648, 0, 648, 324, 648, 324, - 648, 324, 324, 324, 324, 324, 324, 324, 648, 324, - 0, 324, 0, 648, 648, 648, 648, 648, 648, 0, - 0, 0, 648, 0, 648, 648, 0, 648, 648, 648, - 648, 0, 648, 648, 648, 324, 648, 648, 648, 0, - 648, 324, 324, 324, 648, 648, 0, 324, 324, 648, - 324, 648, 648, 648, 648, 648, 648, 648, 324, 0, - 0, 0, 648, 648, 648, 648, 648, 648, 648, 324, - 324, 648, 324, 324, 324, 324, 324, 0, 648, 0, - 0, 648, 648, 648, 0, 648, 648, 648, 648, 648, - 648, 648, 648, 648, 648, 648, 324, 324, 324, 324, - 324, 324, 324, 324, 324, 324, 324, 324, 324, 324, - 648, 648, 0, 0, 324, 324, 324, 324, 648, 0, - 0, 648, 648, 324, 648, 648, 0, 648, 0, 648, - 324, 648, 324, 648, 324, 324, 324, 324, 324, 324, - 324, 648, 324, 454, 324, 0, 648, 648, 648, 648, - 648, 648, 0, 454, 0, 648, 0, 648, 648, 0, - 648, 648, 648, 648, 0, 648, 648, 648, 324, 0, - 0, 0, 0, 563, 0, 563, 563, 563, 563, 563, - 0, 0, 0, 0, 563, 0, 0, 454, 0, 0, - 0, 0, 0, 0, 113, 0, 0, 0, 0, 563, - 0, 454, 454, 0, 123, 0, 454, 0, 0, 563, - 0, 0, 0, 0, 0, 0, 0, 563, 563, 563, - 563, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 112, 0, 454, 0, 0, 0, 0, 0, - 0, 0, 0, 113, 0, 0, 0, 539, 0, 0, - 0, 0, 0, 0, 0, 563, 0, 539, 0, 0, - 0, 0, 115, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 535, 0, 0, 0, 0, - 0, 112, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 539, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 539, 539, 0, 117, 0, - 539, 115, 0, 534, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 671, 596, 0, 0, 672, 539, 0, - 0, 162, 163, 537, 164, 165, 166, 167, 168, 169, - 170, 0, 0, 171, 172, 0, 0, 0, 538, 0, - 173, 174, 175, 176, 0, 0, 0, 0, 538, 0, - 289, 0, 0, 0, 0, 0, 0, 178, 179, 0, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 190, 0, 0, 191, 0, 0, 0, 0, 0, 0, - 0, 0, 538, 0, 129, 454, 454, 454, 0, 0, - 454, 454, 454, 0, 454, 192, 538, 538, 0, 116, - 0, 538, 454, 454, 454, 454, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 324, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 754, 754, 754, 0, 754, 324, 324, 324, + 754, 754, 0, 324, 324, 754, 324, 754, 754, 754, + 754, 754, 754, 754, 0, 0, 0, 754, 754, 754, + 754, 754, 754, 754, 324, 324, 754, 324, 324, 324, + 324, 324, 0, 754, 0, 0, 754, 754, 754, 0, + 754, 754, 754, 754, 754, 754, 754, 754, 754, 754, + 754, 324, 324, 324, 324, 324, 324, 324, 324, 324, + 324, 324, 324, 324, 324, 754, 754, 0, 0, 324, + 324, 324, 324, 754, 0, 0, 754, 754, 324, 754, + 754, 0, 754, 0, 754, 324, 754, 324, 754, 324, + 324, 324, 324, 324, 324, 324, 754, 324, 0, 324, + 0, 754, 754, 754, 754, 754, 754, 0, 0, 780, + 754, 0, 754, 754, 0, 754, 754, 754, 754, 780, + 754, 754, 754, 324, 0, 324, 754, 754, 754, 0, + 754, 324, 324, 324, 754, 754, 0, 324, 324, 754, + 324, 754, 754, 754, 754, 754, 754, 754, 0, 0, + 780, 754, 754, 754, 754, 754, 754, 754, 324, 324, + 754, 324, 324, 324, 324, 324, 0, 754, 780, 0, + 754, 754, 754, 0, 754, 754, 754, 754, 754, 754, + 754, 754, 754, 754, 754, 324, 324, 324, 324, 324, + 324, 324, 324, 324, 324, 324, 324, 324, 324, 754, + 754, 0, 0, 324, 324, 324, 324, 754, 0, 0, + 754, 754, 324, 754, 754, 0, 754, 0, 754, 324, + 754, 324, 754, 324, 324, 324, 324, 324, 324, 324, + 754, 324, 0, 324, 0, 754, 754, 754, 754, 754, + 754, 0, 0, 644, 754, 0, 754, 754, 0, 754, + 754, 754, 754, 644, 754, 754, 754, 324, 0, 324, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 35, 0, 0, 644, 0, 0, 644, 0, 0, + 0, 35, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 644, 644, 0, 116, 0, 644, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 644, 0, 0, 0, 0, 0, + 35, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 125, 0, 0, + 124, 0, 0, 0, 0, 0, 290, 290, 290, 0, + 290, 780, 780, 780, 290, 290, 780, 780, 780, 290, + 780, 290, 290, 290, 290, 290, 290, 290, 780, 780, + 0, 290, 290, 290, 290, 290, 290, 290, 780, 780, + 290, 780, 780, 780, 780, 780, 125, 290, 0, 124, + 290, 290, 290, 0, 290, 290, 290, 290, 290, 290, + 290, 290, 290, 290, 290, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 780, 0, 757, 290, + 290, 753, 0, 0, 0, 780, 780, 290, 0, 0, + 290, 0, 780, 290, 290, 0, 290, 646, 290, 0, + 290, 0, 290, 0, 0, 0, 0, 646, 0, 0, + 290, 0, 780, 780, 0, 290, 290, 290, 290, 290, + 290, 0, 0, 0, 290, 0, 290, 290, 0, 290, + 290, 290, 290, 0, 290, 290, 290, 780, 646, 780, + 0, 646, 0, 0, 0, 644, 644, 644, 0, 122, + 644, 644, 644, 0, 644, 646, 646, 0, 118, 0, + 646, 0, 0, 644, 644, 0, 0, 0, 0, 0, + 0, 0, 644, 644, 0, 644, 644, 644, 644, 644, + 0, 0, 0, 35, 35, 35, 0, 644, 646, 35, + 35, 0, 35, 0, 0, 0, 0, 0, 122, 644, + 644, 644, 644, 644, 644, 644, 644, 644, 644, 644, + 644, 644, 644, 35, 35, 35, 35, 644, 644, 644, + 644, 0, 656, 644, 0, 0, 644, 0, 0, 644, + 650, 644, 0, 644, 647, 644, 0, 644, 644, 644, + 644, 644, 644, 644, 647, 644, 0, 644, 0, 757, + 0, 0, 0, 0, 125, 0, 0, 124, 0, 644, + 0, 0, 0, 0, 35, 0, 757, 0, 0, 753, + 0, 644, 0, 644, 0, 647, 0, 0, 647, 0, + 0, 0, 0, 757, 0, 35, 0, 0, 0, 0, + 0, 0, 647, 647, 0, 119, 0, 647, 757, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 35, + 0, 35, 0, 0, 757, 0, 0, 753, 0, 0, + 0, 483, 0, 757, 757, 647, 753, 753, 0, 753, + 757, 0, 753, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 454, 0, 0, 0, 0, 0, + 757, 0, 0, 753, 454, 483, 0, 0, 0, 646, + 646, 646, 0, 0, 646, 646, 646, 0, 646, 0, + 483, 0, 0, 0, 0, 0, 0, 646, 646, 0, + 0, 0, 0, 0, 0, 0, 646, 646, 104, 646, + 646, 646, 646, 646, 0, 0, 0, 0, 0, 0, + 0, 646, 0, 454, 0, 123, 122, 454, 0, 0, + 0, 0, 0, 646, 646, 646, 646, 646, 646, 646, + 646, 646, 646, 646, 646, 646, 646, 0, 0, 0, + 0, 646, 646, 646, 646, 454, 658, 646, 0, 0, + 646, 0, 0, 646, 0, 646, 0, 646, 649, 646, + 0, 646, 646, 646, 646, 646, 646, 646, 649, 646, + 0, 646, 0, 113, 0, 0, 650, 0, 0, 0, + 0, 0, 0, 646, 0, 650, 650, 0, 0, 0, + 0, 0, 0, 0, 0, 646, 0, 646, 0, 649, + 0, 0, 649, 0, 0, 0, 647, 647, 647, 0, + 0, 647, 647, 647, 0, 647, 649, 649, 0, 121, + 0, 649, 113, 0, 647, 647, 0, 0, 757, 0, + 0, 0, 0, 647, 647, 0, 647, 647, 647, 647, + 647, 0, 0, 0, 0, 0, 0, 0, 647, 649, + 0, 0, 0, 0, 641, 0, 0, 0, 0, 0, + 647, 647, 647, 647, 647, 647, 647, 647, 647, 647, + 647, 647, 647, 647, 0, 0, 757, 0, 647, 647, + 647, 647, 0, 659, 647, 757, 757, 647, 483, 0, + 647, 753, 647, 0, 647, 648, 647, 0, 647, 647, + 647, 647, 647, 647, 647, 648, 647, 0, 647, 757, + 0, 0, 757, 483, 483, 0, 454, 454, 454, 0, + 647, 0, 454, 454, 0, 454, 0, 0, 0, 0, + 0, 0, 647, 454, 647, 0, 648, 0, 0, 648, 0, 0, 0, 454, 454, 0, 454, 454, 454, 454, - 454, 0, 0, 0, 0, 0, 0, 0, 454, 538, - 0, 113, 0, 129, 0, 0, 0, 0, 0, 0, + 454, 0, 0, 648, 648, 0, 120, 0, 648, 0, + 0, 483, 0, 0, 483, 0, 0, 483, 0, 0, 454, 454, 454, 454, 454, 454, 454, 454, 454, 454, - 454, 454, 454, 454, 0, 0, 128, 0, 454, 454, - 454, 454, 0, 0, 454, 314, 0, 454, 0, 112, - 454, 0, 454, 0, 454, 540, 454, 0, 454, 454, - 454, 454, 454, 454, 454, 540, 454, 454, 454, 539, - 539, 539, 535, 0, 539, 539, 539, 0, 539, 115, - 454, 535, 535, 0, 0, 128, 539, 0, 539, 539, - 0, 0, 454, 0, 0, 0, 0, 539, 539, 540, - 539, 539, 539, 539, 539, 0, 0, 0, 0, 0, - 534, 0, 539, 540, 540, 0, 118, 325, 540, 534, - 534, 0, 0, 0, 539, 539, 539, 539, 539, 539, - 539, 539, 539, 539, 539, 539, 539, 539, 0, 0, - 537, 0, 539, 539, 539, 539, 540, 551, 539, 537, - 537, 539, 0, 0, 539, 0, 539, 0, 539, 541, - 539, 0, 539, 539, 539, 539, 539, 539, 539, 541, - 539, 0, 539, 0, 0, 0, 0, 0, 0, 0, - 538, 538, 538, 0, 539, 538, 538, 538, 0, 538, - 0, 0, 0, 0, 0, 0, 539, 538, 0, 538, - 538, 0, 0, 541, 0, 0, 0, 0, 538, 538, - 0, 538, 538, 538, 538, 538, 0, 541, 541, 0, - 119, 129, 541, 538, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 538, 538, 538, 538, 538, - 538, 538, 538, 538, 538, 538, 538, 538, 538, 0, - 541, 0, 0, 538, 538, 538, 538, 0, 550, 538, - 0, 0, 538, 0, 0, 538, 0, 538, 0, 538, - 543, 538, 0, 538, 538, 538, 538, 538, 538, 538, - 543, 538, 314, 538, 0, 0, 0, 0, 0, 0, - 0, 314, 314, 128, 0, 538, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 538, 0, 0, - 0, 0, 0, 0, 543, 0, 0, 540, 540, 540, - 0, 0, 540, 540, 540, 0, 540, 0, 543, 543, - 0, 121, 0, 543, 540, 0, 540, 540, 0, 0, - 0, 0, 0, 0, 0, 540, 540, 0, 540, 540, - 540, 540, 540, 0, 325, 0, 0, 0, 0, 0, - 540, 543, 0, 325, 325, 0, 0, 0, 0, 0, - 0, 0, 540, 540, 540, 540, 540, 540, 540, 540, - 540, 540, 540, 540, 540, 540, 0, 0, 0, 0, - 540, 540, 540, 540, 0, 552, 540, 0, 0, 540, - 0, 0, 540, 0, 540, 0, 540, 542, 540, 0, - 540, 540, 540, 540, 540, 540, 540, 542, 540, 0, - 540, 541, 541, 541, 0, 0, 541, 541, 541, 0, - 541, 0, 540, 0, 0, 0, 0, 0, 541, 0, - 541, 541, 0, 0, 540, 0, 0, 0, 0, 541, - 541, 542, 541, 541, 541, 541, 541, 0, 0, 0, - 0, 0, 0, 0, 541, 542, 542, 0, 120, 0, - 542, 0, 0, 0, 0, 0, 541, 541, 541, 541, - 541, 541, 541, 541, 541, 541, 541, 541, 541, 541, - 0, 0, 0, 0, 541, 541, 541, 541, 542, 553, - 541, 0, 0, 541, 0, 0, 541, 0, 541, 0, - 541, 544, 541, 0, 541, 541, 541, 541, 541, 541, - 541, 544, 541, 0, 541, 0, 0, 0, 0, 0, - 0, 0, 543, 543, 543, 0, 541, 543, 543, 543, - 0, 543, 0, 0, 0, 0, 0, 0, 541, 543, - 0, 543, 543, 0, 0, 544, 0, 0, 0, 0, - 543, 543, 0, 543, 543, 543, 543, 543, 0, 544, - 544, 0, 122, 0, 544, 543, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 543, 543, 543, - 543, 543, 543, 543, 543, 543, 543, 543, 543, 543, - 543, 0, 544, 0, 0, 543, 543, 543, 543, 0, - 555, 543, 0, 0, 543, 0, 0, 543, 0, 543, - 0, 543, 535, 543, 0, 543, 543, 543, 543, 543, - 543, 543, 535, 543, 0, 543, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 543, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 543, - 0, 0, 0, 0, 0, 0, 535, 0, 0, 542, - 542, 542, 0, 0, 542, 542, 542, 0, 542, 0, - 535, 535, 0, 113, 0, 535, 542, 0, 542, 542, - 0, 0, 0, 0, 0, 0, 0, 542, 542, 0, - 542, 542, 542, 542, 542, 0, 0, 0, 0, 0, - 0, 0, 542, 535, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 542, 542, 542, 542, 542, 542, - 542, 542, 542, 542, 542, 542, 542, 542, 0, 0, - 0, 0, 542, 542, 542, 542, 0, 554, 542, 0, - 0, 542, 0, 0, 542, 0, 542, 0, 542, 534, - 542, 0, 542, 542, 542, 542, 542, 542, 542, 534, - 542, 0, 542, 544, 544, 544, 0, 0, 544, 544, - 544, 0, 544, 0, 542, 0, 0, 0, 0, 0, - 544, 0, 544, 544, 0, 0, 542, 0, 0, 0, - 0, 544, 544, 534, 544, 544, 544, 544, 544, 0, - 0, 0, 0, 0, 0, 0, 544, 534, 534, 0, - 112, 0, 534, 0, 0, 0, 0, 0, 544, 544, - 544, 544, 544, 544, 544, 544, 544, 544, 544, 544, - 544, 544, 0, 0, 101, 0, 544, 544, 544, 544, - 534, 556, 544, 0, 0, 544, 0, 0, 544, 0, - 544, 0, 544, 537, 544, 0, 544, 544, 544, 544, - 544, 544, 544, 537, 544, 0, 544, 0, 101, 0, - 0, 0, 0, 0, 535, 535, 535, 0, 544, 535, - 535, 535, 0, 535, 0, 101, 0, 0, 0, 0, - 544, 535, 0, 535, 535, 0, 0, 537, 0, 0, - 0, 0, 535, 535, 0, 535, 535, 535, 535, 535, - 0, 537, 537, 0, 115, 542, 537, 535, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 535, - 535, 535, 535, 535, 535, 535, 535, 535, 535, 535, - 535, 535, 535, 0, 537, 0, 0, 535, 535, 535, - 535, 0, 547, 535, 0, 0, 535, 0, 0, 535, - 0, 535, 0, 535, 453, 535, 0, 535, 535, 535, - 535, 535, 535, 535, 453, 535, 0, 535, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 535, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 535, 0, 0, 0, 0, 0, 0, 453, 0, - 0, 534, 534, 534, 0, 0, 534, 534, 534, 0, - 534, 0, 453, 453, 0, 0, 0, 453, 534, 0, - 534, 534, 0, 0, 0, 0, 0, 0, 0, 534, - 534, 0, 534, 534, 534, 534, 534, 0, 0, 0, - 0, 0, 0, 0, 534, 453, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 534, 534, 534, 534, - 534, 534, 534, 534, 534, 534, 534, 534, 534, 534, - 0, 0, 0, 0, 534, 534, 534, 534, 0, 546, - 534, 0, 0, 534, 0, 0, 534, 0, 534, 0, - 534, 673, 534, 101, 534, 534, 534, 534, 534, 534, - 534, 673, 534, 0, 534, 537, 537, 537, 0, 0, - 537, 537, 537, 0, 537, 0, 534, 0, 0, 0, - 0, 0, 537, 0, 537, 537, 0, 0, 534, 0, - 0, 0, 0, 537, 537, 673, 537, 537, 537, 537, - 537, 0, 542, 0, 0, 0, 0, 0, 537, 673, - 673, 542, 542, 0, 673, 0, 0, 0, 101, 0, - 537, 537, 537, 537, 537, 537, 537, 537, 537, 537, - 537, 537, 537, 537, 0, 0, 103, 0, 537, 537, - 537, 537, 673, 549, 537, 0, 0, 537, 0, 0, - 537, 0, 537, 0, 537, 314, 537, 0, 537, 537, - 537, 537, 537, 537, 537, 314, 537, 0, 537, 0, - 103, 0, 0, 0, 0, 0, 453, 453, 453, 0, - 537, 453, 453, 453, 0, 453, 0, 103, 0, 0, - 0, 0, 537, 453, 453, 453, 453, 0, 0, 314, - 0, 0, 0, 0, 453, 453, 0, 453, 453, 453, - 453, 453, 0, 314, 314, 0, 129, 544, 314, 453, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 453, 453, 453, 453, 453, 453, 453, 453, 453, - 453, 453, 453, 453, 453, 0, 314, 0, 0, 453, - 453, 453, 453, 0, 0, 453, 0, 0, 453, 0, - 0, 453, 0, 453, 0, 453, 325, 453, 0, 453, - 453, 453, 453, 453, 453, 453, 325, 453, 453, 453, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 453, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 453, 0, 0, 0, 0, 0, 0, - 325, 0, 0, 673, 673, 673, 0, 0, 673, 673, - 673, 0, 673, 0, 325, 325, 0, 128, 0, 325, - 673, 673, 673, 673, 0, 0, 0, 0, 0, 0, - 0, 673, 673, 0, 673, 673, 673, 673, 673, 0, - 0, 0, 0, 0, 0, 0, 673, 325, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 673, 673, - 673, 673, 673, 673, 673, 673, 673, 673, 673, 673, - 673, 673, 0, 0, 0, 0, 673, 673, 673, 673, - 0, 0, 673, 0, 0, 673, 0, 0, 673, 0, - 673, 0, 673, 481, 673, 103, 673, 673, 673, 673, - 673, 673, 673, 481, 673, 673, 673, 314, 314, 314, - 0, 0, 314, 314, 314, 0, 314, 0, 673, 0, - 0, 0, 0, 0, 314, 0, 314, 314, 0, 0, - 673, 0, 0, 0, 0, 314, 314, 481, 314, 314, - 314, 314, 314, 0, 544, 0, 0, 0, 0, 0, - 314, 481, 481, 544, 544, 0, 481, 0, 0, 0, - 103, 0, 314, 314, 314, 314, 314, 314, 314, 314, - 314, 314, 314, 314, 314, 314, 0, 0, 94, 0, - 314, 314, 314, 314, 481, 0, 314, 0, 0, 314, - 0, 0, 314, 0, 314, 0, 314, 336, 314, 0, - 314, 314, 314, 314, 314, 314, 314, 336, 314, 0, - 314, 0, 94, 0, 0, 0, 0, 0, 325, 325, - 325, 0, 314, 325, 325, 325, 0, 325, 0, 94, - 0, 0, 0, 0, 314, 325, 0, 325, 325, 0, - 0, 336, 0, 0, 0, 0, 325, 325, 0, 325, - 325, 325, 325, 325, 0, 336, 336, 0, 0, 535, - 336, 325, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 325, 325, 325, 325, 325, 325, 325, - 325, 325, 325, 325, 325, 325, 325, 0, 336, 0, - 0, 325, 325, 325, 325, 0, 0, 325, 0, 0, - 325, 0, 0, 325, 0, 325, 0, 325, 261, 325, - 0, 325, 325, 325, 325, 325, 325, 325, 261, 325, - 0, 325, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 325, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 325, 0, 0, 0, 0, - 0, 0, 261, 0, 0, 481, 481, 481, 0, 0, - 481, 481, 481, 0, 481, 0, 261, 261, 0, 0, - 0, 261, 481, 0, 481, 481, 0, 0, 0, 0, - 0, 0, 0, 481, 481, 0, 481, 481, 481, 481, - 481, 0, 0, 0, 0, 0, 0, 0, 481, 369, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 481, 481, 481, 481, 481, 481, 481, 481, 481, 481, - 481, 481, 481, 481, 0, 0, 0, 0, 481, 481, - 481, 481, 0, 0, 481, 0, 0, 481, 0, 0, - 481, 0, 481, 0, 481, 331, 481, 94, 481, 481, - 481, 481, 481, 481, 481, 331, 481, 0, 481, 336, - 336, 336, 0, 0, 336, 336, 336, 0, 336, 0, - 481, 0, 0, 0, 0, 0, 336, 0, 336, 336, - 0, 0, 481, 0, 0, 0, 0, 336, 336, 331, - 336, 336, 336, 336, 336, 0, 535, 0, 0, 0, - 0, 0, 336, 331, 331, 535, 535, 0, 331, 0, - 0, 0, 94, 0, 336, 336, 336, 336, 336, 336, - 336, 336, 336, 336, 336, 336, 336, 336, 0, 0, - 93, 0, 336, 336, 336, 336, 331, 0, 336, 0, - 0, 336, 0, 0, 336, 0, 336, 0, 336, 528, - 336, 0, 336, 336, 336, 336, 336, 336, 336, 528, - 336, 0, 336, 0, 93, 0, 0, 0, 0, 0, - 261, 261, 261, 0, 336, 261, 261, 261, 0, 261, - 0, 93, 0, 0, 0, 0, 336, 261, 0, 261, - 261, 0, 0, 528, 0, 0, 0, 0, 261, 261, - 0, 261, 261, 261, 261, 261, 0, 528, 528, 0, - 0, 534, 528, 261, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 261, 261, 261, 261, 261, - 261, 261, 261, 261, 261, 261, 369, 261, 261, 0, - 528, 0, 0, 261, 261, 369, 369, 0, 0, 261, - 0, 0, 261, 0, 0, 261, 0, 261, 0, 261, - 365, 261, 0, 261, 261, 261, 261, 261, 261, 261, - 365, 261, 0, 261, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 261, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 261, 0, 0, - 0, 0, 0, 0, 365, 0, 0, 331, 331, 331, - 0, 0, 331, 331, 331, 0, 331, 0, 0, 365, - 0, 0, 0, 365, 331, 0, 331, 331, 0, 0, - 0, 0, 0, 0, 0, 331, 331, 0, 331, 331, - 331, 331, 331, 0, 0, 0, 0, 0, 0, 0, - 331, 365, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 331, 331, 331, 331, 331, 331, 331, 331, - 331, 331, 331, 331, 331, 331, 0, 0, 0, 0, - 331, 331, 331, 331, 0, 0, 331, 0, 0, 331, - 0, 0, 331, 0, 331, 0, 331, 366, 331, 93, - 331, 331, 331, 331, 331, 331, 331, 366, 331, 0, - 331, 528, 528, 528, 0, 0, 528, 528, 528, 0, - 528, 0, 331, 0, 0, 0, 0, 0, 528, 0, - 528, 528, 0, 0, 331, 0, 0, 0, 0, 528, - 528, 366, 528, 528, 528, 528, 528, 0, 534, 0, - 0, 0, 0, 0, 528, 0, 366, 534, 534, 0, - 366, 0, 0, 0, 93, 0, 0, 528, 528, 528, - 528, 528, 528, 528, 528, 528, 528, 528, 528, 528, - 0, 0, 96, 0, 528, 528, 528, 528, 366, 0, - 528, 0, 0, 528, 0, 0, 528, 0, 528, 0, - 528, 328, 528, 0, 528, 528, 528, 528, 528, 528, - 528, 328, 528, 0, 528, 0, 96, 0, 0, 0, - 0, 0, 365, 365, 365, 0, 528, 365, 365, 365, - 0, 365, 0, 96, 0, 0, 0, 0, 528, 365, - 0, 365, 365, 0, 0, 328, 0, 0, 0, 0, - 365, 365, 0, 365, 365, 365, 365, 365, 0, 0, - 328, 0, 0, 537, 328, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 365, 365, 365, - 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, - 365, 0, 328, 0, 0, 365, 365, 365, 365, 0, - 0, 365, 0, 0, 365, 0, 0, 365, 0, 365, - 0, 365, 229, 365, 0, 365, 365, 365, 365, 365, - 365, 365, 229, 365, 0, 365, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 365, - 0, 0, 0, 0, 0, 0, 229, 0, 0, 366, - 366, 366, 0, 0, 366, 366, 366, 0, 366, 0, - 229, 229, 0, 0, 0, 229, 366, 0, 366, 366, - 0, 0, 0, 0, 0, 0, 0, 366, 366, 0, - 366, 366, 366, 366, 366, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 366, 366, 366, 366, 366, 366, - 366, 366, 366, 366, 366, 366, 366, 366, 0, 0, - 0, 0, 366, 366, 366, 366, 0, 0, 366, 0, - 0, 366, 0, 0, 366, 0, 366, 0, 366, 232, - 366, 96, 366, 366, 366, 366, 366, 366, 366, 232, - 366, 0, 366, 328, 328, 328, 0, 0, 328, 328, - 328, 0, 328, 0, 0, 0, 0, 0, 0, 0, - 328, 0, 328, 328, 0, 0, 366, 0, 0, 0, - 0, 328, 328, 232, 328, 328, 328, 328, 328, 0, - 537, 0, 0, 0, 0, 0, 0, 232, 232, 537, - 537, 0, 232, 0, 0, 0, 96, 0, 328, 328, - 328, 328, 328, 328, 328, 328, 328, 328, 328, 328, - 328, 328, 0, 0, 110, 0, 328, 328, 328, 328, - 0, 0, 328, 0, 0, 328, 0, 0, 328, 0, - 328, 0, 328, 242, 328, 0, 328, 328, 328, 328, - 328, 328, 328, 242, 328, 0, 328, 0, 110, 0, - 0, 0, 0, 0, 229, 229, 229, 0, 0, 229, - 229, 229, 0, 229, 0, 110, 0, 0, 0, 0, - 328, 229, 0, 229, 229, 0, 0, 242, 0, 0, - 0, 0, 229, 229, 0, 229, 229, 229, 229, 229, - 0, 242, 242, 0, 0, 314, 242, 229, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 229, - 229, 229, 229, 229, 229, 229, 229, 229, 229, 229, - 0, 229, 229, 0, 0, 0, 0, 229, 229, 0, - 0, 0, 0, 229, 0, 0, 229, 0, 0, 229, - 0, 229, 0, 229, 239, 229, 0, 229, 229, 229, - 229, 229, 229, 229, 239, 229, 0, 229, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 229, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 229, 0, 0, 0, 0, 0, 0, 239, 0, - 0, 232, 232, 232, 0, 0, 232, 232, 232, 0, - 232, 0, 239, 239, 0, 0, 0, 239, 232, 0, - 232, 232, 0, 0, 0, 0, 0, 0, 0, 232, - 232, 0, 232, 232, 232, 232, 232, 0, 0, 0, - 0, 0, 0, 0, 232, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 232, 232, 232, 232, - 232, 232, 232, 232, 232, 232, 232, 0, 232, 232, - 0, 0, 0, 0, 232, 232, 0, 0, 0, 0, - 232, 0, 0, 232, 0, 0, 232, 0, 232, 0, - 232, 236, 232, 110, 232, 232, 232, 232, 232, 232, - 232, 236, 232, 0, 232, 242, 242, 242, 0, 0, - 242, 242, 242, 0, 242, 0, 232, 0, 0, 0, - 0, 0, 242, 0, 242, 242, 0, 0, 232, 0, - 0, 0, 0, 242, 242, 236, 242, 242, 242, 242, - 242, 0, 314, 0, 0, 0, 0, 0, 242, 236, - 236, 314, 314, 0, 236, 0, 0, 0, 110, 0, - 0, 242, 242, 242, 242, 242, 242, 242, 242, 242, - 242, 0, 242, 242, 0, 0, 109, 0, 242, 242, - 0, 0, 0, 0, 242, 0, 0, 242, 0, 0, - 242, 0, 242, 0, 242, 238, 242, 0, 242, 242, - 242, 242, 242, 242, 242, 238, 242, 0, 242, 0, - 109, 0, 0, 0, 0, 0, 239, 239, 239, 0, - 242, 239, 239, 239, 0, 239, 0, 109, 0, 0, - 0, 0, 242, 239, 0, 239, 239, 0, 0, 238, - 0, 0, 0, 0, 239, 239, 0, 239, 239, 239, - 239, 239, 0, 238, 238, 0, 0, 325, 238, 239, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 239, 239, 239, 239, 239, 239, 239, 239, - 239, 239, 0, 239, 239, 0, 0, 0, 0, 239, - 239, 0, 0, 0, 0, 239, 0, 0, 239, 0, - 0, 239, 0, 239, 0, 239, 237, 239, 0, 239, - 239, 239, 239, 239, 239, 239, 237, 239, 0, 239, + 454, 454, 454, 454, 0, 483, 648, 0, 454, 454, + 454, 454, 0, 0, 0, 0, 0, 454, 0, 0, + 0, 0, 0, 0, 454, 454, 454, 0, 454, 454, + 454, 454, 454, 454, 454, 454, 454, 454, 454, 0, + 649, 649, 649, 0, 0, 649, 649, 649, 0, 649, + 113, 0, 0, 0, 0, 0, 0, 0, 649, 649, + 0, 0, 454, 0, 454, 0, 0, 649, 649, 454, + 649, 649, 649, 649, 649, 0, 0, 0, 112, 0, + 0, 0, 649, 0, 454, 0, 123, 0, 454, 0, + 0, 0, 0, 0, 649, 649, 649, 649, 649, 649, + 649, 649, 649, 649, 649, 649, 649, 649, 0, 0, + 641, 0, 649, 649, 649, 649, 454, 661, 649, 641, + 641, 649, 0, 0, 649, 0, 649, 112, 649, 650, + 649, 0, 649, 649, 649, 649, 649, 649, 649, 650, + 649, 0, 649, 0, 115, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 649, 0, 0, 0, 0, 640, + 0, 0, 0, 0, 0, 0, 649, 0, 649, 0, + 650, 0, 0, 650, 0, 129, 0, 648, 648, 648, + 0, 128, 648, 648, 648, 0, 648, 650, 650, 0, + 122, 0, 650, 115, 0, 648, 648, 0, 0, 0, + 0, 0, 0, 0, 648, 648, 0, 648, 648, 648, + 648, 648, 0, 0, 0, 0, 0, 0, 0, 648, + 650, 0, 0, 0, 129, 643, 0, 0, 0, 0, + 128, 648, 648, 648, 648, 648, 648, 648, 648, 648, + 648, 648, 648, 648, 648, 0, 0, 0, 0, 648, + 648, 648, 648, 0, 660, 648, 314, 0, 648, 0, + 0, 648, 325, 648, 0, 648, 641, 648, 0, 648, + 648, 648, 648, 648, 648, 648, 641, 648, 0, 648, + 0, 0, 0, 0, 0, 0, 0, 454, 454, 454, + 0, 648, 0, 454, 454, 0, 454, 0, 0, 0, + 0, 0, 0, 648, 454, 648, 0, 641, 0, 0, + 641, 0, 0, 0, 454, 454, 0, 454, 454, 454, + 454, 454, 0, 0, 641, 641, 0, 113, 0, 641, + 0, 0, 0, 0, 0, 112, 0, 0, 0, 0, + 0, 454, 454, 454, 454, 454, 454, 454, 454, 454, + 454, 454, 454, 454, 454, 0, 0, 641, 0, 454, + 454, 454, 454, 0, 0, 0, 0, 0, 454, 0, + 0, 0, 0, 0, 0, 454, 645, 454, 0, 454, + 454, 454, 454, 454, 454, 454, 645, 454, 454, 454, + 0, 650, 650, 650, 0, 640, 650, 650, 650, 0, + 650, 115, 0, 0, 640, 640, 0, 0, 0, 650, + 650, 0, 0, 454, 0, 454, 0, 0, 650, 650, + 98, 650, 650, 650, 650, 650, 0, 0, 0, 0, + 0, 0, 129, 650, 0, 645, 0, 117, 128, 645, + 0, 0, 0, 0, 0, 650, 650, 650, 650, 650, + 650, 650, 650, 650, 650, 650, 650, 650, 650, 0, + 0, 643, 0, 650, 650, 650, 650, 645, 662, 650, + 643, 643, 650, 0, 0, 650, 0, 650, 0, 650, + 640, 650, 0, 650, 650, 650, 650, 650, 650, 650, + 640, 650, 314, 650, 0, 0, 0, 0, 325, 0, + 0, 314, 314, 0, 0, 650, 0, 325, 325, 0, + 0, 0, 0, 0, 0, 0, 0, 650, 0, 650, + 0, 640, 0, 0, 640, 0, 0, 0, 641, 641, + 641, 0, 0, 641, 641, 641, 0, 641, 640, 640, + 0, 112, 0, 640, 0, 0, 641, 641, 0, 0, + 0, 0, 0, 0, 0, 641, 641, 0, 641, 641, + 641, 641, 641, 0, 0, 0, 0, 0, 0, 0, + 641, 640, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 641, 641, 641, 641, 641, 641, 641, 641, + 641, 641, 641, 641, 641, 641, 0, 0, 0, 0, + 641, 641, 641, 641, 0, 653, 641, 0, 0, 641, + 0, 0, 641, 0, 641, 0, 641, 643, 641, 0, + 641, 641, 641, 641, 641, 641, 641, 643, 641, 0, + 641, 0, 0, 0, 0, 0, 0, 0, 645, 645, + 645, 0, 641, 0, 645, 645, 0, 645, 0, 0, + 0, 0, 0, 0, 641, 0, 641, 0, 643, 0, + 0, 643, 0, 0, 0, 645, 645, 0, 645, 645, + 645, 645, 645, 0, 0, 643, 643, 0, 115, 0, + 643, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 645, 645, 645, 645, 645, 645, 645, 645, + 645, 645, 645, 645, 645, 645, 0, 0, 643, 0, + 645, 645, 645, 645, 0, 657, 0, 0, 0, 645, + 0, 0, 0, 0, 0, 0, 645, 644, 645, 0, + 645, 645, 645, 645, 645, 645, 645, 644, 645, 0, + 645, 0, 640, 640, 640, 0, 0, 640, 640, 640, + 0, 640, 0, 0, 0, 0, 0, 0, 0, 0, + 640, 640, 0, 0, 645, 0, 645, 0, 0, 640, + 640, 97, 640, 640, 640, 640, 640, 0, 0, 0, + 0, 0, 0, 0, 640, 0, 644, 0, 116, 0, + 644, 0, 0, 0, 0, 0, 640, 640, 640, 640, + 640, 640, 640, 640, 640, 640, 640, 640, 640, 640, + 0, 0, 0, 0, 640, 640, 640, 640, 644, 652, + 640, 0, 0, 640, 0, 0, 640, 0, 640, 0, + 640, 453, 640, 0, 640, 640, 640, 640, 640, 640, + 640, 453, 640, 0, 640, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 640, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 640, 0, + 640, 0, 453, 0, 0, 453, 0, 0, 0, 643, + 643, 643, 0, 0, 643, 643, 643, 0, 643, 453, + 453, 0, 0, 0, 453, 0, 0, 643, 643, 0, + 0, 0, 0, 0, 0, 0, 643, 643, 0, 643, + 643, 643, 643, 643, 0, 0, 0, 0, 0, 0, + 0, 643, 453, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 643, 643, 643, 643, 643, 643, 643, + 643, 643, 643, 643, 643, 643, 643, 0, 126, 0, + 0, 643, 643, 643, 643, 0, 655, 643, 0, 0, + 643, 0, 0, 643, 0, 643, 0, 643, 780, 643, + 0, 643, 643, 643, 643, 643, 643, 643, 780, 643, + 0, 643, 0, 0, 0, 0, 0, 0, 0, 644, + 644, 644, 0, 643, 0, 644, 644, 126, 644, 0, + 0, 0, 0, 0, 0, 643, 0, 643, 0, 780, + 0, 0, 780, 0, 0, 0, 644, 644, 0, 644, + 644, 644, 644, 644, 0, 0, 780, 780, 0, 754, + 0, 780, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 644, 644, 644, 644, 644, 644, 644, + 644, 644, 644, 644, 644, 644, 644, 0, 0, 780, + 0, 644, 644, 644, 644, 0, 656, 0, 0, 0, + 644, 0, 0, 0, 0, 0, 0, 644, 646, 644, + 0, 644, 644, 644, 644, 644, 644, 644, 646, 644, + 0, 644, 0, 453, 453, 453, 0, 0, 453, 453, + 453, 0, 453, 0, 0, 0, 0, 0, 0, 0, + 453, 453, 453, 0, 0, 644, 0, 644, 0, 0, + 453, 453, 99, 453, 453, 453, 453, 453, 0, 0, + 0, 0, 0, 0, 0, 453, 0, 646, 0, 118, + 0, 646, 0, 0, 0, 0, 0, 453, 453, 453, + 453, 453, 453, 453, 453, 453, 453, 453, 453, 453, + 453, 0, 0, 0, 0, 453, 453, 453, 453, 646, + 0, 453, 0, 0, 453, 0, 0, 453, 0, 453, + 0, 453, 584, 453, 0, 453, 453, 453, 453, 453, + 453, 453, 584, 453, 453, 453, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 126, 0, 453, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 754, 0, 453, + 0, 453, 0, 584, 0, 0, 584, 0, 0, 0, + 780, 780, 780, 0, 0, 780, 780, 780, 0, 780, + 584, 584, 0, 0, 0, 584, 0, 780, 780, 780, + 0, 0, 0, 0, 0, 0, 0, 780, 780, 0, + 780, 780, 780, 780, 780, 754, 0, 0, 0, 0, + 0, 0, 780, 584, 754, 754, 0, 0, 0, 0, + 754, 0, 0, 0, 780, 780, 780, 780, 780, 780, + 780, 780, 780, 780, 780, 780, 780, 780, 0, 0, + 0, 754, 780, 780, 780, 780, 584, 0, 780, 0, + 0, 780, 0, 0, 780, 0, 780, 0, 780, 314, + 780, 0, 780, 780, 780, 780, 780, 780, 780, 314, + 780, 780, 780, 0, 0, 0, 0, 0, 0, 0, + 646, 646, 646, 0, 780, 0, 646, 646, 0, 646, + 0, 0, 0, 0, 0, 0, 780, 0, 780, 0, + 314, 0, 0, 314, 0, 0, 0, 646, 646, 0, + 646, 646, 646, 646, 646, 0, 0, 314, 314, 0, + 129, 0, 314, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 646, 646, 646, 646, 646, 646, + 646, 646, 646, 646, 646, 646, 646, 646, 0, 0, + 314, 0, 646, 646, 646, 646, 0, 658, 0, 0, + 0, 646, 0, 0, 0, 0, 0, 0, 646, 647, + 646, 0, 646, 646, 646, 646, 646, 646, 646, 647, + 646, 0, 646, 0, 584, 584, 584, 0, 0, 584, + 584, 584, 0, 584, 0, 0, 0, 0, 0, 0, + 0, 0, 584, 584, 0, 0, 646, 0, 646, 0, + 0, 584, 584, 100, 584, 584, 584, 584, 584, 0, + 0, 0, 0, 0, 0, 0, 584, 0, 647, 0, + 119, 0, 647, 0, 0, 0, 0, 0, 584, 584, + 584, 584, 584, 584, 584, 584, 584, 584, 584, 584, + 584, 584, 0, 0, 0, 0, 584, 584, 584, 584, + 647, 0, 584, 0, 0, 584, 0, 0, 584, 0, + 584, 0, 584, 325, 584, 0, 584, 584, 584, 584, + 584, 584, 584, 325, 584, 0, 584, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 584, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 584, 0, 584, 0, 325, 0, 0, 325, 0, 0, + 0, 314, 314, 314, 0, 0, 314, 314, 314, 0, + 314, 325, 325, 0, 128, 0, 325, 0, 0, 314, + 314, 0, 0, 0, 0, 0, 0, 0, 314, 314, + 0, 314, 314, 314, 314, 314, 0, 0, 0, 0, + 0, 0, 0, 314, 325, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 314, 314, 314, 314, 314, + 314, 314, 314, 314, 314, 314, 314, 314, 314, 0, + 123, 0, 0, 314, 314, 314, 314, 0, 0, 314, + 0, 0, 314, 0, 0, 314, 0, 314, 0, 314, + 336, 314, 0, 314, 314, 314, 314, 314, 314, 314, + 336, 314, 0, 314, 0, 0, 0, 0, 0, 0, + 0, 647, 647, 647, 0, 314, 0, 647, 647, 123, + 647, 0, 0, 0, 0, 0, 0, 314, 0, 314, + 0, 336, 0, 0, 336, 0, 0, 0, 647, 647, + 0, 647, 647, 647, 647, 647, 0, 0, 336, 336, + 0, 454, 0, 336, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 647, 647, 647, 647, 647, + 647, 647, 647, 647, 647, 647, 647, 647, 647, 0, + 0, 336, 0, 647, 647, 647, 647, 0, 659, 0, + 0, 0, 647, 0, 0, 0, 0, 0, 0, 647, + 649, 647, 0, 647, 647, 647, 647, 647, 647, 647, + 649, 647, 0, 647, 0, 325, 325, 325, 0, 0, + 325, 325, 325, 0, 325, 0, 0, 0, 0, 0, + 0, 0, 0, 325, 325, 0, 0, 647, 0, 647, + 0, 0, 325, 325, 102, 325, 325, 325, 325, 325, + 0, 0, 0, 0, 0, 0, 0, 325, 0, 649, + 0, 121, 0, 649, 0, 0, 0, 0, 0, 325, + 325, 325, 325, 325, 325, 325, 325, 325, 325, 325, + 325, 325, 325, 0, 0, 0, 0, 325, 325, 325, + 325, 649, 0, 325, 0, 0, 325, 0, 0, 325, + 0, 325, 0, 325, 261, 325, 0, 325, 325, 325, + 325, 325, 325, 325, 261, 325, 0, 325, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 123, 0, 325, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 454, + 0, 325, 0, 325, 0, 261, 0, 0, 261, 0, + 0, 0, 336, 336, 336, 0, 0, 336, 336, 336, + 0, 336, 261, 261, 0, 0, 0, 261, 0, 0, + 336, 336, 0, 0, 0, 0, 0, 0, 0, 336, + 336, 0, 336, 336, 336, 336, 336, 454, 0, 0, + 0, 0, 0, 0, 336, 369, 454, 454, 0, 0, + 0, 0, 0, 0, 0, 0, 336, 336, 336, 336, + 336, 336, 336, 336, 336, 336, 336, 336, 336, 336, + 0, 0, 0, 454, 336, 336, 336, 336, 0, 0, + 336, 0, 0, 336, 0, 0, 336, 0, 336, 0, + 336, 331, 336, 0, 336, 336, 336, 336, 336, 336, + 336, 331, 336, 0, 336, 0, 0, 0, 0, 0, + 0, 0, 649, 649, 649, 0, 336, 0, 649, 649, + 0, 649, 0, 0, 0, 0, 0, 0, 336, 0, + 336, 0, 331, 0, 0, 331, 0, 0, 0, 649, + 649, 0, 649, 649, 649, 649, 649, 0, 0, 331, + 331, 0, 0, 0, 331, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 649, 649, 649, 649, + 649, 649, 649, 649, 649, 649, 649, 649, 649, 649, + 0, 0, 331, 0, 649, 649, 649, 649, 0, 661, + 0, 0, 0, 649, 0, 0, 0, 0, 0, 0, + 649, 0, 649, 0, 649, 649, 649, 649, 649, 649, + 649, 0, 649, 0, 649, 0, 261, 261, 261, 0, + 0, 261, 261, 261, 0, 261, 0, 443, 0, 0, + 0, 0, 0, 0, 261, 261, 0, 443, 649, 0, + 649, 0, 0, 261, 261, 0, 261, 261, 261, 261, + 261, 0, 0, 0, 0, 0, 0, 0, 261, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 443, 0, + 261, 261, 261, 261, 261, 261, 261, 261, 261, 261, + 261, 369, 261, 261, 0, 0, 443, 0, 261, 261, + 369, 369, 0, 0, 261, 0, 0, 261, 0, 0, + 261, 0, 261, 0, 261, 365, 261, 0, 261, 261, + 261, 261, 261, 261, 261, 365, 261, 0, 261, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 261, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 261, 0, 261, 0, 365, 0, 0, 365, + 0, 0, 0, 331, 331, 331, 0, 0, 331, 331, + 331, 0, 331, 0, 365, 0, 0, 0, 365, 0, + 0, 331, 331, 0, 0, 0, 0, 0, 0, 0, + 331, 331, 0, 331, 331, 331, 331, 331, 0, 0, + 0, 0, 0, 0, 0, 331, 365, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 331, 331, 331, + 331, 331, 331, 331, 331, 331, 331, 331, 331, 331, + 331, 0, 0, 0, 0, 331, 331, 331, 331, 0, + 0, 331, 0, 0, 331, 0, 0, 331, 0, 331, + 0, 331, 366, 331, 0, 331, 331, 331, 331, 331, + 331, 331, 366, 331, 0, 331, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 331, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 331, + 0, 331, 0, 366, 0, 0, 366, 0, 0, 443, + 443, 443, 542, 0, 443, 443, 443, 0, 443, 0, + 0, 366, 0, 0, 0, 366, 0, 443, 0, 0, + 0, 0, 0, 0, 0, 0, 443, 443, 0, 443, + 443, 443, 443, 443, 0, 0, 542, 0, 0, 0, + 0, 0, 0, 366, 0, 0, 0, 0, 0, 0, + 0, 542, 0, 0, 0, 0, 328, 0, 0, 0, + 0, 0, 0, 0, 443, 0, 328, 0, 0, 0, + 0, 0, 0, 443, 443, 0, 0, 365, 365, 365, + 443, 0, 365, 365, 365, 0, 365, 0, 0, 0, + 0, 0, 0, 0, 0, 365, 365, 328, 0, 0, + 328, 443, 0, 0, 365, 365, 0, 365, 365, 365, + 365, 365, 0, 0, 0, 328, 542, 0, 0, 328, + 0, 0, 0, 0, 0, 443, 0, 443, 0, 0, + 0, 365, 365, 365, 365, 365, 365, 365, 365, 365, + 365, 365, 365, 365, 365, 0, 0, 328, 0, 365, + 365, 365, 365, 0, 0, 365, 0, 0, 365, 0, + 0, 365, 0, 365, 0, 365, 0, 365, 229, 365, + 365, 365, 365, 365, 365, 365, 0, 365, 229, 365, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 365, 0, 365, 0, 0, 0, 229, + 0, 0, 229, 0, 366, 366, 366, 0, 0, 366, + 366, 366, 0, 366, 0, 0, 229, 229, 0, 0, + 0, 229, 366, 366, 0, 0, 0, 0, 0, 0, + 0, 366, 366, 0, 366, 366, 366, 366, 366, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 542, + 0, 0, 0, 0, 0, 0, 0, 0, 366, 366, + 366, 366, 366, 366, 366, 366, 366, 366, 366, 366, + 366, 366, 0, 0, 542, 542, 366, 366, 366, 366, + 0, 0, 366, 0, 0, 366, 0, 0, 366, 0, + 366, 0, 366, 232, 366, 0, 366, 366, 366, 366, + 366, 366, 366, 232, 366, 0, 366, 0, 328, 328, + 328, 0, 0, 328, 328, 328, 0, 328, 0, 0, + 0, 0, 542, 0, 0, 542, 328, 328, 542, 0, + 366, 0, 366, 0, 232, 328, 328, 232, 328, 328, + 328, 328, 328, 0, 0, 0, 542, 0, 0, 0, + 0, 232, 232, 0, 0, 0, 232, 0, 0, 0, + 0, 0, 328, 328, 328, 328, 328, 328, 328, 328, + 328, 328, 328, 328, 328, 328, 0, 0, 0, 0, + 328, 328, 328, 328, 0, 0, 328, 0, 0, 328, + 105, 0, 328, 0, 328, 0, 328, 179, 328, 0, + 328, 328, 328, 328, 328, 328, 328, 0, 328, 0, + 328, 0, 0, 0, 0, 107, 0, 0, 0, 0, + 229, 229, 229, 0, 105, 229, 229, 229, 0, 229, + 0, 0, 0, 0, 328, 0, 328, 0, 229, 229, + 0, 105, 0, 0, 0, 0, 179, 229, 229, 107, + 229, 229, 229, 229, 229, 0, 0, 0, 0, 0, + 0, 0, 229, 0, 0, 0, 107, 0, 0, 0, + 0, 753, 0, 0, 229, 229, 229, 229, 229, 229, + 229, 229, 229, 229, 229, 0, 229, 229, 0, 0, + 0, 0, 229, 229, 0, 242, 754, 0, 229, 0, + 0, 229, 0, 0, 229, 242, 229, 0, 229, 0, + 229, 0, 229, 229, 229, 229, 229, 229, 229, 0, + 229, 0, 229, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 229, 0, 242, 0, 0, 242, + 0, 0, 0, 0, 0, 0, 229, 0, 229, 0, + 0, 0, 0, 242, 242, 232, 232, 232, 242, 0, + 232, 232, 232, 0, 232, 0, 0, 0, 0, 0, + 0, 0, 0, 232, 232, 0, 0, 0, 0, 0, + 0, 0, 232, 232, 0, 232, 232, 232, 232, 232, + 0, 0, 0, 0, 0, 0, 0, 232, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 232, + 232, 232, 232, 232, 232, 232, 232, 232, 232, 232, + 0, 232, 232, 0, 0, 0, 0, 232, 232, 0, + 239, 0, 0, 232, 0, 0, 232, 0, 0, 232, + 239, 232, 0, 232, 0, 232, 0, 232, 232, 232, + 232, 232, 232, 232, 0, 232, 0, 232, 0, 753, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 232, + 0, 239, 0, 0, 239, 0, 0, 0, 0, 0, + 0, 232, 0, 232, 754, 0, 0, 0, 239, 239, + 0, 0, 179, 239, 179, 179, 179, 179, 179, 0, + 0, 0, 0, 179, 0, 0, 0, 753, 0, 0, + 0, 0, 0, 0, 650, 0, 753, 753, 179, 0, + 0, 0, 753, 105, 650, 0, 0, 0, 179, 179, + 0, 0, 754, 0, 135, 0, 179, 179, 179, 179, + 0, 754, 754, 753, 0, 0, 0, 754, 107, 0, + 0, 0, 0, 0, 0, 0, 0, 242, 242, 242, + 0, 0, 242, 242, 242, 0, 242, 0, 754, 0, + 105, 0, 0, 0, 179, 242, 242, 0, 0, 0, + 0, 0, 0, 135, 242, 242, 0, 242, 242, 242, + 242, 242, 0, 0, 0, 107, 0, 0, 0, 242, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 242, 242, 242, 242, 242, 242, 242, 242, + 242, 242, 0, 242, 242, 0, 0, 0, 0, 242, + 242, 0, 236, 0, 0, 242, 0, 0, 242, 0, + 0, 242, 236, 242, 0, 242, 0, 242, 0, 242, + 242, 242, 242, 242, 242, 242, 0, 242, 0, 242, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 242, 0, 236, 0, 0, 236, 0, 0, 0, + 0, 0, 0, 242, 0, 242, 0, 0, 0, 0, + 236, 236, 239, 239, 239, 236, 0, 239, 239, 239, 0, 239, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 239, 0, 0, 0, 0, 0, 0, - 237, 0, 0, 236, 236, 236, 0, 0, 236, 236, - 236, 0, 236, 0, 237, 237, 0, 0, 0, 237, - 236, 0, 236, 236, 0, 0, 0, 0, 0, 0, - 0, 236, 236, 0, 236, 236, 236, 236, 236, 0, - 0, 0, 0, 0, 0, 0, 236, 0, 0, 0, + 239, 239, 0, 0, 0, 0, 0, 0, 0, 239, + 239, 0, 239, 239, 239, 239, 239, 0, 0, 0, + 0, 0, 0, 0, 239, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 239, 239, 239, + 239, 239, 239, 239, 239, 239, 239, 0, 239, 239, + 0, 0, 0, 0, 239, 239, 0, 238, 0, 0, + 239, 0, 0, 239, 0, 0, 239, 238, 239, 0, + 239, 0, 239, 0, 239, 239, 239, 239, 239, 239, + 239, 0, 239, 0, 239, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 239, 0, 238, 0, + 0, 238, 0, 0, 0, 0, 0, 0, 239, 0, + 239, 0, 0, 0, 0, 238, 238, 0, 0, 135, + 238, 135, 135, 135, 135, 135, 0, 0, 0, 0, + 135, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 639, 0, 0, 0, 135, 0, 0, 0, 0, + 0, 639, 0, 0, 0, 135, 135, 0, 0, 0, + 0, 136, 0, 135, 135, 135, 135, 0, 0, 0, + 0, 0, 0, 669, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 236, 236, 236, 0, 0, 236, + 236, 236, 0, 236, 0, 0, 0, 0, 0, 0, + 0, 135, 236, 236, 0, 0, 0, 0, 0, 0, + 136, 236, 236, 0, 236, 236, 236, 236, 236, 0, + 0, 0, 669, 0, 0, 0, 236, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 236, 236, 236, 236, 236, 236, 236, 236, 236, 236, 0, - 236, 236, 0, 0, 0, 0, 236, 236, 0, 0, - 0, 0, 236, 0, 0, 236, 0, 0, 236, 0, - 236, 0, 236, 240, 236, 109, 236, 236, 236, 236, - 236, 236, 236, 240, 236, 0, 236, 238, 238, 238, - 0, 0, 238, 238, 238, 0, 238, 0, 236, 0, - 0, 0, 0, 0, 238, 0, 238, 238, 0, 0, - 236, 0, 0, 0, 0, 238, 238, 240, 238, 238, - 238, 238, 238, 0, 325, 0, 0, 0, 0, 0, - 238, 240, 240, 325, 325, 0, 240, 0, 0, 0, - 109, 0, 0, 238, 238, 238, 238, 238, 238, 238, - 238, 238, 238, 0, 238, 238, 0, 0, 0, 0, - 238, 238, 0, 0, 0, 0, 238, 0, 0, 238, - 0, 0, 238, 0, 238, 0, 238, 454, 238, 0, - 238, 238, 238, 238, 238, 238, 238, 454, 238, 0, - 238, 0, 0, 0, 0, 0, 0, 0, 237, 237, - 237, 0, 238, 237, 237, 237, 0, 237, 0, 0, - 0, 0, 0, 0, 238, 237, 0, 237, 237, 0, - 0, 104, 0, 0, 0, 0, 237, 237, 0, 237, - 237, 237, 237, 237, 0, 0, 454, 0, 123, 0, - 454, 237, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 237, 237, 237, 237, 237, 237, - 237, 237, 237, 237, 0, 237, 237, 0, 454, 0, - 0, 237, 237, 0, 0, 0, 0, 237, 0, 0, - 237, 0, 0, 237, 0, 237, 0, 237, 454, 237, - 0, 237, 237, 237, 237, 237, 237, 237, 454, 237, - 0, 237, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 237, 0, 0, 0, 0, 0, 0, + 236, 236, 0, 0, 0, 0, 236, 236, 0, 237, + 0, 0, 236, 0, 0, 236, 0, 0, 236, 237, + 236, 0, 236, 0, 236, 0, 236, 236, 236, 236, + 236, 236, 236, 0, 236, 0, 236, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 236, 0, + 237, 0, 0, 237, 0, 0, 0, 0, 0, 0, + 236, 0, 236, 0, 0, 0, 0, 237, 237, 238, + 238, 238, 237, 0, 238, 238, 238, 0, 238, 0, + 0, 0, 0, 0, 0, 0, 0, 238, 238, 0, + 0, 0, 0, 0, 0, 0, 238, 238, 0, 238, + 238, 238, 238, 238, 0, 0, 0, 0, 0, 0, + 0, 238, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 238, 238, 238, 238, 238, 238, + 238, 238, 238, 238, 0, 238, 238, 0, 0, 0, + 0, 238, 238, 0, 240, 0, 0, 238, 0, 0, + 238, 0, 0, 238, 240, 238, 0, 238, 0, 238, + 0, 238, 238, 238, 238, 238, 238, 238, 0, 238, + 0, 238, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 238, 0, 240, 0, 0, 240, 0, + 0, 0, 543, 0, 0, 238, 0, 238, 0, 0, + 0, 0, 240, 240, 0, 0, 136, 240, 136, 136, + 136, 136, 136, 0, 0, 0, 0, 136, 669, 0, + 669, 669, 669, 669, 669, 0, 543, 0, 642, 669, + 0, 0, 136, 0, 0, 0, 0, 0, 642, 0, + 0, 543, 136, 136, 669, 0, 0, 0, 648, 0, + 136, 136, 136, 136, 669, 0, 0, 0, 648, 0, + 0, 0, 669, 669, 669, 669, 0, 0, 0, 0, + 0, 237, 237, 237, 0, 0, 237, 237, 237, 0, + 237, 0, 0, 0, 0, 0, 0, 0, 136, 237, + 237, 0, 101, 0, 0, 0, 0, 0, 237, 237, + 669, 237, 237, 237, 237, 237, 543, 648, 0, 120, + 0, 648, 0, 237, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 237, 237, 237, 237, + 237, 237, 237, 237, 237, 237, 0, 237, 237, 648, + 0, 0, 0, 237, 237, 0, 0, 0, 0, 237, + 0, 0, 237, 0, 0, 237, 0, 237, 0, 237, + 650, 237, 0, 237, 237, 237, 237, 237, 237, 237, + 650, 237, 0, 237, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 237, 0, 0, 0, 0, - 0, 0, 454, 0, 0, 240, 240, 240, 0, 0, - 240, 240, 240, 0, 240, 0, 0, 454, 0, 123, - 0, 454, 240, 0, 240, 240, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 237, 0, 237, + 0, 0, 0, 0, 103, 0, 240, 240, 240, 0, + 0, 240, 240, 240, 0, 240, 0, 0, 0, 650, + 0, 122, 0, 650, 240, 240, 0, 0, 0, 0, 0, 0, 0, 240, 240, 0, 240, 240, 240, 240, - 240, 0, 0, 0, 0, 0, 0, 0, 240, 454, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 240, 0, 0, 0, 0, 0, 0, 0, 240, 543, + 0, 650, 0, 0, 0, 0, 0, 0, 0, 0, 0, 240, 240, 240, 240, 240, 240, 240, 240, 240, - 240, 0, 240, 240, 0, 0, 0, 0, 240, 240, + 240, 0, 240, 240, 543, 543, 0, 0, 240, 240, 0, 0, 0, 0, 240, 0, 0, 240, 0, 0, - 240, 0, 240, 0, 240, 539, 240, 0, 240, 240, - 240, 240, 240, 240, 240, 539, 240, 0, 240, 454, - 454, 454, 0, 0, 0, 454, 454, 0, 454, 0, - 240, 0, 0, 0, 0, 0, 454, 454, 0, 0, - 0, 0, 240, 0, 0, 0, 0, 454, 454, 98, - 454, 454, 454, 454, 454, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 539, 0, 117, 0, 539, 0, - 0, 0, 0, 0, 454, 454, 454, 454, 454, 454, - 454, 454, 454, 454, 454, 454, 454, 454, 0, 0, - 0, 0, 454, 454, 454, 454, 539, 0, 0, 0, - 0, 454, 0, 0, 0, 0, 0, 0, 454, 538, - 454, 0, 454, 454, 454, 454, 454, 454, 454, 538, - 454, 454, 454, 0, 0, 0, 0, 0, 0, 0, - 454, 454, 454, 0, 0, 0, 454, 454, 0, 454, - 0, 0, 0, 0, 0, 0, 454, 454, 454, 0, - 0, 0, 0, 97, 0, 0, 0, 0, 454, 454, - 0, 454, 454, 454, 454, 454, 0, 0, 538, 0, - 116, 0, 538, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 454, 454, 454, 454, 454, - 454, 454, 454, 454, 454, 454, 454, 454, 454, 0, - 538, 0, 0, 454, 454, 454, 454, 0, 0, 0, - 0, 0, 454, 0, 0, 0, 0, 0, 0, 454, - 540, 454, 0, 454, 454, 454, 454, 454, 454, 454, - 540, 454, 454, 454, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 454, 0, 0, - 0, 0, 0, 0, 99, 0, 0, 539, 539, 539, - 0, 0, 0, 539, 539, 0, 539, 0, 0, 540, - 0, 118, 0, 540, 539, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 539, 539, 0, 539, 539, - 539, 539, 539, 0, 0, 0, 0, 0, 0, 0, - 0, 540, 0, 0, 0, 0, + 240, 0, 240, 0, 240, 641, 240, 0, 240, 240, + 240, 240, 240, 240, 240, 641, 240, 0, 240, 0, + 648, 648, 648, 0, 0, 0, 648, 648, 0, 648, + 240, 0, 543, 0, 0, 543, 0, 0, 543, 0, + 0, 0, 240, 0, 240, 0, 0, 648, 648, 94, + 648, 648, 648, 648, 648, 0, 543, 0, 0, 0, + 0, 0, 0, 0, 641, 0, 113, 0, 641, 0, + 0, 0, 0, 0, 648, 648, 648, 648, 648, 648, + 648, 648, 648, 648, 648, 648, 648, 648, 0, 0, + 0, 0, 648, 648, 648, 648, 641, 660, 0, 0, + 0, 648, 0, 0, 0, 0, 0, 0, 648, 640, + 648, 0, 648, 648, 648, 648, 648, 648, 648, 640, + 648, 0, 648, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 650, 650, 650, 0, 0, 0, }; } private static final short[] yyTable3() { return new short[] { - 0, 0, 0, 0, 0, 0, 539, 539, 539, 539, - 539, 539, 539, 539, 539, 539, 539, 539, 539, 539, - 0, 0, 0, 0, 539, 539, 539, 539, 0, 551, - 0, 0, 0, 539, 0, 0, 0, 0, 0, 0, - 539, 541, 539, 0, 539, 539, 539, 539, 539, 539, - 539, 541, 539, 0, 539, 538, 538, 538, 0, 0, - 0, 538, 538, 0, 538, 0, 0, 0, 0, 0, - 0, 0, 538, 0, 0, 0, 0, 0, 539, 0, - 0, 0, 0, 538, 538, 100, 538, 538, 538, 538, - 538, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 541, 0, 119, 0, 541, 0, 0, 0, 0, 0, - 538, 538, 538, 538, 538, 538, 538, 538, 538, 538, - 538, 538, 538, 538, 0, 0, 0, 0, 538, 538, - 538, 538, 541, 550, 0, 0, 0, 538, 0, 0, - 0, 0, 0, 0, 538, 543, 538, 0, 538, 538, - 538, 538, 538, 538, 538, 543, 538, 0, 538, 0, - 0, 0, 0, 0, 0, 0, 540, 540, 540, 0, - 0, 0, 540, 540, 0, 540, 0, 0, 0, 0, - 0, 0, 538, 540, 947, 0, 0, 0, 956, 102, - 0, 0, 0, 0, 540, 540, 0, 540, 540, 540, - 540, 540, 0, 0, 543, 0, 121, 0, 543, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 540, 540, 540, 540, 540, 540, 540, 540, 540, - 540, 540, 540, 540, 540, 0, 543, 0, 0, 540, - 540, 540, 540, 0, 552, 0, 0, 0, 540, 0, - 0, 0, 0, 0, 0, 540, 542, 540, 0, 540, - 540, 540, 540, 540, 540, 540, 542, 540, 0, 540, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 1027, 0, - 0, 0, 0, 540, 0, 0, 0, 0, 0, 0, - 101, 0, 0, 541, 541, 541, 0, 0, 0, 541, - 541, 0, 541, 0, 0, 542, 0, 120, 0, 542, - 541, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 541, 541, 0, 541, 541, 541, 541, 541, 0, - 0, 1060, 0, 1062, 0, 1063, 0, 542, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 541, 541, - 541, 541, 541, 541, 541, 541, 541, 541, 541, 541, - 541, 541, 0, 0, 0, 0, 541, 541, 541, 541, - 0, 553, 0, 0, 0, 541, 0, 0, 1100, 0, - 0, 0, 541, 544, 541, 1108, 541, 541, 541, 541, - 541, 541, 541, 544, 541, 0, 541, 543, 543, 543, - 0, 0, 0, 543, 543, 0, 543, 0, 0, 0, - 1117, 0, 0, 0, 543, 0, 0, 0, 0, 0, - 541, 0, 0, 0, 0, 543, 543, 103, 543, 543, - 543, 543, 543, 0, 1131, 0, 1133, 0, 0, 1134, - 0, 0, 544, 0, 122, 0, 544, 0, 0, 0, - 1140, 0, 543, 543, 543, 543, 543, 543, 543, 543, - 543, 543, 543, 543, 543, 543, 0, 0, 0, 0, - 543, 543, 543, 543, 544, 555, 0, 0, 0, 543, - 0, 0, 0, 0, 0, 0, 543, 535, 543, 0, - 543, 543, 543, 543, 543, 543, 543, 535, 543, 0, - 543, 0, 0, 0, 0, 0, 0, 0, 542, 542, - 542, 0, 0, 0, 542, 542, 0, 542, 0, 0, - 0, 0, 0, 0, 543, 542, 0, 0, 0, 0, - 0, 94, 0, 0, 0, 0, 542, 542, 0, 542, - 542, 542, 542, 542, 0, 0, 535, 0, 113, 0, - 535, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 542, 542, 542, 542, 542, 542, 542, - 542, 542, 542, 542, 542, 542, 542, 0, 535, 0, - 0, 542, 542, 542, 542, 0, 554, 0, 0, 0, - 542, 0, 0, 0, 0, 0, 0, 542, 534, 542, - 0, 542, 542, 542, 542, 542, 542, 542, 534, 542, - 0, 542, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 542, 0, 0, 0, 0, - 0, 0, 93, 0, 0, 544, 544, 544, 0, 0, - 0, 544, 544, 0, 544, 0, 0, 534, 0, 112, - 0, 534, 544, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 544, 544, 0, 544, 544, 544, 544, - 544, 0, 0, 0, 0, 0, 0, 0, 0, 534, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 544, 544, 544, 544, 544, 544, 544, 544, 544, 544, - 544, 544, 544, 544, 0, 0, 0, 0, 544, 544, - 544, 544, 0, 556, 0, 0, 0, 544, 0, 0, - 0, 0, 0, 0, 544, 537, 544, 0, 544, 544, - 544, 544, 544, 544, 544, 537, 544, 0, 544, 535, - 535, 535, 0, 0, 0, 535, 535, 0, 535, 0, - 0, 0, 0, 0, 0, 0, 535, 0, 0, 0, - 0, 0, 544, 0, 0, 0, 0, 535, 535, 96, - 535, 535, 535, 535, 535, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 537, 0, 115, 0, 537, 0, - 0, 0, 0, 0, 535, 535, 535, 535, 535, 535, - 535, 535, 535, 535, 535, 535, 535, 535, 0, 0, - 0, 0, 535, 535, 535, 535, 537, 547, 0, 0, - 0, 535, 0, 0, 0, 0, 0, 0, 535, 247, - 535, 0, 535, 535, 535, 535, 535, 535, 535, 247, - 535, 0, 535, 0, 0, 0, 0, 0, 0, 0, - 534, 534, 534, 0, 0, 0, 534, 534, 0, 534, - 0, 0, 0, 0, 0, 0, 535, 534, 0, 0, - 0, 0, 0, 247, 0, 0, 0, 0, 534, 534, - 0, 534, 534, 534, 534, 534, 0, 247, 247, 0, - 0, 0, 247, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 534, 534, 534, 534, 534, - 534, 534, 534, 534, 534, 534, 534, 534, 534, 0, - 0, 0, 0, 534, 534, 534, 534, 0, 546, 0, - 0, 0, 534, 0, 0, 0, 0, 0, 0, 534, - 314, 534, 0, 534, 534, 534, 534, 534, 534, 534, - 314, 534, 0, 534, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 534, 0, 0, - 0, 0, 0, 0, 110, 0, 0, 537, 537, 537, - 0, 0, 0, 537, 537, 0, 537, 0, 0, 314, - 0, 129, 0, 314, 537, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 537, 537, 0, 537, 537, - 537, 537, 537, 0, 0, 0, 0, 0, 0, 0, - 0, 314, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 537, 537, 537, 537, 537, 537, 537, 537, - 537, 537, 537, 537, 537, 537, 0, 0, 0, 0, - 537, 537, 537, 537, 0, 549, 0, 0, 0, 537, - 0, 0, 0, 0, 0, 0, 537, 325, 537, 0, - 537, 537, 537, 537, 537, 537, 537, 325, 537, 0, - 537, 247, 247, 247, 0, 0, 247, 247, 247, 0, - 247, 0, 0, 0, 0, 0, 0, 0, 247, 0, - 247, 247, 0, 0, 537, 0, 0, 0, 0, 247, - 247, 109, 247, 247, 247, 247, 247, 0, 0, 0, - 0, 0, 0, 0, 247, 0, 325, 0, 128, 0, - 325, 0, 0, 0, 0, 0, 247, 247, 247, 247, - 247, 0, 0, 247, 247, 247, 247, 0, 247, 247, - 0, 0, 0, 0, 247, 247, 0, 0, 325, 0, - 247, 0, 0, 247, 0, 0, 247, 0, 247, 0, - 247, 234, 247, 0, 247, 247, 247, 247, 0, 0, - 247, 234, 247, 0, 247, 0, 0, 0, 0, 0, - 0, 0, 314, 314, 314, 0, 247, 0, 314, 314, - 0, 314, 0, 0, 0, 0, 0, 0, 247, 314, - 0, 0, 0, 0, 0, 234, 0, 0, 0, 0, - 314, 314, 0, 314, 314, 314, 314, 314, 0, 234, - 234, 0, 0, 0, 234, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 314, 314, 314, - 314, 314, 314, 314, 314, 314, 314, 314, 314, 314, - 314, 0, 0, 0, 0, 314, 314, 314, 314, 0, - 0, 0, 0, 0, 314, 0, 0, 0, 0, 0, - 0, 314, 235, 314, 0, 314, 314, 314, 314, 314, - 314, 314, 235, 314, 0, 314, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 314, - 0, 0, 0, 0, 0, 0, 235, 0, 0, 325, - 325, 325, 0, 0, 0, 325, 325, 0, 325, 0, - 235, 235, 0, 0, 0, 235, 325, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 325, 325, 0, - 325, 325, 325, 325, 325, 0, 0, 536, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 325, 325, 325, 325, 325, 325, - 325, 325, 325, 325, 325, 325, 325, 325, 0, 0, - 0, 536, 325, 325, 325, 325, 0, 0, 0, 0, - 0, 325, 0, 0, 0, 0, 536, 0, 325, 314, - 325, 0, 325, 325, 325, 325, 325, 325, 325, 314, - 325, 0, 325, 234, 234, 234, 0, 0, 234, 234, - 234, 0, 234, 0, 0, 0, 0, 0, 536, 0, - 234, 0, 234, 234, 0, 0, 325, 0, 0, 0, - 0, 234, 234, 314, 234, 234, 234, 234, 234, 0, + 650, 650, 0, 650, 0, 0, 0, 0, 648, 0, + 648, 0, 0, 0, 0, 93, 0, 0, 0, 0, + 0, 650, 650, 0, 650, 650, 650, 650, 650, 0, + 640, 0, 112, 0, 640, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 650, 650, + 650, 650, 650, 650, 650, 650, 650, 650, 650, 650, + 650, 650, 640, 0, 0, 0, 650, 650, 650, 650, + 0, 662, 0, 0, 0, 650, 0, 0, 0, 0, + 0, 0, 650, 643, 650, 0, 650, 650, 650, 650, + 650, 650, 650, 643, 650, 0, 650, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 650, 0, 650, 0, 0, 0, 0, 96, 0, 641, + 641, 641, 0, 0, 0, 641, 641, 0, 641, 0, + 0, 0, 643, 0, 115, 0, 643, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 641, 641, 0, 641, + 641, 641, 641, 641, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 643, 0, 0, 0, 0, 0, + 0, 0, 0, 641, 641, 641, 641, 641, 641, 641, + 641, 641, 641, 641, 641, 641, 641, 0, 0, 0, + 0, 641, 641, 641, 641, 0, 653, 0, 0, 0, + 641, 0, 0, 0, 0, 0, 0, 641, 247, 641, + 0, 641, 641, 641, 641, 641, 641, 641, 247, 641, + 0, 641, 0, 640, 640, 640, 0, 0, 0, 640, + 640, 0, 640, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 641, 0, 641, 0, 247, + 640, 640, 247, 640, 640, 640, 640, 640, 0, 0, + 0, 0, 0, 0, 0, 0, 247, 247, 0, 0, + 0, 247, 0, 0, 0, 0, 0, 640, 640, 640, + 640, 640, 640, 640, 640, 640, 640, 640, 640, 640, + 640, 0, 0, 0, 0, 640, 640, 640, 640, 0, + 652, 0, 0, 0, 640, 0, 0, 0, 0, 0, + 0, 640, 234, 640, 0, 640, 640, 640, 640, 640, + 640, 640, 234, 640, 0, 640, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 643, 643, 643, 0, 0, + 0, 643, 643, 0, 643, 0, 0, 0, 0, 640, + 0, 640, 0, 234, 0, 0, 234, 0, 0, 0, + 0, 0, 643, 643, 0, 643, 643, 643, 643, 643, + 234, 234, 0, 0, 0, 234, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 643, + 643, 643, 643, 643, 643, 643, 643, 643, 643, 643, + 643, 643, 643, 0, 0, 0, 0, 643, 643, 643, + 643, 0, 655, 0, 0, 0, 643, 0, 0, 0, + 0, 0, 0, 643, 0, 643, 0, 643, 643, 643, + 643, 643, 643, 643, 0, 643, 0, 643, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 235, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 235, 643, 0, 643, 0, 0, 0, 0, 0, 0, + 247, 247, 247, 0, 0, 247, 247, 247, 0, 247, + 0, 0, 0, 0, 0, 0, 0, 0, 247, 247, + 0, 235, 0, 0, 235, 0, 0, 247, 247, 0, + 247, 247, 247, 247, 247, 0, 0, 0, 235, 235, + 0, 0, 247, 235, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 247, 247, 247, 247, 247, 0, + 0, 247, 247, 247, 247, 0, 247, 247, 0, 0, + 0, 0, 247, 247, 0, 0, 0, 0, 247, 0, + 0, 247, 0, 0, 247, 0, 247, 0, 247, 314, + 247, 0, 247, 247, 247, 247, 0, 0, 247, 314, + 247, 0, 247, 0, 234, 234, 234, 0, 0, 234, + 234, 234, 0, 234, 247, 0, 0, 0, 0, 0, + 0, 0, 234, 234, 0, 0, 247, 0, 247, 0, + 0, 234, 234, 110, 234, 234, 234, 234, 234, 0, 0, 0, 0, 0, 0, 0, 234, 0, 314, 0, 129, 0, 314, 0, 0, 0, 0, 0, 0, 234, 234, 234, 234, 234, 234, 234, 234, 234, 234, 0, 234, 234, 0, 0, 0, 0, 234, 234, 0, 0, 314, 0, 234, 0, 0, 234, 0, 0, 234, 0, - 234, 0, 0, 255, 234, 0, 0, 0, 234, 234, - 234, 234, 234, 255, 234, 0, 234, 0, 0, 0, - 0, 0, 0, 0, 235, 235, 235, 0, 234, 235, - 235, 235, 0, 235, 0, 0, 0, 0, 0, 0, - 234, 235, 0, 235, 235, 0, 0, 255, 0, 0, - 0, 0, 235, 235, 0, 235, 235, 235, 235, 235, - 0, 255, 255, 0, 0, 0, 255, 235, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 235, 235, 235, 235, 235, 235, 235, 235, 235, 235, - 0, 235, 235, 0, 0, 0, 0, 235, 235, 0, - 0, 0, 0, 235, 0, 0, 235, 0, 0, 235, - 0, 235, 0, 0, 256, 235, 0, 645, 0, 235, - 235, 235, 235, 235, 256, 235, 0, 235, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 235, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 235, 0, 0, 0, 0, 0, 0, 256, 0, - 0, 314, 314, 314, 0, 536, 0, 314, 314, 0, - 314, 0, 256, 256, 536, 536, 0, 256, 314, 0, - 645, 0, 0, 0, 0, 0, 0, 0, 0, 314, - 314, 0, 314, 314, 314, 314, 314, 0, 536, 0, - 0, 645, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 314, 314, 314, 314, + 234, 0, 0, 0, 234, 325, 0, 0, 234, 234, + 234, 234, 234, 0, 234, 325, 234, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 234, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 234, 0, 234, 0, 0, 0, 0, 0, 0, 109, + 0, 0, 235, 235, 235, 0, 0, 235, 235, 235, + 0, 235, 0, 0, 325, 0, 128, 0, 325, 0, + 235, 235, 0, 0, 0, 0, 0, 0, 0, 235, + 235, 0, 235, 235, 235, 235, 235, 0, 0, 0, + 0, 0, 0, 0, 235, 0, 325, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 235, 235, 235, + 235, 235, 235, 235, 235, 235, 235, 0, 235, 235, + 0, 0, 0, 0, 235, 235, 0, 0, 0, 0, + 235, 0, 0, 235, 0, 0, 235, 0, 235, 0, + 0, 314, 235, 0, 0, 0, 235, 235, 235, 235, + 235, 314, 235, 0, 235, 0, 0, 0, 0, 0, + 0, 314, 314, 314, 0, 0, 235, 314, 314, 0, + 314, 0, 0, 0, 0, 0, 0, 0, 235, 0, + 235, 0, 0, 0, 0, 314, 0, 0, 314, 314, + 0, 314, 314, 314, 314, 314, 0, 0, 0, 0, + 314, 0, 129, 0, 314, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 314, 314, 314, 314, 314, + 314, 314, 314, 314, 314, 314, 314, 314, 314, 0, + 0, 0, 314, 314, 314, 314, 314, 0, 0, 0, + 0, 0, 314, 0, 0, 0, 0, 0, 0, 314, + 0, 314, 255, 314, 314, 314, 314, 314, 314, 314, + 0, 314, 255, 314, 0, 0, 0, 325, 325, 325, + 0, 0, 0, 325, 325, 0, 325, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 314, 0, 314, + 0, 0, 0, 255, 325, 325, 255, 325, 325, 325, + 325, 325, 0, 0, 0, 0, 0, 0, 0, 0, + 255, 255, 0, 0, 0, 255, 0, 0, 0, 0, + 0, 325, 325, 325, 325, 325, 325, 325, 325, 325, + 325, 325, 325, 325, 325, 0, 0, 0, 0, 325, + 325, 325, 325, 0, 0, 0, 0, 0, 325, 0, + 0, 0, 0, 0, 0, 325, 256, 325, 0, 325, + 325, 325, 325, 325, 325, 325, 256, 325, 0, 325, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 325, 0, 325, 0, 256, 0, 0, + 256, 0, 0, 314, 314, 314, 0, 0, 0, 314, + 314, 0, 314, 0, 256, 256, 0, 0, 0, 256, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 314, 314, 0, 314, 314, 314, 314, 314, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 314, 314, 314, 314, 314, 314, 314, 314, 314, 314, 314, 314, 314, - 0, 0, 0, 0, 314, 314, 314, 314, 0, 0, - 0, 0, 0, 314, 0, 0, 0, 0, 0, 0, - 314, 245, 314, 0, 314, 314, 314, 314, 314, 314, - 314, 245, 314, 0, 314, 255, 255, 255, 0, 0, - 255, 255, 255, 0, 255, 0, 0, 0, 0, 0, - 0, 0, 255, 0, 255, 255, 0, 0, 314, 0, - 0, 0, 0, 255, 255, 245, 255, 255, 255, 255, - 255, 0, 0, 0, 0, 0, 0, 0, 255, 245, - 245, 0, 0, 0, 245, 0, 0, 0, 0, 0, - 0, 255, 255, 255, 255, 255, 255, 255, 255, 255, - 255, 0, 255, 255, 0, 0, 0, 0, 255, 255, - 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, - 255, 0, 255, 0, 0, 243, 255, 0, 0, 0, - 0, 0, 255, 255, 255, 243, 255, 0, 255, 0, - 0, 0, 0, 0, 0, 0, 256, 256, 256, 0, - 255, 256, 256, 256, 0, 256, 0, 0, 0, 0, - 0, 0, 255, 256, 0, 256, 256, 0, 0, 243, - 0, 0, 0, 0, 256, 256, 0, 256, 256, 256, - 256, 256, 0, 243, 243, 0, 0, 0, 243, 256, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 256, 256, 256, 256, 256, 256, 256, 256, - 256, 256, 0, 256, 256, 0, 0, 0, 0, 256, - 256, 0, 0, 0, 0, 256, 0, 0, 256, 0, - 0, 256, 0, 256, 0, 0, 244, 256, 0, 0, - 0, 0, 0, 256, 256, 256, 244, 256, 0, 256, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 256, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 256, 0, 0, 651, 0, 0, 0, - 244, 0, 0, 245, 245, 245, 0, 0, 245, 245, - 245, 0, 245, 0, 244, 244, 0, 0, 0, 244, - 245, 0, 245, 245, 0, 0, 0, 0, 0, 0, - 651, 245, 245, 0, 245, 245, 245, 245, 245, 0, - 0, 0, 0, 0, 0, 651, 245, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 245, - 245, 245, 245, 245, 245, 245, 245, 245, 245, 0, - 245, 245, 0, 0, 0, 0, 0, 651, 0, 0, - 0, 0, 245, 0, 0, 245, 0, 0, 245, 266, - 245, 0, 0, 0, 245, 0, 0, 0, 0, 266, - 245, 245, 245, 0, 245, 0, 245, 243, 243, 243, - 0, 0, 243, 243, 243, 0, 243, 0, 245, 0, - 0, 0, 0, 0, 243, 0, 243, 243, 0, 0, - 245, 0, 0, 266, 0, 243, 243, 0, 243, 243, - 243, 243, 243, 0, 0, 0, 0, 266, 266, 0, - 243, 0, 266, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 243, 243, 243, 243, 243, 243, 243, - 243, 243, 243, 0, 243, 243, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 243, 0, 0, 243, - 0, 0, 243, 0, 243, 0, 0, 0, 0, 0, - 0, 267, 0, 0, 243, 243, 243, 0, 243, 0, - 243, 267, 0, 0, 0, 0, 0, 0, 244, 244, - 244, 0, 243, 244, 244, 244, 0, 244, 0, 0, - 0, 0, 0, 0, 243, 244, 0, 244, 244, 0, - 0, 0, 0, 0, 0, 267, 244, 244, 0, 244, - 244, 244, 244, 244, 0, 0, 0, 0, 0, 267, - 267, 244, 0, 0, 267, 0, 651, 0, 0, 0, - 0, 0, 0, 0, 244, 244, 244, 244, 244, 244, - 244, 244, 244, 244, 0, 244, 244, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 244, 0, 0, - 244, 0, 0, 244, 0, 244, 0, 0, 0, 0, - 0, 0, 0, 0, 651, 244, 244, 244, 246, 244, - 0, 244, 0, 651, 651, 0, 0, 0, 246, 647, - 0, 0, 0, 244, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 244, 0, 651, 0, 0, - 651, 266, 266, 266, 0, 0, 266, 266, 266, 0, - 266, 0, 246, 0, 0, 0, 0, 0, 266, 0, - 266, 266, 0, 0, 0, 0, 246, 246, 0, 266, - 266, 246, 266, 266, 266, 266, 266, 0, 0, 0, - 0, 0, 0, 0, 266, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 266, 266, 266, - 266, 266, 266, 266, 266, 266, 266, 0, 266, 266, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 266, 0, 0, 266, 0, 0, 266, 0, 266, 0, - 0, 248, 0, 0, 0, 0, 0, 0, 266, 266, - 0, 248, 0, 0, 266, 0, 0, 0, 0, 0, - 0, 0, 0, 267, 267, 267, 266, 0, 267, 267, - 267, 0, 267, 0, 0, 0, 0, 0, 266, 0, - 267, 0, 267, 267, 0, 248, 0, 0, 0, 0, - 0, 267, 267, 0, 267, 267, 267, 267, 267, 248, - 248, 0, 0, 0, 248, 0, 267, 0, 0, 0, + 314, 0, 0, 0, 0, 314, 314, 314, 314, 0, + 0, 0, 0, 0, 314, 0, 0, 0, 0, 0, + 0, 314, 0, 314, 245, 314, 314, 314, 314, 314, + 314, 314, 0, 314, 245, 314, 0, 0, 0, 0, + 0, 0, 0, 0, 255, 255, 255, 0, 0, 255, + 255, 255, 0, 255, 0, 0, 0, 0, 0, 314, + 0, 314, 255, 255, 0, 245, 0, 0, 245, 0, + 0, 255, 255, 0, 255, 255, 255, 255, 255, 0, + 0, 0, 245, 245, 0, 0, 255, 245, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 0, + 255, 255, 0, 0, 0, 0, 255, 255, 0, 0, + 0, 0, 255, 0, 0, 255, 0, 0, 255, 0, + 255, 0, 0, 0, 255, 0, 0, 0, 0, 0, + 255, 255, 255, 0, 255, 0, 255, 0, 256, 256, + 256, 0, 0, 256, 256, 256, 0, 256, 255, 0, + 0, 0, 0, 0, 0, 0, 256, 256, 0, 0, + 255, 0, 255, 0, 0, 256, 256, 0, 256, 256, + 256, 256, 256, 0, 243, 0, 0, 0, 0, 0, + 256, 0, 0, 0, 243, 0, 0, 0, 0, 0, + 0, 0, 0, 256, 256, 256, 256, 256, 256, 256, + 256, 256, 256, 0, 256, 256, 0, 0, 0, 0, + 256, 256, 0, 0, 0, 243, 256, 0, 243, 256, + 0, 0, 256, 0, 256, 0, 0, 0, 256, 0, + 0, 0, 243, 243, 256, 256, 256, 243, 256, 0, + 256, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 256, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 256, 0, 256, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 245, 245, 245, 0, + 0, 245, 245, 245, 0, 245, 0, 0, 0, 0, + 0, 0, 0, 0, 245, 245, 0, 0, 0, 0, + 0, 0, 0, 245, 245, 244, 245, 245, 245, 245, + 245, 0, 0, 0, 0, 244, 0, 0, 245, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 245, 245, 245, 245, 245, 245, 245, 245, 245, + 245, 0, 245, 245, 0, 0, 244, 0, 0, 244, + 0, 0, 0, 0, 245, 0, 0, 245, 0, 0, + 245, 0, 245, 244, 244, 0, 245, 0, 244, 0, + 0, 0, 245, 245, 245, 0, 245, 0, 245, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 245, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 245, 0, 245, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 266, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 266, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 243, 243, 243, 0, + 0, 243, 243, 243, 0, 243, 0, 0, 0, 0, + 0, 0, 0, 0, 243, 243, 0, 266, 0, 0, + 266, 0, 0, 243, 243, 0, 243, 243, 243, 243, + 243, 0, 0, 0, 266, 266, 0, 0, 243, 266, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 243, 243, 243, 243, 243, 243, 243, 243, 243, + 243, 0, 243, 243, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 243, 0, 0, 243, 0, 267, + 243, 0, 243, 0, 0, 0, 0, 0, 0, 267, + 0, 0, 243, 243, 243, 0, 243, 0, 243, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 243, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 267, 0, 243, 267, 243, 0, 0, 244, 244, 244, + 0, 0, 244, 244, 244, 0, 244, 267, 267, 0, + 0, 0, 267, 0, 0, 244, 244, 0, 0, 0, + 0, 0, 0, 0, 244, 244, 0, 244, 244, 244, + 244, 244, 0, 0, 0, 0, 0, 0, 0, 244, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 244, 244, 244, 244, 244, 244, 244, 244, + 244, 244, 0, 244, 244, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 244, 0, 0, 244, 0, + 0, 244, 0, 244, 0, 0, 0, 0, 246, 0, + 0, 0, 0, 244, 244, 244, 0, 244, 246, 244, + 0, 0, 0, 0, 0, 0, 0, 0, 266, 266, + 266, 244, 0, 266, 266, 266, 0, 266, 0, 0, + 0, 0, 0, 244, 0, 244, 266, 266, 0, 246, + 0, 0, 246, 0, 0, 266, 266, 0, 266, 266, + 266, 266, 266, 0, 0, 0, 246, 246, 0, 0, + 266, 246, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 266, 266, 266, 266, 266, 266, 266, + 266, 266, 266, 0, 266, 266, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 266, 0, 0, 266, + 0, 248, 266, 0, 266, 0, 0, 0, 0, 0, + 0, 248, 0, 0, 266, 266, 0, 0, 0, 0, + 266, 267, 267, 267, 0, 0, 267, 267, 267, 0, + 267, 0, 266, 0, 0, 0, 0, 0, 0, 267, + 267, 0, 248, 0, 266, 248, 266, 0, 267, 267, + 0, 267, 267, 267, 267, 267, 0, 0, 0, 248, + 248, 0, 0, 267, 248, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 267, 267, 267, 267, + 267, 267, 267, 267, 267, 267, 0, 267, 267, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 267, - 267, 267, 267, 267, 267, 267, 267, 267, 267, 0, - 267, 267, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 267, 0, 0, 267, 0, 0, 267, 0, - 267, 0, 0, 0, 0, 0, 0, 0, 249, 0, - 267, 267, 0, 0, 0, 0, 267, 0, 249, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 267, 0, + 0, 0, 267, 0, 0, 267, 0, 267, 0, 0, + 0, 0, 249, 0, 0, 0, 0, 267, 267, 0, + 0, 0, 249, 267, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 267, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 267, 0, 267, + 0, 0, 0, 249, 0, 0, 249, 0, 0, 0, 246, 246, 246, 0, 0, 246, 246, 246, 0, 246, - 267, 0, 0, 0, 0, 0, 0, 246, 0, 246, - 246, 0, 249, 0, 0, 0, 0, 0, 246, 246, - 0, 246, 246, 246, 246, 246, 249, 249, 0, 0, - 0, 249, 0, 246, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 246, 246, 0, 0, 0, 246, 246, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 250, 246, - 0, 0, 246, 0, 0, 246, 0, 246, 250, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 246, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 246, 0, 0, 0, 0, - 0, 0, 250, 248, 248, 248, 0, 246, 248, 248, - 248, 0, 248, 0, 0, 0, 250, 250, 0, 0, - 248, 250, 248, 248, 0, 0, 0, 0, 0, 0, - 0, 248, 248, 0, 248, 248, 248, 248, 248, 0, - 0, 0, 0, 0, 0, 0, 248, 0, 0, 257, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 257, - 0, 0, 0, 0, 0, 248, 248, 0, 0, 0, - 248, 248, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 248, 0, 0, 248, 0, 0, 248, 0, - 248, 0, 0, 257, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 248, 257, 257, 0, - 0, 0, 257, 273, 0, 0, 0, 0, 248, 0, - 249, 249, 249, 273, 0, 249, 249, 249, 0, 249, - 248, 0, 0, 0, 0, 0, 0, 249, 0, 249, - 249, 0, 0, 0, 0, 0, 0, 0, 249, 249, - 0, 249, 249, 249, 249, 249, 0, 268, 0, 0, - 0, 0, 0, 249, 0, 0, 0, 0, 0, 0, - 0, 0, 273, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 249, 249, 0, 0, 0, 249, 249, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 251, 249, - 0, 0, 249, 0, 0, 249, 0, 249, 251, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 250, 250, 250, 249, 0, 250, 250, 250, 0, 250, - 0, 0, 0, 0, 0, 249, 0, 250, 0, 250, - 250, 0, 251, 0, 0, 0, 0, 249, 250, 250, - 0, 250, 250, 250, 250, 250, 251, 251, 0, 0, - 0, 251, 0, 250, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 250, 250, 0, 0, 0, 250, 250, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 250, - 0, 0, 250, 0, 0, 250, 0, 250, 0, 252, - 0, 257, 257, 257, 0, 0, 257, 257, 257, 252, - 257, 0, 0, 250, 0, 0, 0, 0, 257, 0, - 257, 257, 0, 0, 0, 250, 0, 0, 0, 257, - 257, 0, 257, 257, 257, 257, 257, 250, 0, 0, - 0, 0, 0, 252, 257, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 252, 252, 0, - 0, 0, 252, 257, 257, 273, 273, 273, 257, 257, - 0, 273, 273, 0, 273, 0, 0, 0, 0, 0, - 257, 0, 273, 257, 0, 0, 257, 0, 257, 0, - 258, 0, 0, 273, 273, 0, 273, 273, 273, 273, - 258, 0, 0, 0, 257, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 257, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 257, 0, - 0, 0, 0, 0, 258, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 273, 258, 258, - 251, 251, 251, 258, 0, 251, 251, 251, 0, 251, - 0, 0, 0, 0, 0, 0, 0, 251, 273, 251, - 251, 0, 0, 0, 0, 0, 0, 0, 251, 251, - 228, 251, 251, 251, 251, 251, 0, 0, 0, 0, - 228, 0, 273, 251, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 251, 251, 0, 0, 0, 251, 251, 0, - 0, 0, 0, 0, 228, 0, 0, 0, 0, 251, - 0, 0, 251, 0, 0, 251, 0, 251, 228, 228, - 0, 0, 0, 228, 231, 0, 0, 0, 0, 0, - 0, 0, 0, 251, 231, 0, 0, 0, 0, 0, - 0, 252, 252, 252, 0, 251, 252, 252, 252, 0, - 252, 0, 0, 0, 0, 0, 0, 251, 252, 0, - 252, 252, 0, 0, 0, 0, 0, 0, 231, 252, - 252, 0, 252, 252, 252, 252, 252, 0, 0, 0, - 0, 0, 231, 231, 252, 0, 0, 231, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 252, 252, 0, 0, 0, 252, 252, - 0, 0, 0, 0, 259, 0, 0, 0, 0, 0, - 252, 0, 0, 252, 259, 0, 252, 0, 252, 0, - 0, 0, 258, 258, 258, 0, 0, 258, 258, 258, - 0, 258, 0, 0, 252, 0, 0, 0, 0, 258, - 0, 258, 258, 0, 0, 0, 252, 0, 259, 0, - 258, 258, 0, 258, 258, 258, 258, 258, 252, 0, - 0, 0, 259, 259, 0, 258, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 258, 0, 0, 0, 258, - 258, 0, 274, 0, 0, 0, 0, 0, 0, 0, - 0, 258, 274, 0, 258, 0, 0, 258, 0, 258, - 0, 0, 228, 228, 228, 0, 0, 228, 228, 228, - 0, 228, 0, 0, 0, 258, 0, 0, 0, 228, - 0, 228, 228, 0, 0, 0, 274, 258, 0, 0, - 228, 228, 0, 228, 228, 228, 228, 228, 0, 258, - 274, 274, 0, 0, 0, 228, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 231, 231, 231, 0, - 0, 231, 231, 231, 0, 231, 0, 0, 0, 0, - 0, 228, 260, 231, 228, 231, 231, 228, 0, 228, - 0, 0, 260, 0, 231, 231, 0, 231, 231, 231, - 231, 231, 0, 0, 0, 228, 0, 0, 0, 231, - 0, 0, 0, 0, 0, 0, 0, 228, 0, 0, - 0, 0, 0, 0, 0, 0, 260, 0, 0, 228, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 260, 260, 0, 0, 0, 231, 0, 0, 231, 0, - 0, 231, 0, 231, 0, 0, 259, 259, 259, 0, - 0, 259, 259, 259, 0, 259, 0, 0, 0, 231, - 221, 0, 0, 259, 0, 259, 259, 0, 0, 0, - 221, 231, 0, 0, 259, 259, 0, 259, 259, 259, - 259, 259, 0, 231, 0, 0, 0, 0, 0, 259, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 221, 0, 0, 0, 0, 0, + 249, 249, 0, 0, 0, 249, 0, 0, 246, 246, + 0, 0, 0, 0, 0, 0, 0, 246, 246, 0, + 246, 246, 246, 246, 246, 0, 0, 0, 0, 0, + 0, 0, 246, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 246, 246, 0, 0, 0, 246, 246, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 246, 0, + 0, 246, 0, 250, 246, 0, 246, 0, 0, 0, + 0, 0, 0, 250, 0, 0, 0, 0, 0, 0, + 0, 0, 246, 248, 248, 248, 0, 0, 248, 248, + 248, 0, 248, 0, 246, 0, 0, 0, 0, 0, + 0, 248, 248, 0, 250, 0, 246, 250, 246, 0, + 248, 248, 0, 248, 248, 248, 248, 248, 0, 0, + 0, 250, 250, 0, 0, 248, 250, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 248, 248, 0, 0, 0, 248, + 248, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 248, 0, 0, 248, 0, 0, 248, 0, 248, + 0, 0, 0, 0, 257, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 257, 248, 0, 0, 0, 0, + 0, 0, 0, 0, 249, 249, 249, 248, 0, 249, + 249, 249, 0, 249, 0, 0, 0, 0, 0, 248, + 0, 248, 249, 249, 0, 257, 0, 0, 257, 0, + 0, 249, 249, 0, 249, 249, 249, 249, 249, 0, + 0, 0, 257, 257, 0, 0, 249, 257, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 249, 249, 0, 0, 0, + 249, 249, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 249, 0, 0, 249, 0, 251, 249, 0, + 249, 0, 0, 0, 0, 0, 0, 251, 0, 0, + 0, 0, 0, 0, 0, 0, 249, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 249, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 251, 0, + 249, 251, 249, 0, 0, 250, 250, 250, 0, 0, + 250, 250, 250, 0, 250, 251, 251, 0, 0, 0, + 251, 0, 0, 250, 250, 0, 0, 0, 0, 0, + 0, 0, 250, 250, 0, 250, 250, 250, 250, 250, + 0, 0, 0, 0, 0, 0, 252, 250, 0, 0, + 0, 0, 0, 0, 0, 0, 252, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 250, 250, 0, 0, + 0, 250, 250, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 250, 0, 0, 250, 252, 0, 250, + 252, 250, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 252, 252, 0, 250, 0, 252, + 0, 0, 0, 0, 0, 0, 257, 257, 257, 250, + 0, 257, 257, 257, 0, 257, 0, 0, 0, 0, + 0, 250, 0, 250, 257, 257, 0, 0, 0, 0, + 0, 0, 0, 257, 257, 0, 257, 257, 257, 257, + 257, 0, 258, 0, 0, 0, 0, 0, 257, 0, + 0, 0, 258, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 257, 257, 0, + 0, 0, 257, 257, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 258, 257, 0, 258, 257, 0, 0, + 257, 0, 257, 0, 0, 0, 0, 0, 0, 0, + 258, 258, 0, 0, 0, 258, 0, 0, 257, 251, + 251, 251, 0, 0, 251, 251, 251, 0, 251, 0, + 257, 0, 0, 0, 0, 0, 0, 251, 251, 0, + 0, 0, 257, 0, 257, 0, 251, 251, 0, 251, + 251, 251, 251, 251, 0, 0, 0, 0, 0, 0, + 0, 251, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 251, 251, 0, 0, 0, 251, 251, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 251, 0, 0, + 251, 0, 230, 251, 1017, 251, 0, 0, 252, 252, + 252, 0, 230, 252, 252, 252, 0, 252, 0, 0, + 0, 251, 0, 0, 0, 0, 252, 252, 0, 0, + 0, 0, 0, 251, 0, 252, 252, 0, 252, 252, + 252, 252, 252, 230, 0, 251, 230, 251, 0, 0, + 252, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 230, 230, 0, 0, 0, 230, 0, 302, 0, 252, + 252, 0, 0, 0, 252, 252, 0, 302, 0, 0, + 0, 0, 0, 0, 1017, 1017, 252, 0, 1017, 252, + 0, 0, 252, 0, 252, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 233, 0, + 252, 298, 0, 0, 258, 258, 258, 0, 233, 258, + 258, 258, 252, 258, 1017, 0, 302, 0, 0, 0, + 0, 0, 258, 258, 252, 0, 252, 0, 0, 0, + 0, 258, 258, 0, 258, 258, 258, 258, 258, 233, + 0, 0, 233, 0, 0, 0, 258, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 233, 233, 0, 0, + 0, 233, 0, 0, 0, 0, 258, 1017, 0, 0, + 258, 258, 1017, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 258, 0, 0, 258, 0, 228, 258, 0, + 258, 0, 1017, 1017, 1017, 1017, 0, 228, 0, 1017, + 1017, 0, 1017, 0, 0, 0, 258, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 258, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 228, 0, + 258, 228, 258, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 228, 228, 0, 231, 0, + 228, 0, 0, 0, 230, 230, 230, 0, 231, 230, + 230, 230, 0, 230, 0, 0, 0, 0, 0, 0, + 0, 0, 230, 230, 0, 0, 0, 0, 0, 0, + 0, 230, 230, 0, 230, 230, 230, 230, 230, 231, + 0, 0, 231, 0, 0, 0, 230, 0, 0, 0, + 0, 0, 0, 0, 1017, 0, 231, 231, 0, 0, + 1017, 231, 0, 0, 0, 0, 0, 1017, 0, 302, + 302, 302, 0, 0, 302, 302, 302, 0, 302, 0, + 0, 0, 230, 0, 1017, 230, 0, 0, 230, 0, + 230, 0, 0, 0, 0, 0, 0, 0, 1017, 302, + 302, 302, 302, 302, 259, 0, 230, 0, 0, 0, + 233, 233, 233, 0, 259, 233, 233, 233, 230, 233, + 0, 0, 0, 0, 0, 0, 0, 0, 233, 233, + 230, 0, 230, 0, 0, 0, 0, 233, 233, 0, + 233, 233, 233, 233, 233, 259, 0, 302, 259, 0, + 302, 0, 233, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 259, 259, 0, 0, 0, 0, 0, 0, + 0, 302, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 233, 0, + 0, 233, 0, 274, 233, 302, 233, 302, 0, 228, + 228, 228, 0, 274, 228, 228, 228, 0, 228, 0, + 0, 0, 233, 0, 0, 0, 0, 228, 228, 0, + 0, 0, 0, 0, 233, 0, 228, 228, 0, 228, + 228, 228, 228, 228, 274, 0, 233, 274, 233, 0, + 0, 228, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 274, 274, 0, 0, 0, 0, 0, 0, 0, + 231, 231, 231, 0, 0, 231, 231, 231, 0, 231, + 0, 0, 0, 0, 0, 0, 0, 228, 231, 231, + 228, 0, 0, 228, 0, 228, 0, 231, 231, 0, + 231, 231, 231, 231, 231, 0, 260, 0, 0, 0, + 0, 228, 231, 0, 0, 0, 260, 0, 0, 0, + 0, 0, 0, 228, 0, 0, 0, 0, 0, 0, + 0, 0, 1018, 0, 0, 228, 0, 228, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 260, 231, 0, + 260, 231, 0, 0, 231, 0, 231, 0, 0, 0, + 0, 0, 0, 0, 260, 260, 0, 0, 0, 0, + 221, 0, 231, 0, 0, 0, 259, 259, 259, 0, + 221, 259, 259, 259, 231, 259, 0, 0, 0, 0, + 0, 0, 0, 0, 259, 259, 231, 0, 231, 0, + 0, 0, 0, 259, 259, 0, 259, 259, 259, 259, + 259, 221, 1018, 1018, 221, 0, 1018, 0, 259, 0, 0, 0, 0, 0, 0, 0, 0, 0, 221, 221, - 0, 0, 0, 0, 0, 259, 0, 0, 259, 0, - 0, 259, 0, 259, 274, 274, 274, 0, 0, 274, - 274, 274, 0, 274, 0, 0, 0, 0, 268, 259, - 0, 274, 0, 274, 274, 0, 0, 0, 268, 0, - 0, 259, 274, 274, 0, 274, 274, 274, 274, 274, - 0, 0, 0, 259, 0, 0, 0, 274, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 268, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 268, 0, 0, - 0, 0, 273, 274, 0, 0, 274, 0, 0, 274, - 0, 274, 273, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 260, 260, 260, 274, 0, 260, - 260, 260, 0, 260, 0, 0, 0, 0, 0, 274, - 0, 260, 0, 260, 260, 0, 273, 0, 0, 0, - 0, 274, 260, 260, 0, 260, 260, 260, 260, 260, - 273, 273, 0, 0, 0, 0, 296, 260, 0, 0, - 0, 0, 0, 0, 0, 0, 296, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 260, 0, 0, 260, 0, 0, 260, - 296, 260, 221, 221, 221, 0, 0, 221, 221, 221, - 0, 221, 0, 0, 0, 296, 298, 260, 0, 221, - 0, 221, 221, 0, 0, 0, 298, 0, 0, 260, - 221, 221, 0, 221, 221, 221, 221, 221, 0, 0, - 0, 260, 0, 0, 0, 221, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 57, 0, 0, 0, - 298, 0, 0, 0, 0, 0, 57, 0, 0, 0, - 0, 0, 0, 0, 0, 298, 0, 0, 0, 0, - 0, 221, 0, 0, 221, 0, 0, 221, 0, 221, - 268, 268, 268, 0, 0, 268, 268, 268, 0, 268, - 0, 0, 0, 0, 0, 221, 0, 268, 0, 268, - 268, 0, 0, 0, 0, 57, 0, 221, 268, 268, - 58, 268, 268, 268, 268, 268, 0, 0, 0, 221, - 58, 0, 0, 268, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 273, 273, 273, 0, 0, 273, - 273, 273, 0, 273, 0, 0, 0, 0, 0, 268, - 0, 273, 268, 273, 273, 268, 0, 268, 0, 58, - 0, 0, 273, 273, 303, 273, 273, 273, 273, 0, - 0, 0, 0, 268, 303, 0, 0, 273, 0, 0, - 0, 0, 0, 54, 0, 268, 0, 0, 0, 0, - 0, 0, 0, 54, 0, 0, 0, 268, 296, 296, - 296, 0, 0, 296, 296, 296, 0, 296, 299, 0, - 0, 0, 0, 273, 0, 296, 273, 296, 296, 273, - 0, 273, 0, 303, 0, 0, 296, 296, 0, 296, - 296, 296, 296, 296, 0, 0, 0, 273, 36, 0, - 0, 0, 54, 0, 0, 0, 0, 0, 36, 273, - 0, 0, 0, 0, 0, 0, 0, 0, 298, 298, - 298, 273, 0, 298, 298, 298, 0, 298, 0, 0, - 0, 0, 0, 0, 0, 298, 0, 298, 298, 0, - 296, 0, 0, 296, 0, 296, 298, 298, 0, 298, - 298, 298, 298, 298, 0, 0, 24, 36, 57, 57, - 57, 296, 0, 57, 57, 57, 24, 57, 0, 0, - 0, 0, 0, 0, 0, 57, 0, 57, 0, 0, - 0, 0, 0, 0, 0, 296, 57, 57, 0, 57, - 57, 57, 57, 57, 0, 0, 0, 0, 0, 0, - 298, 0, 0, 298, 0, 298, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 24, 0, 0, 0, 0, - 0, 298, 58, 58, 58, 0, 0, 58, 58, 58, - 293, 58, 0, 0, 0, 0, 0, 0, 0, 58, - 57, 58, 0, 0, 0, 298, 0, 0, 0, 0, - 58, 58, 0, 58, 58, 58, 58, 58, 0, 0, - 0, 57, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 57, 303, 303, 303, 0, - 0, 303, 303, 303, 0, 303, 0, 0, 0, 0, - 0, 0, 0, 303, 58, 54, 54, 54, 0, 0, - 54, 54, 54, 0, 54, 0, 0, 303, 303, 303, - 303, 303, 54, 0, 54, 58, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 54, 54, 54, 54, - 54, 0, 0, 0, 0, 0, 0, 0, 0, 58, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 36, 36, 36, 130, 0, 303, 36, 36, 303, 36, - 0, 0, 0, 0, 0, 0, 0, 36, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 54, 0, 303, - 0, 36, 36, 36, 36, 36, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 54, 0, - 0, 0, 130, 303, 0, 0, 0, 0, 24, 24, - 24, 0, 0, 0, 24, 24, 0, 24, 0, 0, - 0, 0, 54, 0, 0, 24, 0, 0, 0, 0, - 0, 0, 36, 0, 533, 0, 0, 0, 0, 24, - 24, 24, 24, 24, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 36, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 4, 5, 6, - 0, 8, 0, 0, 0, 9, 10, 36, 0, 0, - 11, 0, 12, 13, 14, 15, 16, 17, 18, 131, - 24, 0, 0, 19, 20, 21, 214, 215, 216, 217, - 0, 0, 251, 0, 0, 0, 0, 0, 0, 28, - 0, 24, 218, 219, 220, 0, 221, 35, 222, 223, - 224, 225, 271, 40, 41, 42, 43, 0, 0, 0, - 0, 0, 0, 0, 0, 24, 0, 0, 131, 0, - 0, 44, 45, 0, 0, 0, 0, 0, 0, 226, - 0, 0, 227, 0, 0, 48, 49, 0, 50, 0, - 272, 0, 273, 0, 52, 0, 0, 0, 0, 0, - 536, 0, 274, 0, 0, 0, 0, 54, 275, 56, - 57, 58, 59, 0, 0, 0, 60, 0, 61, 62, - 0, 63, 64, 65, 66, 0, 67, 68, 276, 130, - 130, 130, 130, 130, 130, 130, 130, 130, 130, 130, - 0, 0, 130, 130, 0, 130, 130, 130, 130, 130, - 130, 130, 0, 644, 0, 0, 130, 130, 130, 130, - 130, 130, 130, 0, 0, 130, 0, 0, 0, 0, - 0, 130, 130, 0, 130, 130, 130, 130, 0, 130, - 130, 130, 130, 130, 130, 0, 130, 130, 130, 130, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 130, - 0, 533, 0, 0, 130, 130, 0, 0, 0, 0, - 533, 533, 130, 0, 0, 130, 644, 0, 130, 130, - 0, 130, 0, 130, 0, 0, 0, 130, 0, 0, - 0, 0, 130, 0, 0, 130, 0, 644, 0, 0, - 130, 130, 130, 130, 130, 130, 0, 0, 130, 130, - 0, 130, 130, 0, 130, 130, 130, 130, 0, 130, - 130, 0, 0, 0, 0, 131, 131, 131, 131, 131, - 131, 131, 131, 131, 131, 131, 0, 0, 131, 131, - 651, 131, 131, 131, 131, 131, 131, 131, 0, 645, - 0, 0, 131, 131, 131, 131, 131, 131, 131, 0, - 0, 131, 0, 0, 0, 0, 0, 131, 131, 0, - 131, 131, 131, 131, 0, 131, 131, 131, 131, 131, - 131, 0, 131, 131, 131, 131, 0, 0, 0, 0, - 0, 0, 0, 131, 0, 0, 0, 536, 0, 0, - 131, 131, 0, 0, 0, 0, 536, 536, 131, 0, - 0, 131, 645, 0, 131, 131, 0, 131, 0, 131, - 0, 0, 0, 131, 0, 0, 0, 0, 131, 0, - 0, 131, 0, 645, 0, 0, 131, 131, 131, 131, - 131, 131, 131, 0, 0, 131, 0, 131, 131, 0, - 131, 131, 131, 131, 0, 131, 131, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 324, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 130, 130, 130, 130, 130, - 130, 130, 130, 130, 130, 130, 0, 0, 130, 130, - 0, 130, 130, 130, 130, 130, 130, 130, 0, 651, - 0, 0, 130, 130, 130, 130, 130, 130, 130, 0, - 0, 130, 0, 0, 0, 0, 0, 130, 130, 0, - 130, 130, 130, 130, 0, 130, 130, 130, 130, 130, - 130, 0, 130, 130, 130, 130, 0, 0, 0, 0, - 0, 0, 0, 131, 0, 0, 0, 651, 0, 0, - 130, 130, 0, 0, 0, 0, 651, 651, 130, 0, - 0, 130, 647, 0, 130, 130, 0, 130, 0, 130, - 0, 0, 0, 130, 0, 0, 0, 0, 130, 0, - 0, 130, 0, 651, 0, 0, 130, 130, 130, 130, - 130, 130, 131, 0, 0, 130, 0, 130, 130, 0, - 130, 130, 130, 130, 0, 130, 130, 0, 0, 131, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1018, 0, 259, 0, 0, 259, 0, 273, + 259, 0, 259, 0, 0, 274, 274, 274, 0, 273, + 274, 274, 274, 0, 274, 0, 0, 0, 259, 0, + 0, 0, 0, 274, 274, 0, 0, 0, 0, 0, + 259, 0, 274, 274, 0, 274, 274, 274, 274, 274, + 273, 0, 259, 273, 259, 1018, 0, 274, 0, 0, + 1018, 0, 0, 0, 0, 0, 0, 273, 273, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1018, 1018, 1018, 1018, 0, 0, 0, 1018, 1018, 0, + 1018, 0, 0, 274, 0, 0, 274, 0, 296, 274, + 0, 274, 0, 0, 0, 0, 0, 0, 296, 0, + 0, 0, 0, 0, 0, 0, 0, 274, 260, 260, + 260, 0, 0, 260, 260, 260, 0, 260, 0, 274, + 0, 0, 0, 0, 0, 0, 260, 260, 0, 296, + 0, 274, 296, 274, 0, 260, 260, 0, 260, 260, + 260, 260, 260, 0, 0, 0, 0, 296, 0, 0, + 260, 0, 298, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 298, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 221, 221, 221, 0, 0, 221, 221, 221, + 0, 221, 1018, 0, 0, 0, 260, 0, 1018, 260, + 221, 221, 260, 298, 260, 1018, 298, 0, 0, 221, + 221, 0, 221, 221, 221, 221, 221, 0, 0, 0, + 260, 298, 1018, 0, 221, 0, 0, 0, 0, 0, + 0, 0, 260, 0, 0, 0, 1018, 0, 0, 0, + 0, 0, 0, 0, 260, 0, 260, 0, 0, 0, + 0, 0, 293, 0, 0, 0, 0, 0, 0, 0, + 221, 0, 293, 221, 0, 0, 221, 0, 221, 0, + 0, 273, 273, 273, 0, 0, 273, 273, 273, 0, + 273, 0, 0, 0, 221, 0, 0, 0, 0, 273, + 273, 0, 0, 293, 0, 781, 221, 0, 273, 273, + 0, 273, 273, 273, 273, 781, 0, 0, 221, 0, + 221, 293, 0, 273, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 781, 0, 0, 0, + 0, 61, 0, 0, 0, 0, 0, 0, 0, 273, + 0, 61, 273, 0, 781, 273, 0, 273, 0, 0, + 296, 296, 296, 0, 0, 296, 296, 296, 0, 296, + 0, 0, 0, 273, 0, 0, 0, 0, 296, 296, + 0, 0, 61, 0, 0, 273, 0, 296, 296, 0, + 296, 296, 296, 296, 296, 0, 0, 273, 0, 273, + 61, 0, 0, 0, 0, 0, 0, 0, 65, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 65, 0, + 0, 0, 0, 0, 298, 298, 298, 0, 0, 298, + 298, 298, 0, 298, 0, 0, 0, 0, 0, 0, + 0, 296, 298, 298, 296, 0, 296, 0, 0, 65, + 0, 298, 298, 0, 298, 298, 298, 298, 298, 0, + 0, 0, 296, 0, 0, 0, 0, 65, 0, 0, + 0, 0, 63, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 63, 0, 0, 0, 296, 0, 296, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 298, 0, 0, 298, 0, + 298, 0, 53, 63, 293, 293, 293, 0, 0, 293, + 293, 293, 53, 293, 0, 0, 298, 0, 0, 0, + 0, 63, 293, 293, 0, 0, 0, 0, 0, 0, + 0, 293, 293, 0, 293, 293, 293, 293, 293, 0, + 298, 0, 298, 53, 0, 0, 0, 781, 781, 781, + 0, 0, 781, 781, 781, 0, 781, 0, 0, 0, + 0, 53, 0, 0, 0, 781, 781, 0, 0, 0, + 0, 0, 0, 0, 781, 781, 0, 781, 781, 781, + 781, 781, 0, 0, 0, 293, 0, 0, 293, 0, + 293, 0, 0, 61, 61, 61, 0, 0, 61, 61, + 61, 0, 61, 0, 0, 55, 293, 0, 0, 0, + 0, 61, 61, 0, 0, 55, 0, 0, 0, 0, + 61, 61, 0, 61, 61, 61, 61, 61, 781, 0, + 293, 781, 293, 781, 0, 0, 0, 0, 0, 0, + 57, 0, 0, 0, 0, 0, 55, 0, 0, 781, + 57, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 65, 65, 65, 0, 55, 65, 65, 65, 0, 65, + 0, 0, 0, 781, 61, 781, 0, 61, 65, 65, + 0, 57, 0, 0, 0, 0, 0, 65, 65, 0, + 65, 65, 65, 65, 65, 61, 0, 0, 0, 57, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 58, 61, + 0, 61, 0, 0, 63, 63, 63, 0, 58, 63, + 63, 63, 0, 63, 0, 0, 0, 0, 0, 1019, + 0, 65, 63, 63, 65, 0, 0, 0, 0, 0, + 0, 63, 63, 0, 63, 63, 63, 63, 63, 58, + 0, 0, 65, 0, 53, 53, 53, 0, 0, 53, + 53, 53, 0, 53, 54, 0, 0, 58, 0, 0, + 0, 0, 53, 0, 54, 0, 65, 0, 65, 0, + 0, 53, 53, 0, 53, 53, 53, 53, 53, 0, + 0, 0, 0, 0, 0, 63, 0, 0, 63, 0, + 0, 0, 0, 0, 0, 54, 0, 0, 0, 1019, + 1019, 0, 0, 1019, 0, 0, 63, 303, 0, 0, + 0, 0, 0, 54, 0, 0, 0, 303, 0, 0, + 0, 0, 0, 0, 0, 53, 0, 0, 0, 0, + 63, 0, 63, 0, 0, 0, 0, 0, 0, 1019, + 0, 0, 0, 0, 0, 0, 53, 55, 55, 55, + 0, 299, 55, 55, 55, 0, 55, 0, 0, 0, + 0, 0, 0, 0, 0, 55, 303, 0, 0, 0, + 53, 0, 53, 0, 55, 55, 0, 55, 55, 55, + 55, 55, 57, 57, 57, 0, 0, 57, 57, 57, + 0, 57, 1019, 0, 0, 0, 0, 1019, 0, 0, + 57, 0, 1016, 0, 0, 0, 0, 0, 0, 57, + 57, 0, 57, 57, 57, 57, 57, 1019, 1019, 1019, + 1019, 0, 0, 0, 1019, 1019, 0, 1019, 55, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 55, + 0, 0, 373, 0, 0, 0, 0, 0, 0, 0, + 58, 58, 58, 57, 0, 58, 58, 58, 0, 58, + 0, 0, 0, 55, 0, 55, 0, 0, 58, 0, + 0, 0, 0, 0, 57, 0, 0, 58, 58, 0, + 58, 58, 58, 58, 58, 0, 0, 0, 0, 0, + 0, 373, 0, 0, 0, 0, 0, 0, 57, 0, + 57, 0, 0, 0, 0, 0, 54, 54, 54, 0, + 0, 54, 54, 54, 0, 54, 0, 0, 0, 1019, + 0, 0, 0, 0, 54, 1019, 0, 0, 0, 0, + 0, 58, 1019, 0, 0, 0, 54, 54, 54, 54, + 54, 0, 0, 0, 0, 0, 0, 0, 0, 1019, + 0, 0, 58, 0, 0, 0, 0, 0, 0, 303, + 303, 303, 0, 1019, 303, 303, 303, 0, 303, 0, + 0, 0, 294, 0, 0, 0, 58, 0, 58, 0, + 0, 0, 0, 998, 999, 1000, 1001, 54, 0, 303, + 303, 303, 303, 303, 0, 0, 0, 0, 0, 1002, + 1003, 1004, 0, 1005, 0, 0, 0, 1006, 54, 0, + 40, 0, 0, 262, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1008, 1009, + 0, 0, 54, 0, 54, 0, 1010, 303, 0, 1011, + 303, 0, 0, 1012, 0, 1013, 0, 1180, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 303, 0, 0, 54, 55, 56, 57, 58, 59, + 0, 0, 0, 60, 0, 0, 0, 0, 63, 64, + 65, 66, 0, 67, 68, 303, 0, 303, 373, 373, + 373, 373, 373, 373, 373, 373, 373, 373, 373, 0, + 373, 373, 373, 373, 373, 373, 373, 373, 373, 373, + 373, 130, 0, 0, 373, 373, 373, 373, 373, 373, + 373, 0, 0, 373, 0, 0, 0, 0, 0, 373, + 373, 0, 373, 373, 373, 373, 0, 373, 373, 373, + 373, 373, 373, 0, 373, 373, 373, 373, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 130, 0, 373, 373, 0, 0, 0, 0, 0, 0, + 373, 0, 0, 373, 0, 0, 373, 373, 0, 373, + 0, 373, 0, 0, 0, 373, 0, 0, 0, 0, + 0, 0, 639, 373, 0, 0, 0, 0, 373, 373, + 373, 373, 373, 373, 0, 0, 0, 373, 0, 373, + 373, 0, 373, 373, 373, 373, 0, 373, 373, 4, + 5, 6, 373, 8, 0, 0, 0, 9, 10, 0, + 0, 0, 11, 0, 12, 13, 14, 15, 16, 17, + 18, 0, 0, 0, 19, 20, 21, 215, 216, 217, + 218, 0, 0, 252, 0, 131, 0, 0, 0, 0, + 28, 0, 0, 219, 220, 221, 0, 222, 35, 223, + 224, 225, 226, 272, 40, 41, 42, 43, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 44, 45, 0, 0, 0, 0, 0, 0, + 227, 0, 0, 228, 131, 0, 48, 49, 0, 50, + 0, 273, 0, 274, 0, 52, 0, 0, 0, 0, + 0, 0, 0, 275, 0, 0, 0, 0, 54, 276, + 56, 57, 58, 59, 0, 0, 642, 60, 0, 61, + 62, 0, 63, 64, 65, 66, 0, 67, 68, 277, + 0, 0, 0, 0, 0, 0, 0, 130, 130, 130, + 130, 130, 130, 130, 130, 130, 130, 130, 0, 0, + 130, 130, 0, 130, 130, 130, 130, 130, 130, 130, + 750, 0, 0, 130, 130, 130, 130, 130, 130, 130, + 0, 0, 130, 0, 0, 0, 0, 0, 130, 130, + 0, 130, 130, 130, 130, 0, 130, 130, 130, 130, + 130, 130, 130, 130, 130, 130, 130, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 639, 0, + 0, 130, 130, 0, 0, 0, 0, 639, 639, 130, + 0, 0, 130, 750, 0, 130, 130, 0, 130, 0, + 130, 0, 0, 0, 130, 0, 0, 0, 0, 130, + 0, 130, 130, 0, 750, 0, 0, 130, 130, 130, + 130, 130, 130, 0, 0, 0, 130, 0, 130, 130, + 0, 130, 130, 130, 130, 0, 130, 130, 0, 0, + 0, 0, 0, 757, 0, 0, 0, 0, 0, 0, + 0, 131, 131, 131, 131, 131, 131, 131, 131, 131, + 131, 131, 0, 0, 131, 131, 0, 131, 131, 131, + 131, 131, 131, 131, 751, 0, 0, 131, 131, 131, + 131, 131, 131, 131, 0, 0, 131, 0, 0, 0, + 0, 0, 131, 131, 0, 131, 131, 131, 131, 0, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, - 0, 0, 131, 131, 325, 131, 131, 131, 131, 131, - 131, 131, 0, 0, 0, 0, 131, 131, 131, 131, - 131, 131, 131, 0, 0, 131, 0, 0, 0, 0, - 0, 131, 131, 0, 131, 131, 131, 131, 0, 131, - 131, 131, 131, 131, 131, 0, 131, 131, 131, 131, - 0, 0, 0, 0, 0, 0, 0, 373, 0, 0, - 0, 324, 0, 0, 131, 131, 0, 0, 0, 0, - 324, 324, 131, 0, 0, 131, 648, 0, 131, 131, - 0, 131, 0, 131, 0, 0, 0, 131, 0, 0, - 0, 0, 131, 0, 0, 131, 0, 0, 0, 0, - 131, 131, 131, 131, 131, 131, 373, 0, 0, 131, - 0, 131, 131, 0, 131, 131, 131, 131, 0, 131, 131, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 642, 0, 0, 131, 131, 0, 0, 0, + 0, 642, 642, 131, 0, 0, 131, 751, 0, 131, + 131, 0, 131, 0, 131, 0, 0, 0, 131, 0, + 0, 0, 0, 131, 0, 131, 131, 0, 751, 0, + 0, 131, 131, 131, 131, 131, 131, 0, 0, 0, + 131, 0, 131, 131, 0, 131, 131, 131, 131, 0, + 131, 131, 0, 0, 0, 0, 0, 324, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 130, 130, + 130, 130, 130, 130, 130, 130, 130, 130, 130, 0, + 0, 130, 130, 0, 130, 130, 130, 130, 130, 130, + 130, 757, 0, 0, 130, 130, 130, 130, 130, 130, + 130, 0, 0, 130, 0, 0, 0, 0, 0, 130, + 130, 0, 130, 130, 130, 130, 0, 130, 130, 130, + 130, 130, 130, 131, 130, 130, 130, 130, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 757, + 0, 0, 130, 130, 0, 0, 0, 0, 757, 757, + 130, 0, 0, 130, 753, 0, 130, 130, 0, 130, + 0, 130, 0, 0, 0, 130, 0, 0, 0, 0, + 130, 0, 131, 130, 0, 757, 0, 0, 130, 130, + 130, 130, 130, 130, 0, 0, 0, 130, 0, 130, + 130, 0, 130, 130, 130, 130, 0, 130, 130, 0, + 0, 0, 0, 0, 325, 0, 0, 0, 0, 0, + 0, 0, 131, 131, 131, 131, 131, 131, 131, 131, + 131, 131, 131, 0, 0, 131, 131, 0, 131, 131, + 131, 131, 131, 131, 131, 0, 0, 0, 131, 131, + 131, 131, 131, 131, 131, 0, 0, 131, 0, 0, + 0, 0, 0, 131, 131, 780, 131, 131, 131, 131, + 0, 131, 131, 131, 131, 131, 131, 0, 131, 131, + 131, 131, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 324, 0, 0, 131, 131, 0, 0, + 0, 0, 324, 324, 131, 0, 0, 131, 754, 0, + 131, 131, 0, 131, 780, 131, 0, 0, 0, 131, + 0, 0, 0, 0, 131, 0, 0, 131, 0, 0, + 0, 0, 131, 131, 131, 131, 131, 131, 0, 0, + 0, 131, 0, 131, 131, 0, 131, 131, 131, 131, + 0, 131, 131, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 0, 0, 131, 131, 0, 131, 131, 131, 131, 131, - 131, 131, 0, 673, 0, 0, 131, 131, 131, 131, - 131, 131, 131, 0, 0, 131, 0, 0, 0, 0, - 0, 131, 131, 0, 131, 131, 131, 131, 0, 131, - 131, 131, 131, 131, 131, 0, 131, 131, 131, 131, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 325, 673, 0, 131, 131, 0, 0, 0, 0, - 325, 325, 131, 0, 0, 131, 0, 0, 131, 131, - 0, 131, 0, 131, 0, 0, 0, 131, 0, 0, - 0, 0, 131, 0, 0, 131, 0, 0, 0, 0, - 131, 131, 131, 131, 131, 131, 0, 0, 0, 131, - 0, 131, 131, 0, 131, 131, 131, 131, 0, 131, - 131, 0, 0, 373, 373, 373, 373, 373, 373, 373, - 373, 373, 373, 373, 0, 373, 373, 373, 373, 373, - 373, 373, 373, 373, 373, 373, 373, 316, 0, 0, - 373, 373, 373, 373, 373, 373, 373, 0, 0, 373, - 0, 0, 0, 0, 0, 373, 373, 0, 373, 373, - 373, 373, 0, 373, 373, 373, 373, 373, 373, 0, - 373, 373, 373, 373, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 316, 0, 373, 373, - 0, 0, 0, 0, 0, 0, 373, 0, 0, 373, - 0, 0, 373, 373, 0, 373, 0, 373, 0, 0, - 0, 373, 0, 0, 0, 0, 0, 0, 0, 373, - 0, 0, 0, 0, 373, 373, 373, 373, 373, 373, - 0, 0, 0, 373, 0, 373, 373, 0, 373, 373, - 373, 373, 0, 373, 373, 0, 0, 0, 0, 673, - 673, 673, 673, 673, 673, 673, 673, 673, 673, 673, - 0, 0, 673, 673, 0, 673, 673, 673, 673, 673, - 673, 673, 561, 0, 0, 0, 673, 673, 673, 673, - 673, 673, 673, 0, 0, 673, 0, 0, 0, 0, - 0, 673, 673, 0, 673, 673, 673, 673, 0, 673, - 673, 673, 673, 673, 673, 0, 673, 673, 673, 673, - 0, 0, 0, 0, 0, 0, 0, 0, 420, 0, - 0, 561, 0, 0, 673, 673, 0, 0, 0, 0, - 0, 0, 673, 0, 0, 673, 0, 0, 673, 673, - 0, 673, 0, 673, 0, 0, 0, 673, 0, 0, - 0, 0, 0, 0, 420, 673, 0, 0, 0, 0, - 673, 673, 673, 673, 673, 673, 0, 0, 0, 673, - 0, 673, 673, 0, 673, 673, 673, 673, 0, 673, - 673, 0, 0, 316, 316, 316, 316, 316, 316, 316, - 316, 316, 316, 316, 0, 0, 316, 316, 0, 316, - 316, 316, 316, 316, 316, 316, 673, 0, 0, 0, - 316, 316, 316, 316, 316, 316, 316, 0, 0, 316, - 0, 0, 0, 0, 0, 316, 316, 0, 316, 316, - 316, 316, 0, 316, 316, 316, 316, 316, 316, 0, - 316, 316, 316, 316, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 673, 0, 0, 316, 316, - 0, 0, 0, 0, 0, 0, 316, 0, 0, 316, - 0, 0, 316, 316, 0, 316, 0, 316, 0, 0, - 0, 316, 0, 0, 0, 0, 0, 0, 0, 316, - 0, 17, 0, 0, 316, 316, 316, 316, 316, 316, - 0, 0, 0, 316, 0, 316, 316, 0, 316, 316, - 316, 316, 0, 316, 316, 0, 0, 0, 561, 561, - 561, 561, 561, 561, 561, 561, 561, 561, 561, 0, - 0, 561, 561, 0, 561, 561, 561, 561, 561, 561, - 561, 318, 0, 0, 0, 561, 561, 561, 561, 561, - 561, 561, 0, 0, 561, 0, 0, 0, 0, 0, - 561, 561, 0, 561, 561, 561, 561, 0, 561, 561, - 561, 561, 561, 561, 0, 561, 561, 561, 561, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 561, 561, 0, 0, 0, 0, 0, - 0, 561, 0, 0, 561, 0, 0, 561, 561, 0, - 561, 0, 561, 0, 0, 0, 561, 0, 0, 0, - 0, 0, 0, 0, 561, 0, 0, 0, 0, 561, - 561, 561, 561, 561, 561, 0, 0, 0, 561, 0, - 561, 561, 0, 561, 561, 561, 561, 0, 561, 561, - 0, 0, 673, 673, 673, 673, 673, 673, 0, 0, - 0, 673, 673, 0, 0, 0, 673, 0, 673, 673, - 673, 673, 673, 673, 673, 236, 0, 0, 0, 673, - 673, 673, 673, 673, 673, 673, 0, 0, 673, 0, - 0, 0, 0, 0, 673, 673, 0, 673, 673, 673, - 673, 0, 673, 673, 673, 673, 673, 673, 0, 673, - 673, 673, 673, 0, 0, 0, 0, 0, 0, 0, - 0, 420, 0, 0, 235, 0, 0, 673, 673, 0, - 0, 0, 0, 0, 0, 673, 0, 0, 673, 0, - 0, 673, 673, 0, 673, 0, 673, 0, 0, 0, - 673, 0, 0, 0, 0, 0, 0, 420, 673, 0, - 0, 673, 0, 673, 673, 673, 673, 673, 673, 0, - 0, 0, 673, 0, 673, 673, 0, 673, 673, 673, - 673, 0, 673, 673, 0, 0, 0, 0, 320, 320, - 320, 320, 320, 0, 0, 0, 320, 320, 0, 0, - 0, 320, 0, 320, 320, 320, 320, 320, 320, 320, - 293, 0, 0, 0, 320, 320, 320, 320, 320, 320, - 320, 0, 0, 320, 0, 0, 0, 0, 0, 320, - 320, 0, 320, 320, 320, 320, 0, 320, 320, 320, - 320, 320, 320, 0, 320, 320, 320, 320, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 320, 320, 0, 0, 0, 0, 0, 0, - 320, 0, 0, 320, 0, 318, 320, 320, 0, 320, - 0, 320, 0, 0, 0, 320, 0, 0, 0, 0, - 0, 0, 0, 320, 0, 0, 0, 0, 320, 320, - 320, 320, 320, 320, 0, + 131, 131, 316, 0, 0, 131, 131, 131, 131, 131, + 131, 131, 0, 0, 131, 0, 0, 0, 0, 0, + 131, 131, 0, 131, 131, 131, 131, 0, 131, 131, + 131, 131, 131, 131, 0, 131, 131, 131, 131, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 325, 316, 0, 131, 131, 0, 0, 0, 0, 325, + 325, 131, 0, 0, 131, 0, 0, 131, 131, 0, + 131, 0, 131, 0, 0, 0, 131, 0, 0, 0, + 0, 131, 0, 0, 131, 0, 0, 0, 0, 131, + 131, 131, 131, 131, 131, 0, 0, 0, 131, 0, + 131, 131, 0, 131, 131, 131, 131, 0, 131, 131, + 0, 780, 780, 780, 780, 780, 780, 780, 780, 780, + 780, 780, 0, 0, 780, 780, 0, 780, 780, 780, + 780, 780, 780, 780, 667, 0, 0, 780, 780, 780, + 780, 780, 780, 780, 0, 0, 780, 0, 0, 0, + 0, 0, 780, 780, 0, 780, 780, 780, 780, 0, + 780, 780, 780, 780, 780, 780, 0, 780, 780, 780, + 780, 0, 0, 0, 0, 0, 0, 0, 0, 420, + 0, 0, 0, 667, 0, 780, 780, 0, 0, 0, + 0, 0, 0, 780, 0, 0, 780, 0, 0, 780, + 780, 0, 780, 0, 780, 0, 0, 0, 780, 0, + 0, 0, 0, 0, 0, 420, 780, 0, 0, 0, + 0, 780, 780, 780, 780, 780, 780, 0, 0, 0, + 780, 0, 780, 780, 0, 780, 780, 780, 780, 0, + 780, 780, 0, 0, 0, 0, 0, 0, 316, 316, + 316, 316, 316, 316, 316, 316, 316, 316, 316, 0, + 0, 316, 316, 0, 316, 316, 316, 316, 316, 316, + 316, 780, 0, 0, 316, 316, 316, 316, 316, 316, + 316, 0, 0, 316, 0, 0, 0, 0, 0, 316, + 316, 0, 316, 316, 316, 316, 0, 316, 316, 316, + 316, 316, 316, 0, 316, 316, 316, 316, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 780, 0, 316, 316, 0, 0, 0, 0, 0, 0, + 316, 0, 0, 316, 0, 0, 316, 316, 0, 316, + 0, 316, 0, 0, 0, 316, 0, 0, 0, 0, + 0, 0, 0, 316, 0, 17, 0, 0, 316, 316, + 316, 316, 316, 316, 0, 0, 0, 316, 0, 316, + 316, 0, 316, 316, 316, 316, 0, 316, 316, 0, + 667, 667, 667, 667, 667, 667, 667, 667, 667, 667, + 667, 0, 0, 667, 667, 0, 667, 667, 667, 667, + 667, 667, 667, 318, 0, 0, 667, 667, 667, 667, + 667, 667, 667, 0, 0, 667, 0, 0, 0, 0, + 0, 667, 667, 0, 667, 667, 667, 667, 0, 667, + 667, 667, 667, 667, 667, 0, 667, 667, 667, 667, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 667, 667, 0, 0, 0, 0, + 0, 0, 667, 0, 0, 667, 0, 0, 667, 667, + 0, 667, 0, 667, 0, 0, 0, 667, 0, 0, + 0, 0, 0, 0, 0, 667, 0, 0, 0, 0, + 667, 667, 667, 667, 667, 667, 0, 0, 0, 667, + 0, 667, 667, 0, 667, 667, 667, 667, 0, 667, + 667, 0, 0, 0, 0, 0, 0, 780, 780, 780, + 780, 780, 780, 0, 0, 0, 780, 780, 0, 0, + 0, 780, 0, 780, 780, 780, 780, 780, 780, 780, + 237, 0, 0, 780, 780, 780, 780, 780, 780, 780, + 0, 0, 780, 0, 0, 0, 0, 0, 780, 780, + 0, 780, 780, 780, 780, 0, 780, 780, 780, 780, + 780, 780, 0, 780, 780, 780, 780, 0, 0, 0, + 0, 0, 0, 0, 0, 420, 0, 0, 0, 236, + 0, 780, 780, 0, 0, 0, 0, 0, 0, 780, + 0, 0, 780, 0, 0, 780, 780, 0, 780, 0, + 780, 0, 0, 0, 780, 0, 0, 0, 0, 0, + 0, 420, 780, 0, 0, 780, 0, 780, 780, 780, + 780, 780, 780, 0, 0, 0, 780, 0, 780, 780, + 0, 780, 780, 780, 780, 0, 780, 780, 0, 0, + 320, 320, 320, 320, 320, 0, 0, 0, 320, 320, + 0, 0, 0, 320, 0, 320, 320, 320, 320, 320, + 320, 320, 294, 0, 0, 320, 320, 320, 320, 320, + 320, 320, 0, 0, 320, 0, 0, 0, 0, 0, + 320, 320, 0, 320, 320, 320, 320, 0, 320, 320, + 320, 320, 320, 320, 0, 320, 320, 320, 320, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 320, 320, 0, 0, 0, 0, 0, + 0, 320, 0, 0, 320, 0, 318, 320, 320, 0, + 320, 0, 320, 0, 0, 0, 320, 0, 0, 0, + 0, 0, 0, 0, 320, 0, 0, 0, 0, 320, + 320, 320, 320, 320, 320, 0, 0, 0, 320, 0, + 320, 320, 0, 320, 320, 320, 320, 0, 320, 320, + 0, 0, 0, 0, 0, 0, 0, 4, 5, 6, + 0, 8, 0, 0, 0, 9, 10, 0, 0, 0, + 11, 0, 12, 13, 14, 15, 16, 17, 18, 0, + 0, 0, 19, 20, 21, 215, 216, 217, 218, 0, + 0, 26, 0, 0, 0, 0, 0, 0, 28, 0, + 0, 219, 220, 221, 0, 222, 35, 223, 224, 225, + 226, 0, 40, 41, 42, 43, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 44, 45, 0, 0, 0, 0, 0, 0, 227, 0, + 0, 228, 0, 0, 48, 49, 0, 50, 1020, 0, + 0, 0, 0, 52, 0, 0, 0, 0, 0, 0, + 0, 53, 0, 0, 0, 0, 54, 55, 56, 57, + 58, 59, 0, 0, 0, 60, 0, 61, 62, 0, + 63, 64, 65, 66, 0, 67, 68, 0, 0, 4, + 5, 6, 0, 8, 0, 0, 0, 9, 10, 0, + 1021, 0, 11, 0, 12, 13, 14, 15, 16, 17, + 18, 1022, 0, 0, 19, 20, 21, 215, 216, 217, + 218, 0, 0, 26, 0, 0, 0, 0, 1020, 1020, + 28, 0, 1020, 219, 220, 221, 0, 222, 35, 223, + 224, 225, 226, 0, 40, 41, 42, 43, 1023, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 44, 45, 0, 0, 0, 0, 1020, 0, + 227, 0, 0, 228, 0, 0, 48, 49, 0, 50, + 1021, 1021, 0, 0, 1021, 52, 0, 0, 0, 0, + 0, 1022, 1022, 53, 0, 1022, 0, 0, 54, 55, + 56, 57, 58, 59, 0, 0, 0, 60, 0, 61, + 62, 0, 63, 64, 65, 66, 0, 67, 68, 0, + 1021, 1020, 0, 0, 0, 0, 1020, 0, 1023, 1023, + 0, 1022, 1023, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1020, 1020, 1020, 1020, + 0, 0, 0, 1020, 1020, 0, 1020, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1023, 0, + 0, 0, 0, 1021, 0, 0, 0, 0, 1021, 1024, + 0, 0, 0, 0, 1022, 0, 0, 0, 0, 1022, + 0, 0, 0, 0, 0, 1025, 0, 0, 1021, 1021, + 1021, 1021, 0, 341, 0, 1021, 1021, 0, 1021, 1022, + 1022, 1022, 1022, 0, 0, 0, 1022, 1022, 0, 1022, + 0, 1023, 0, 0, 0, 0, 1023, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1023, 1023, 1023, 1023, + 0, 0, 0, 1023, 1023, 0, 1023, 0, 1020, 1024, + 1024, 0, 0, 1024, 1020, 0, 0, 0, }; } private static final short[] yyTable4() { return new short[] { - 0, 0, 320, 0, 320, 320, 0, 320, 320, 320, - 320, 0, 320, 320, 0, 0, 0, 4, 5, 6, - 0, 8, 0, 0, 0, 9, 10, 0, 0, 0, - 11, 0, 12, 13, 14, 15, 16, 17, 18, 0, - 0, 0, 0, 19, 20, 21, 214, 215, 216, 217, - 0, 0, 26, 0, 0, 0, 0, 0, 0, 28, - 0, 0, 218, 219, 220, 0, 221, 35, 222, 223, - 224, 225, 340, 40, 41, 42, 43, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 44, 45, 0, 0, 0, 0, 0, 0, 226, - 0, 0, 227, 0, 0, 48, 49, 0, 50, 0, - 0, 0, 0, 0, 52, 0, 0, 0, 0, 0, + 0, 0, 0, 1020, 0, 0, 0, 1025, 1025, 0, + 0, 1025, 0, 0, 0, 0, 0, 0, 0, 0, + 1020, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1024, 0, 0, 1020, 0, 0, 0, 0, 0, + 0, 0, 1021, 0, 0, 0, 0, 1025, 1021, 0, + 0, 0, 0, 1022, 0, 1021, 0, 0, 0, 1022, + 0, 0, 0, 0, 0, 621, 1022, 0, 0, 0, + 0, 0, 1021, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1022, 1024, 0, 1021, 0, 0, 1024, + 1023, 0, 0, 0, 0, 0, 1023, 1022, 0, 0, + 1025, 0, 0, 1023, 0, 1025, 0, 0, 0, 1024, + 1024, 1024, 1024, 0, 0, 0, 1024, 1024, 0, 1024, + 1023, 0, 0, 0, 0, 1025, 1025, 1025, 1025, 0, + 0, 0, 1025, 1025, 1023, 1025, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 4, 5, + 6, 0, 8, 0, 0, 0, 9, 10, 0, 0, + 0, 11, 0, 12, 13, 14, 244, 245, 17, 18, + 0, 0, 0, 19, 246, 247, 328, 329, 330, 331, + 0, 0, 252, 0, 0, 0, 0, 0, 0, 253, + 0, 0, 332, 333, 334, 0, 335, 35, 336, 337, + 338, 339, 0, 40, 0, 0, 262, 0, 0, 0, + 463, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1024, 0, 0, 0, 0, 0, 1024, 0, 340, + 0, 0, 228, 0, 1024, 48, 49, 1025, 50, 0, + 0, 0, 0, 1025, 0, 0, 0, 0, 0, 0, + 1025, 1024, 0, 0, 0, 0, 0, 54, 55, 56, + 57, 58, 59, 0, 0, 1024, 60, 1025, 61, 62, + 0, 63, 64, 65, 66, 0, 67, 68, 4, 5, + 6, 1025, 8, 0, 0, 0, 9, 10, 0, 0, + 0, 11, 0, 12, 13, 14, 244, 245, 17, 18, + 0, 0, 0, 19, 246, 247, 328, 329, 330, 331, + 0, 0, 252, 0, 0, 0, 0, 0, 0, 253, + 0, 0, 332, 333, 334, 0, 335, 35, 336, 337, + 338, 339, 0, 40, 0, 0, 262, 0, 0, 0, + 463, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 340, + 0, 0, 228, 0, 0, 48, 49, 0, 50, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 54, 55, 56, + 57, 58, 59, 0, 0, 0, 60, 0, 61, 62, + 0, 63, 64, 65, 66, 0, 67, 68, 4, 5, + 6, 7, 8, 0, 0, 0, 9, 10, 0, 0, + 0, 11, 0, 12, 13, 14, 15, 16, 17, 18, + 0, 0, 0, 19, 20, 21, 22, 23, 24, 25, + 0, 0, 26, 0, 0, 0, 0, 0, 27, 28, + 29, 30, 31, 32, 33, 0, 34, 35, 36, 37, + 38, 39, 0, 40, 41, 42, 43, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 487, 0, 0, + 0, 44, 45, 0, 0, 0, 0, 0, 0, 46, + 0, 0, 47, 0, 0, 48, 49, 0, 50, 0, + 51, 0, 0, 0, 52, 0, 0, 0, 0, 0, 0, 0, 53, 0, 0, 0, 0, 54, 55, 56, 57, 58, 59, 0, 0, 0, 60, 0, 61, 62, - 0, 63, 64, 65, 66, 0, 67, 68, 0, 0, - 0, 0, 4, 5, 6, 0, 8, 0, 0, 0, - 9, 10, 0, 0, 0, 11, 0, 12, 13, 14, - 15, 16, 17, 18, 0, 0, 0, 0, 19, 20, - 21, 214, 215, 216, 217, 0, 0, 26, 0, 0, - 0, 0, 0, 0, 28, 0, 0, 218, 219, 220, - 0, 221, 35, 222, 223, 224, 225, 621, 40, 41, - 42, 43, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 44, 45, 0, 0, - 0, 0, 0, 0, 226, 0, 0, 227, 0, 0, - 48, 49, 0, 50, 0, 0, 0, 0, 0, 52, - 0, 0, 0, 0, 0, 0, 0, 53, 0, 0, - 0, 0, 54, 55, 56, 57, 58, 59, 0, 0, - 0, 60, 0, 61, 62, 0, 63, 64, 65, 66, - 0, 67, 68, 0, 0, 4, 5, 6, 0, 8, - 0, 0, 0, 9, 10, 0, 0, 0, 11, 0, - 12, 13, 14, 243, 244, 17, 18, 0, 0, 0, - 0, 19, 245, 246, 327, 328, 329, 330, 0, 0, - 251, 0, 0, 0, 0, 0, 0, 252, 0, 0, - 331, 332, 333, 0, 334, 35, 335, 336, 337, 338, - 0, 40, 0, 0, 261, 0, 0, 0, 0, 0, - 0, 0, 0, 463, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 339, 0, 0, - 227, 0, 0, 48, 49, 0, 50, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 54, 55, 56, 57, 58, - 59, 0, 0, 0, 60, 0, 61, 62, 0, 63, - 64, 65, 66, 0, 67, 68, 0, 0, 0, 0, - 4, 5, 6, 0, 8, 0, 0, 0, 9, 10, - 0, 0, 0, 11, 0, 12, 13, 14, 243, 244, - 17, 18, 0, 0, 0, 0, 19, 245, 246, 327, - 328, 329, 330, 0, 0, 251, 0, 0, 0, 0, - 0, 0, 252, 0, 0, 331, 332, 333, 0, 334, - 35, 335, 336, 337, 338, 0, 40, 0, 0, 261, - 0, 0, 0, 0, 463, 0, 0, 0, 0, 0, + 0, 63, 64, 65, 66, 0, 67, 68, 4, 5, + 6, 7, 309, 0, 0, 0, 9, 10, 0, 0, + 0, 11, 0, 12, 13, 14, 15, 16, 17, 18, + 0, 0, 0, 19, 20, 21, 22, 23, 24, 25, + 0, 0, 26, 0, 0, 0, 0, 0, 27, 28, + 486, 30, 31, 32, 33, 0, 34, 35, 36, 37, + 38, 39, 0, 40, 41, 42, 43, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 339, 0, 0, 227, 0, 0, 48, 49, - 0, 50, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 44, 45, 0, 0, 0, 0, 0, 0, 46, + 0, 0, 47, 0, 0, 48, 49, 0, 50, 0, + 51, 0, 0, 0, 52, 0, 0, 0, 0, 0, + 0, 0, 53, 0, 0, 0, 0, 54, 55, 56, + 57, 58, 59, 0, 0, 0, 60, 0, 61, 62, + 0, 63, 64, 65, 66, 0, 67, 68, 487, 487, + 487, 487, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1016, 487, 487, 487, 0, 487, 0, + 0, 0, 487, 0, 487, 487, 0, 0, 487, 487, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 54, 55, 56, 57, 58, 59, 0, 0, 0, 60, - 0, 61, 62, 0, 63, 64, 65, 66, 0, 67, - 68, 4, 5, 6, 7, 8, 0, 0, 0, 9, - 10, 0, 0, 0, 11, 0, 12, 13, 14, 15, - 16, 17, 18, 0, 0, 0, 0, 19, 20, 21, - 22, 23, 24, 25, 0, 0, 26, 0, 0, 0, - 0, 0, 27, 28, 29, 30, 31, 32, 33, 0, - 34, 35, 36, 37, 38, 39, 0, 40, 41, 42, - 43, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 44, 45, 0, 0, 0, - 0, 0, 0, 46, 0, 0, 47, 0, 0, 48, - 49, 0, 50, 0, 51, 0, 0, 0, 52, 0, - 0, 0, 0, 0, 0, 0, 53, 0, 0, 0, - 0, 54, 55, 56, 57, 58, 59, 0, 0, 0, - 60, 0, 61, 62, 0, 63, 64, 65, 66, 0, - 67, 68, 4, 5, 6, 7, 308, 0, 0, 0, - 9, 10, 0, 0, 0, 11, 0, 12, 13, 14, - 15, 16, 17, 18, 0, 0, 0, 0, 19, 20, - 21, 22, 23, 24, 25, 0, 0, 26, 0, 0, - 0, 0, 0, 27, 28, 0, 30, 31, 32, 33, - 0, 34, 35, 36, 37, 38, 39, 0, 40, 41, - 42, 43, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 44, 45, 0, 0, - 0, 0, 0, 0, 46, 0, 0, 47, 0, 0, - 48, 49, 0, 50, 0, 51, 0, 0, 0, 52, - 0, 0, 0, 0, 0, 0, 0, 53, 0, 0, - 0, 0, 54, 55, 56, 57, 58, 59, 0, 0, - 0, 60, 0, 61, 62, 0, 63, 64, 65, 66, - 0, 67, 68, 114, 115, 116, 117, 118, 119, 120, - 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, - 131, 132, 133, 134, 135, 136, 137, 0, 0, 138, - 139, 140, 141, 142, 143, 144, 145, 146, 147, 0, - 0, 0, 0, 148, 149, 150, 151, 152, 153, 154, - 155, 0, 156, 157, 158, 159, 160, 161, 0, 0, - 162, 163, 0, 164, 165, 166, 167, 168, 169, 170, - 0, 0, 171, 172, 0, 0, 0, 0, 0, 173, - 174, 175, 176, 0, 0, 0, 0, 0, 0, 177, - 0, 0, 0, 0, 0, 0, 178, 179, 0, 180, - 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, - 0, 0, 191, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 192, 114, 115, 116, 117, 118, - 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, - 129, 130, 131, 132, 133, 134, 135, 136, 137, 0, - 0, 138, 139, 140, 198, 199, 200, 201, 145, 146, - 147, 0, 0, 0, 0, 148, 149, 150, 151, 152, - 202, 203, 204, 0, 205, 157, 347, 348, 206, 349, - 0, 0, 162, 163, 0, 164, 165, 166, 167, 168, - 169, 170, 0, 0, 171, 172, 0, 0, 0, 0, - 0, 173, 174, 175, 176, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 178, 179, - 0, 180, 181, 182, 183, 184, 185, 186, 187, 188, - 189, 190, 0, 0, 191, 0, 0, 0, 0, 0, + 0, 0, 0, 487, 487, 0, 0, 0, 0, 0, + 0, 487, 0, 0, 487, 0, 0, 0, 487, 768, + 487, 0, 487, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 487, + 487, 487, 487, 487, 487, 0, 0, 0, 487, 0, + 0, 0, 0, 487, 487, 487, 487, 0, 487, 487, + 487, 486, 486, 486, 486, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1016, 486, 486, 486, + 0, 486, 0, 0, 0, 486, 0, 486, 486, 0, + 0, 486, 486, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 486, 486, 0, 0, + 0, 0, 0, 0, 486, 0, 0, 486, 0, 768, + 0, 486, 0, 486, 0, 486, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 192, 114, 115, 116, - 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, - 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, - 137, 0, 0, 138, 139, 140, 198, 199, 200, 201, - 145, 146, 147, 0, 0, 0, 0, 148, 149, 150, - 151, 152, 202, 203, 204, 0, 205, 157, 295, 0, - 206, 0, 0, 0, 162, 163, 0, 164, 165, 166, - 167, 168, 169, 170, 0, 0, 171, 172, 0, 0, - 0, 0, 0, 173, 174, 175, 176, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 178, 179, 0, 180, 181, 182, 183, 184, 185, 186, - 187, 188, 189, 190, 0, 0, 191, 54, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 192, 114, - 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, - 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, - 135, 136, 137, 0, 0, 138, 139, 140, 198, 199, - 200, 201, 145, 146, 147, 0, 0, 0, 0, 148, - 149, 150, 151, 152, 202, 203, 204, 0, 205, 157, - 0, 0, 206, 0, 0, 0, 162, 163, 0, 164, - 165, 166, 167, 168, 169, 170, 0, 0, 171, 172, - 0, 0, 0, 0, 0, 173, 174, 175, 176, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 178, 179, 0, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 190, 0, 0, 191, 54, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 192, 114, 115, 116, 117, 118, 119, 120, 121, 122, - 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, - 133, 134, 135, 136, 137, 0, 0, 138, 139, 140, - 198, 199, 200, 201, 145, 146, 147, 0, 0, 0, - 0, 148, 149, 150, 151, 152, 202, 203, 204, 0, - 205, 157, 0, 0, 206, 0, 0, 0, 162, 163, - 0, 164, 165, 166, 167, 168, 169, 170, 0, 0, - 171, 172, 0, 0, 0, 0, 0, 173, 174, 175, - 176, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 178, 179, 0, 180, 181, 182, - 183, 184, 185, 186, 187, 188, 189, 190, 0, 0, - 191, 0, 0, 0, 0, 0, 0, 3, 4, 5, - 6, 7, 8, 0, 0, 0, 9, 10, 0, 0, - 0, 11, 192, 12, 13, 14, 15, 16, 17, 18, - 0, 0, 0, 0, 19, 20, 21, 22, 23, 24, - 25, 0, 0, 26, 0, 0, 0, 0, 0, 27, - 28, 29, 30, 31, 32, 33, 0, 34, 35, 36, - 37, 38, 39, 0, 40, 41, 42, 43, 0, 0, + 0, 0, 486, 486, 486, 486, 486, 486, 0, 0, + 0, 486, 0, 0, 0, 0, 486, 486, 486, 486, + 0, 486, 486, 486, 998, 999, 1000, 1001, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1016, 0, + 1002, 1003, 1004, 0, 1005, 0, 0, 0, 1006, 0, + 1007, 40, 0, 0, 262, 722, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1008, + 1009, 0, 0, 0, 0, 0, 0, 1010, 0, 0, + 1011, 0, 0, 0, 1012, 0, 1013, 0, 1014, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 54, 1015, 56, 57, 58, + 59, 0, 0, 0, 60, 0, 0, 0, 0, 63, + 64, 65, 66, 0, 67, 68, 729, 998, 999, 1000, + 1001, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1002, 1003, 1004, 0, 1005, 0, 0, + 0, 1006, 0, 0, 40, 0, 0, 262, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1008, 1009, 0, 0, 0, 0, 0, 0, + 1010, 0, 0, 1011, 0, 0, 0, 1012, 0, 1013, + 0, 1014, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 54, 55, + 56, 57, 58, 59, 0, 0, 0, 60, 0, 0, + 0, 0, 63, 64, 65, 66, 0, 67, 68, 998, + 999, 1000, 1001, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1002, 1003, 1004, 0, 1005, + 0, 0, 0, 1006, 0, 0, 40, 0, 0, 262, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1008, 1009, 0, 0, 0, 0, + 0, 0, 1010, 0, 0, 1011, 0, 0, 0, 1012, + 0, 1013, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 44, 45, 0, 0, 0, 0, 0, 0, - 46, 0, 0, 47, 0, 0, 48, 49, 0, 50, - 0, 51, 0, 0, 0, 52, 0, 0, 0, 0, - 0, 0, 0, 53, 0, 0, 0, 0, 54, 55, - 56, 57, 58, 59, 0, 0, 0, 60, 0, 61, - 62, 0, 63, 64, 65, 66, 0, 67, 68, 307, - 4, 5, 6, 7, 308, 0, 0, 0, 9, 10, - 0, 0, 0, 11, 0, 12, 13, 14, 15, 16, - 17, 18, 0, 0, 0, 0, 19, 20, 21, 22, - 23, 24, 25, 0, 0, 26, 0, 0, 0, 0, - 0, 27, 28, 0, 30, 31, 32, 33, 0, 34, - 35, 36, 37, 38, 39, 0, 40, 41, 42, 43, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 44, 45, 0, 0, 0, 0, - 0, 0, 46, 0, 0, 309, 0, 0, 48, 49, - 0, 50, 0, 51, 0, 0, 0, 52, 0, 0, - 0, 0, 0, 0, 0, 53, 0, 0, 0, 0, 54, 55, 56, 57, 58, 59, 0, 0, 0, 60, - 0, 61, 62, 0, 63, 64, 65, 66, 0, 67, - 68, 307, 4, 5, 6, 7, 308, 0, 0, 0, - 9, 10, 0, 0, 0, 11, 0, 12, 13, 14, - 15, 16, 17, 18, 0, 0, 0, 0, 19, 20, - 21, 22, 23, 24, 25, 0, 0, 26, 0, 0, - 0, 0, 0, 27, 28, 0, 30, 31, 32, 33, - 0, 34, 35, 36, 37, 38, 39, 0, 40, 41, - 42, 43, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 44, 45, 0, 0, - 0, 0, 0, 0, 46, 0, 0, 47, 0, 0, - 48, 49, 0, 50, 0, 51, 0, 0, 0, 52, - 0, 0, 0, 0, 0, 0, 0, 53, 0, 0, - 0, 0, 54, 55, 56, 57, 58, 59, 0, 0, - 0, 60, 0, 61, 62, 0, 63, 64, 65, 66, - 0, 67, 68, 4, 5, 6, 0, 8, 0, 0, - 0, 9, 10, 0, 0, 0, 11, 0, 12, 13, - 14, 15, 16, 17, 18, 0, 0, 0, 0, 19, - 20, 21, 214, 215, 216, 217, 0, 0, 251, 0, - 0, 0, 0, 0, 0, 28, 0, 0, 218, 219, - 220, 0, 221, 35, 222, 223, 224, 225, 271, 40, - 41, 42, 43, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 44, 45, 0, - 0, 0, 0, 0, 0, 226, 0, 0, 227, 0, - 0, 48, 49, 0, 50, 0, 272, 0, 273, 0, - 52, 0, 0, 0, 0, 0, 0, 0, 274, 0, - 0, 0, 0, 54, 275, 56, 57, 58, 59, 0, - 0, 0, 60, 0, 61, 62, 0, 63, 64, 65, - 66, 0, 67, 68, 276, 4, 5, 6, 0, 8, - 0, 0, 0, 9, 10, 0, 0, 0, 11, 0, - 12, 13, 14, 15, 16, 17, 18, 0, 0, 0, - 0, 19, 20, 21, 214, 215, 216, 217, 0, 0, - 251, 0, 0, 0, 0, 0, 0, 28, 0, 0, - 218, 219, 220, 0, 221, 35, 222, 223, 224, 225, - 271, 40, 41, 42, 43, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 63, 64, 65, 66, 0, 67, + 68, 115, 116, 117, 118, 119, 120, 121, 122, 123, + 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, + 134, 135, 136, 137, 0, 0, 138, 139, 140, 141, + 142, 143, 144, 145, 146, 147, 0, 0, 0, 0, + 148, 149, 150, 151, 152, 153, 154, 155, 0, 156, + 157, 158, 159, 160, 161, 0, 0, 162, 163, 0, + 164, 165, 166, 167, 168, 169, 170, 0, 0, 171, + 172, 0, 0, 0, 0, 0, 173, 174, 175, 176, + 0, 0, 0, 0, 0, 0, 177, 0, 0, 0, + 0, 0, 0, 178, 179, 0, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 190, 0, 0, 191, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 192, 0, 0, 193, 115, 116, 117, 118, 119, + 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, + 130, 131, 132, 133, 134, 135, 136, 137, 0, 0, + 138, 139, 140, 199, 200, 201, 202, 145, 146, 147, + 0, 0, 0, 0, 148, 149, 150, 151, 152, 203, + 204, 205, 0, 206, 157, 348, 349, 207, 350, 0, + 0, 162, 163, 0, 164, 165, 166, 167, 168, 169, + 170, 0, 0, 171, 172, 0, 0, 0, 0, 0, + 173, 174, 175, 176, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 178, 179, 0, + 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, + 190, 0, 0, 191, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 192, 0, 0, 193, 115, + 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, + 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, + 136, 137, 0, 0, 138, 139, 140, 199, 200, 201, + 202, 145, 146, 147, 0, 0, 0, 0, 148, 149, + 150, 151, 152, 203, 204, 205, 0, 206, 157, 296, + 0, 207, 0, 0, 0, 162, 163, 0, 164, 165, + 166, 167, 168, 169, 170, 0, 0, 171, 172, 0, + 0, 0, 0, 0, 173, 174, 175, 176, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 178, 179, 0, 180, 181, 182, 183, 184, 185, + 186, 187, 188, 189, 190, 0, 0, 191, 54, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 192, + 0, 0, 193, 115, 116, 117, 118, 119, 120, 121, + 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, + 132, 133, 134, 135, 136, 137, 0, 0, 138, 139, + 140, 199, 200, 201, 202, 145, 146, 147, 0, 0, + 0, 0, 148, 149, 150, 151, 152, 203, 204, 205, + 0, 206, 157, 0, 0, 207, 0, 0, 0, 162, + 163, 0, 164, 165, 166, 167, 168, 169, 170, 0, + 0, 171, 172, 0, 0, 0, 0, 0, 173, 174, + 175, 176, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 178, 179, 0, 180, 181, + 182, 183, 184, 185, 186, 187, 188, 189, 190, 0, + 0, 191, 54, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 192, 0, 0, 193, 115, 116, 117, + 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, + 0, 0, 138, 139, 140, 199, 200, 201, 202, 145, + 146, 147, 0, 0, 0, 0, 148, 149, 150, 151, + 152, 203, 204, 205, 0, 206, 157, 0, 0, 207, + 0, 0, 0, 162, 163, 0, 164, 165, 166, 167, + 168, 169, 170, 0, 0, 171, 172, 0, 0, 0, + 0, 0, 173, 174, 175, 176, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 178, + 179, 0, 180, 181, 182, 183, 184, 185, 186, 187, + 188, 189, 190, 0, 0, 191, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 3, 4, 5, 6, 7, + 8, 0, 0, 0, 9, 10, 0, 192, 0, 11, + 193, 12, 13, 14, 15, 16, 17, 18, 0, 0, + 0, 19, 20, 21, 22, 23, 24, 25, 0, 0, + 26, 0, 0, 0, 0, 0, 27, 28, 29, 30, + 31, 32, 33, 0, 34, 35, 36, 37, 38, 39, + 0, 40, 41, 42, 43, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 44, - 488, 0, 0, 0, 0, 0, 0, 226, 0, 0, - 227, 0, 0, 48, 49, 0, 50, 0, 272, 0, - 273, 0, 52, 0, 0, 0, 0, 0, 0, 0, - 274, 0, 0, 0, 0, 54, 275, 56, 57, 58, + 45, 0, 0, 0, 0, 0, 0, 46, 0, 0, + 47, 0, 0, 48, 49, 0, 50, 0, 51, 0, + 0, 0, 52, 0, 0, 0, 0, 0, 0, 0, + 53, 0, 0, 0, 0, 54, 55, 56, 57, 58, 59, 0, 0, 0, 60, 0, 61, 62, 0, 63, - 64, 65, 66, 0, 67, 68, 276, 4, 5, 6, - 0, 8, 0, 0, 0, 9, 10, 0, 0, 0, - 11, 0, 12, 13, 14, 243, 244, 17, 18, 0, - 0, 0, 0, 19, 245, 246, 214, 215, 216, 217, - 0, 0, 251, 0, 0, 0, 0, 0, 0, 28, - 0, 0, 218, 219, 220, 0, 221, 35, 222, 223, - 224, 225, 271, 40, 41, 42, 43, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 44, 45, 0, 0, 0, 0, 0, 0, 226, - 0, 0, 227, 0, 0, 48, 49, 0, 50, 0, - 677, 0, 273, 0, 52, 0, 0, 0, 0, 0, - 0, 0, 274, 0, 0, 0, 0, 54, 275, 56, + 64, 65, 66, 0, 67, 68, 308, 4, 5, 6, + 7, 309, 0, 0, 0, 9, 10, 0, 0, 0, + 11, 0, 12, 13, 14, 15, 16, 17, 18, 0, + 0, 0, 19, 20, 21, 22, 23, 24, 25, 0, + 0, 26, 0, 0, 0, 0, 0, 27, 28, 0, + 30, 31, 32, 33, 0, 34, 35, 36, 37, 38, + 39, 0, 40, 41, 42, 43, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 44, 45, 0, 0, 0, 0, 0, 0, 46, 0, + 0, 310, 0, 0, 48, 49, 0, 50, 0, 51, + 0, 0, 0, 52, 0, 0, 0, 0, 0, 0, + 0, 53, 0, 0, 0, 0, 54, 55, 56, 57, + 58, 59, 0, 0, 0, 60, 0, 61, 62, 0, + 63, 64, 65, 66, 0, 67, 68, 308, 4, 5, + 6, 7, 309, 0, 0, 0, 9, 10, 0, 0, + 0, 11, 0, 12, 13, 14, 15, 16, 17, 18, + 0, 0, 0, 19, 20, 21, 22, 23, 24, 25, + 0, 0, 26, 0, 0, 0, 0, 0, 27, 28, + 0, 30, 31, 32, 33, 0, 34, 35, 36, 37, + 38, 39, 0, 40, 41, 42, 43, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 44, 45, 0, 0, 0, 0, 0, 0, 46, + 0, 0, 47, 0, 0, 48, 49, 0, 50, 0, + 51, 0, 0, 0, 52, 0, 0, 0, 0, 0, + 0, 0, 53, 0, 0, 0, 0, 54, 55, 56, + 57, 58, 59, 0, 0, 0, 60, 0, 61, 62, + 0, 63, 64, 65, 66, 0, 67, 68, 4, 5, + 6, 0, 8, 0, 0, 0, 9, 10, 0, 0, + 0, 11, 0, 12, 13, 14, 15, 16, 17, 18, + 0, 0, 0, 19, 20, 21, 215, 216, 217, 218, + 0, 0, 252, 0, 0, 0, 0, 0, 0, 28, + 0, 0, 219, 220, 221, 0, 222, 35, 223, 224, + 225, 226, 272, 40, 41, 42, 43, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 44, 45, 0, 0, 0, 0, 0, 0, 227, + 0, 0, 228, 0, 0, 48, 49, 0, 50, 0, + 273, 0, 274, 0, 52, 0, 0, 0, 0, 0, + 0, 0, 275, 0, 0, 0, 0, 54, 276, 56, 57, 58, 59, 0, 0, 0, 60, 0, 61, 62, - 0, 63, 64, 65, 66, 0, 67, 68, 276, 4, + 0, 63, 64, 65, 66, 0, 67, 68, 277, 4, 5, 6, 0, 8, 0, 0, 0, 9, 10, 0, - 0, 0, 11, 0, 12, 13, 14, 243, 244, 17, - 18, 0, 0, 0, 0, 19, 245, 246, 214, 215, - 216, 217, 0, 0, 251, 0, 0, 0, 0, 0, - 0, 28, 0, 0, 218, 219, 220, 0, 221, 35, - 222, 223, 224, 225, 271, 40, 41, 42, 43, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 44, 488, 0, 0, 0, 0, 0, - 0, 226, 0, 0, 227, 0, 0, 48, 49, 0, - 50, 0, 677, 0, 273, 0, 52, 0, 0, 0, - 0, 0, 0, 0, 274, 0, 0, 0, 0, 54, - 275, 56, 57, 58, 59, 0, 0, 0, 60, 0, + 0, 0, 11, 0, 12, 13, 14, 15, 16, 17, + 18, 0, 0, 0, 19, 20, 21, 215, 216, 217, + 218, 0, 0, 252, 0, 0, 0, 0, 0, 0, + 28, 0, 0, 219, 220, 221, 0, 222, 35, 223, + 224, 225, 226, 272, 40, 41, 42, 43, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 44, 488, 0, 0, 0, 0, 0, 0, + 227, 0, 0, 228, 0, 0, 48, 49, 0, 50, + 0, 273, 0, 274, 0, 52, 0, 0, 0, 0, + 0, 0, 0, 275, 0, 0, 0, 0, 54, 276, + 56, 57, 58, 59, 0, 0, 0, 60, 0, 61, + 62, 0, 63, 64, 65, 66, 0, 67, 68, 277, + 4, 5, 6, 0, 8, 0, 0, 0, 9, 10, + 0, 0, 0, 11, 0, 12, 13, 14, 244, 245, + 17, 18, 0, 0, 0, 19, 246, 247, 215, 216, + 217, 218, 0, 0, 252, 0, 0, 0, 0, 0, + 0, 28, 0, 0, 219, 220, 221, 0, 222, 35, + 223, 224, 225, 226, 272, 40, 41, 42, 43, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 44, 45, 0, 0, 0, 0, 0, + 0, 227, 0, 0, 228, 0, 0, 48, 49, 0, + 50, 0, 677, 0, 274, 0, 52, 0, 0, 0, + 0, 0, 0, 0, 275, 0, 0, 0, 0, 54, + 276, 56, 57, 58, 59, 0, 0, 0, 60, 0, 61, 62, 0, 63, 64, 65, 66, 0, 67, 68, - 276, 290, 290, 290, 0, 290, 0, 0, 0, 290, - 290, 0, 0, 0, 290, 0, 290, 290, 290, 290, - 290, 290, 290, 0, 0, 0, 0, 290, 290, 290, + 277, 4, 5, 6, 0, 8, 0, 0, 0, 9, + 10, 0, 0, 0, 11, 0, 12, 13, 14, 244, + 245, 17, 18, 0, 0, 0, 19, 246, 247, 215, + 216, 217, 218, 0, 0, 252, 0, 0, 0, 0, + 0, 0, 28, 0, 0, 219, 220, 221, 0, 222, + 35, 223, 224, 225, 226, 272, 40, 41, 42, 43, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 44, 488, 0, 0, 0, 0, + 0, 0, 227, 0, 0, 228, 0, 0, 48, 49, + 0, 50, 0, 677, 0, 274, 0, 52, 0, 0, + 0, 0, 0, 0, 0, 275, 0, 0, 0, 0, + 54, 276, 56, 57, 58, 59, 0, 0, 0, 60, + 0, 61, 62, 0, 63, 64, 65, 66, 0, 67, + 68, 277, 290, 290, 290, 0, 290, 0, 0, 0, + 290, 290, 0, 0, 0, 290, 0, 290, 290, 290, + 290, 290, 290, 290, 0, 0, 0, 290, 290, 290, 290, 290, 290, 290, 0, 0, 290, 0, 0, 0, 0, 0, 0, 290, 0, 0, 290, 290, 290, 0, 290, 290, 290, 290, 290, 290, 290, 290, 290, 290, @@ -2206,2912 +2381,3105 @@ private static final short[] yyTable4() { 290, 0, 290, 290, 0, 290, 290, 290, 290, 0, 290, 290, 290, 4, 5, 6, 0, 8, 0, 0, 0, 9, 10, 0, 0, 0, 11, 0, 12, 13, - 14, 243, 244, 17, 18, 0, 0, 0, 0, 19, - 245, 246, 214, 215, 216, 217, 0, 0, 251, 0, - 0, 0, 0, 0, 0, 28, 0, 0, 218, 219, - 220, 0, 221, 35, 222, 223, 224, 225, 271, 40, - 41, 42, 43, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 44, 45, 0, - 0, 0, 0, 0, 0, 226, 0, 0, 227, 0, - 0, 48, 49, 0, 50, 0, 272, 0, 0, 0, - 52, 0, 0, 0, 0, 0, 0, 0, 274, 0, - 0, 0, 0, 54, 275, 56, 57, 58, 59, 0, - 0, 0, 60, 0, 61, 62, 0, 63, 64, 65, - 66, 0, 67, 68, 276, 4, 5, 6, 0, 8, - 0, 0, 0, 9, 10, 0, 0, 0, 11, 0, - 12, 13, 14, 243, 244, 17, 18, 0, 0, 0, - 0, 19, 245, 246, 214, 215, 216, 217, 0, 0, - 251, 0, 0, 0, 0, 0, 0, 28, 0, 0, - 218, 219, 220, 0, 221, 35, 222, 223, 224, 225, - 271, 40, 41, 42, 43, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 44, - 45, 0, 0, 0, 0, 0, 0, 226, 0, 0, - 227, 0, 0, 48, 49, 0, 50, 0, 0, 0, - 273, 0, 52, 0, 0, 0, 0, 0, 0, 0, - 274, 0, 0, 0, 0, 54, 275, 56, 57, 58, - 59, 0, 0, 0, 60, 0, 61, 62, 0, 63, - 64, 65, 66, 0, 67, 68, 276, 4, 5, 6, - 0, 8, 0, 0, 0, 9, 10, 0, 0, 0, - 11, 0, 12, 13, 14, 243, 244, 17, 18, 0, - 0, 0, 0, 19, 245, 246, 214, 215, 216, 217, - 0, 0, 251, 0, 0, 0, 0, 0, 0, 28, - 0, 0, 218, 219, 220, 0, 221, 35, 222, 223, - 224, 225, 271, 40, 41, 42, 43, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 44, 45, 0, 0, 0, 0, 0, 0, 226, - 0, 0, 227, 0, 0, 48, 49, 0, 50, 0, - 677, 0, 0, 0, 52, 0, 0, 0, 0, 0, - 0, 0, 274, 0, 0, 0, 0, 54, 275, 56, - 57, 58, 59, 0, 0, 0, 60, 0, 61, 62, - 0, 63, 64, 65, 66, 0, 67, 68, 276, 4, - 5, 6, 0, 8, 0, 0, 0, 9, 10, 0, - 0, 0, 11, 0, 12, 13, 14, 243, 244, 17, - 18, 0, 0, 0, 0, 19, 245, 246, 214, 215, - 216, 217, 0, 0, 251, 0, 0, 0, 0, 0, - 0, 28, 0, 0, 218, 219, 220, 0, 221, 35, - 222, 223, 224, 225, 271, 40, 41, 42, 43, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 44, 45, 0, 0, 0, 0, 0, - 0, 226, 0, 0, 227, 0, 0, 48, 49, 0, - 50, 0, 0, 0, 0, 0, 52, 0, 0, 0, - 0, 0, 0, 0, 274, 0, 0, 0, 0, 54, - 275, 56, 57, 58, 59, 0, 0, 0, 60, 0, - 61, 62, 0, 63, 64, 65, 66, 0, 67, 68, - 276, 4, 5, 6, 7, 8, 0, 0, 0, 9, - 10, 0, 0, 0, 11, 0, 12, 13, 14, 15, - 16, 17, 18, 0, 0, 0, 0, 19, 20, 21, - 22, 23, 24, 25, 0, 0, 26, 0, 0, 0, - 0, 0, 27, 28, 29, 30, 31, 32, 33, 0, - 34, 35, 36, 37, 38, 39, 0, 40, 41, 42, - 43, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 44, 45, 0, 0, 0, - 0, 0, 0, 46, 0, 0, 47, 0, 0, 48, - 49, 0, 50, 0, 51, 0, 0, 0, 52, 0, - 0, 0, 0, 0, 0, 0, 53, 0, 0, 0, - 0, 54, 55, 56, 57, 58, 59, 0, 0, 0, - 60, 0, 61, 62, 0, 63, 64, 65, 66, 0, - 67, 68, 4, 5, 6, 7, 8, 0, 0, 0, - 9, 10, 0, 0, 0, 11, 0, 12, 13, 14, - 15, 16, 17, 18, 0, 0, 0, 0, 19, 20, - 21, 22, 23, 24, 25, 0, 0, 26, 0, 0, - 0, 0, 0, 27, 28, 0, 30, 31, 32, 33, - 0, 34, 35, 36, 37, 38, 39, 0, 40, 41, + 14, 244, 245, 17, 18, 0, 0, 0, 19, 246, + 247, 215, 216, 217, 218, 0, 0, 252, 0, 0, + 0, 0, 0, 0, 28, 0, 0, 219, 220, 221, + 0, 222, 35, 223, 224, 225, 226, 272, 40, 41, 42, 43, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 44, 45, 0, 0, - 0, 0, 0, 0, 46, 0, 0, 47, 0, 0, - 48, 49, 0, 50, 0, 51, 0, 0, 0, 52, - 0, 0, 0, 0, 0, 0, 0, 53, 0, 0, - 0, 0, 54, 55, 56, 57, 58, 59, 0, 0, + 0, 0, 0, 0, 227, 0, 0, 228, 0, 0, + 48, 49, 0, 50, 0, 273, 0, 0, 0, 52, + 0, 0, 0, 0, 0, 0, 0, 275, 0, 0, + 0, 0, 54, 276, 56, 57, 58, 59, 0, 0, 0, 60, 0, 61, 62, 0, 63, 64, 65, 66, - 0, 67, 68, 4, 5, 6, 0, 8, 0, 0, - 0, 9, 10, 0, 0, 0, 11, 0, 12, 13, - 14, 243, 244, 17, 18, 0, 0, 0, 0, 19, - 245, 246, 214, 215, 216, 217, 0, 0, 251, 0, - 0, 0, 0, 0, 0, 28, 0, 0, 218, 219, - 220, 0, 221, 35, 222, 223, 224, 225, 0, 40, + 0, 67, 68, 277, 4, 5, 6, 0, 8, 0, + 0, 0, 9, 10, 0, 0, 0, 11, 0, 12, + 13, 14, 244, 245, 17, 18, 0, 0, 0, 19, + 246, 247, 215, 216, 217, 218, 0, 0, 252, 0, + 0, 0, 0, 0, 0, 28, 0, 0, 219, 220, + 221, 0, 222, 35, 223, 224, 225, 226, 272, 40, 41, 42, 43, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 44, 45, 0, - 0, 0, 0, 0, 0, 226, 0, 0, 227, 502, - 0, 48, 49, 0, 50, 0, 0, 0, 0, 0, - 52, 0, 0, 0, 0, 0, 0, 0, 274, 0, - 0, 0, 0, 54, 55, 56, 57, 58, 59, 0, + 0, 0, 0, 0, 0, 227, 0, 0, 228, 0, + 0, 48, 49, 0, 50, 0, 0, 0, 274, 0, + 52, 0, 0, 0, 0, 0, 0, 0, 275, 0, + 0, 0, 0, 54, 276, 56, 57, 58, 59, 0, 0, 0, 60, 0, 61, 62, 0, 63, 64, 65, - 66, 0, 67, 68, 4, 5, 6, 0, 8, 0, - 0, 0, 9, 10, 0, 0, 0, 11, 0, 12, - 13, 14, 15, 16, 17, 18, 0, 0, 0, 0, - 19, 20, 21, 214, 215, 216, 217, 0, 0, 251, - 0, 0, 0, 0, 0, 0, 28, 0, 0, 218, - 219, 220, 0, 221, 35, 222, 223, 224, 225, 0, + 66, 0, 67, 68, 277, 4, 5, 6, 0, 8, + 0, 0, 0, 9, 10, 0, 0, 0, 11, 0, + 12, 13, 14, 244, 245, 17, 18, 0, 0, 0, + 19, 246, 247, 215, 216, 217, 218, 0, 0, 252, + 0, 0, 0, 0, 0, 0, 28, 0, 0, 219, + 220, 221, 0, 222, 35, 223, 224, 225, 226, 272, 40, 41, 42, 43, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 44, 45, - 0, 0, 0, 0, 0, 0, 226, 0, 0, 227, - 0, 0, 48, 49, 0, 50, 0, 613, 0, 0, - 0, 52, 0, 0, 0, 0, 0, 0, 0, 274, - 0, 0, 0, 0, 54, 55, 56, 57, 58, 59, + 0, 0, 0, 0, 0, 0, 227, 0, 0, 228, + 0, 0, 48, 49, 0, 50, 0, 677, 0, 0, + 0, 52, 0, 0, 0, 0, 0, 0, 0, 275, + 0, 0, 0, 0, 54, 276, 56, 57, 58, 59, 0, 0, 0, 60, 0, 61, 62, 0, 63, 64, - 65, 66, 0, 67, 68, 4, 5, 6, 0, 8, - 0, 0, 0, 9, 10, 0, 0, 0, 11, 0, - 12, 13, 14, 243, 244, 17, 18, 0, 0, 0, - 0, 19, 245, 246, 214, 215, 216, 217, 0, 0, - 251, 0, 0, 0, 0, 0, 0, 28, 0, 0, - 218, 219, 220, 0, 221, 35, 222, 223, 224, 225, - 0, 40, 41, 42, 43, 0, 0, 0, 0, 0, + 65, 66, 0, 67, 68, 277, 4, 5, 6, 0, + 8, 0, 0, 0, 9, 10, 0, 0, 0, 11, + 0, 12, 13, 14, 244, 245, 17, 18, 0, 0, + 0, 19, 246, 247, 215, 216, 217, 218, 0, 0, + 252, 0, 0, 0, 0, 0, 0, 28, 0, 0, + 219, 220, 221, 0, 222, 35, 223, 224, 225, 226, + 272, 40, 41, 42, 43, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 44, - 45, 0, 0, 0, 0, 0, 0, 226, 0, 0, - 227, 0, 0, 48, 49, 0, 50, 0, 272, 0, + 45, 0, 0, 0, 0, 0, 0, 227, 0, 0, + 228, 0, 0, 48, 49, 0, 50, 0, 0, 0, 0, 0, 52, 0, 0, 0, 0, 0, 0, 0, - 274, 0, 0, 0, 0, 54, 55, 56, 57, 58, + 275, 0, 0, 0, 0, 54, 276, 56, 57, 58, 59, 0, 0, 0, 60, 0, 61, 62, 0, 63, - 64, 65, 66, 0, 67, 68, 4, 5, 6, 0, - 8, 0, 0, 0, 9, 10, 0, 0, 0, 11, - 0, 12, 13, 14, 243, 244, 17, 18, 0, 0, - 0, 0, 19, 245, 246, 214, 215, 216, 217, 0, - 0, 251, 0, 0, 0, 0, 0, 0, 28, 0, - 0, 218, 219, 220, 0, 221, 35, 222, 223, 224, - 225, 0, 40, 41, 42, 43, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 44, 45, 0, 0, 0, 0, 0, 0, 226, 0, - 0, 227, 0, 0, 48, 49, 0, 50, 0, 613, + 64, 65, 66, 0, 67, 68, 277, 4, 5, 6, + 7, 8, 0, 0, 0, 9, 10, 0, 0, 0, + 11, 0, 12, 13, 14, 15, 16, 17, 18, 0, + 0, 0, 19, 20, 21, 22, 23, 24, 25, 0, + 0, 26, 0, 0, 0, 0, 0, 27, 28, 29, + 30, 31, 32, 33, 0, 34, 35, 36, 37, 38, + 39, 0, 40, 41, 42, 43, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 44, 45, 0, 0, 0, 0, 0, 0, 46, 0, + 0, 47, 0, 0, 48, 49, 0, 50, 0, 51, + 0, 0, 0, 52, 0, 0, 0, 0, 0, 0, + 0, 53, 0, 0, 0, 0, 54, 55, 56, 57, + 58, 59, 0, 0, 0, 60, 0, 61, 62, 0, + 63, 64, 65, 66, 0, 67, 68, 4, 5, 6, + 7, 8, 0, 0, 0, 9, 10, 0, 0, 0, + 11, 0, 12, 13, 14, 15, 16, 17, 18, 0, + 0, 0, 19, 20, 21, 22, 23, 24, 25, 0, + 0, 26, 0, 0, 0, 0, 0, 27, 28, 0, + 30, 31, 32, 33, 0, 34, 35, 36, 37, 38, + 39, 0, 40, 41, 42, 43, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 44, 45, 0, 0, 0, 0, 0, 0, 46, 0, + 0, 47, 0, 0, 48, 49, 0, 50, 0, 51, 0, 0, 0, 52, 0, 0, 0, 0, 0, 0, - 0, 274, 0, 0, 0, 0, 54, 55, 56, 57, + 0, 53, 0, 0, 0, 0, 54, 55, 56, 57, 58, 59, 0, 0, 0, 60, 0, 61, 62, 0, 63, 64, 65, 66, 0, 67, 68, 4, 5, 6, 0, 8, 0, 0, 0, 9, 10, 0, 0, 0, - 11, 0, 12, 13, 14, 243, 244, 17, 18, 0, - 0, 0, 0, 19, 245, 246, 214, 215, 216, 217, - 0, 0, 251, 0, 0, 0, 0, 0, 0, 28, - 0, 0, 218, 219, 220, 0, 221, 35, 222, 223, - 224, 225, 0, 40, 41, 42, 43, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 44, 45, 0, 0, 0, 0, 0, 0, 226, - 0, 0, 227, 0, 0, 48, 49, 0, 50, 0, - 903, 0, 0, 0, 52, 0, 0, 0, 0, 0, - 0, 0, 274, 0, 0, 0, 0, 54, 55, 56, - 57, 58, 59, 0, 0, 0, 60, 0, 61, 62, - 0, 63, 64, 65, 66, 0, 67, 68, 4, 5, - 6, 0, 8, 0, 0, 0, 9, 10, 0, 0, - 0, 11, 0, 12, 13, 14, 243, 244, 17, 18, - 0, 0, 0, 0, 19, 245, 246, 214, 215, 216, - 217, 0, 0, 251, 0, 0, 0, 0, 0, 0, - 28, 0, 0, 218, 219, 220, 0, 221, 35, 222, - 223, 224, 225, 0, 40, 41, 42, 43, 0, 0, + 11, 0, 12, 13, 14, 244, 245, 17, 18, 0, + 0, 0, 19, 246, 247, 215, 216, 217, 218, 0, + 0, 252, 0, 0, 0, 0, 0, 0, 28, 0, + 0, 219, 220, 221, 0, 222, 35, 223, 224, 225, + 226, 0, 40, 41, 42, 43, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 44, 45, 0, 0, 0, 0, 0, 0, - 226, 0, 0, 227, 0, 0, 48, 49, 0, 50, - 0, 677, 0, 0, 0, 52, 0, 0, 0, 0, - 0, 0, 0, 274, 0, 0, 0, 0, 54, 55, - 56, 57, 58, 59, 0, 0, 0, 60, 0, 61, - 62, 0, 63, 64, 65, 66, 0, 67, 68, 662, - 662, 662, 0, 662, 0, 0, 0, 662, 662, 0, - 0, 0, 662, 0, 662, 662, 662, 662, 662, 662, - 662, 0, 0, 0, 0, 662, 662, 662, 662, 662, - 662, 662, 0, 0, 662, 0, 0, 0, 0, 0, - 0, 662, 0, 0, 662, 662, 662, 0, 662, 662, - 662, 662, 662, 662, 0, 662, 662, 662, 662, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 662, 662, 0, 0, 0, 0, 0, - 0, 662, 0, 0, 662, 662, 0, 662, 662, 0, - 662, 0, 0, 0, 0, 0, 662, 0, 0, 0, - 0, 0, 0, 0, 662, 0, 0, 0, 0, 662, - 662, 662, 662, 662, 662, 0, 0, 0, 662, 0, - 662, 662, 0, 662, 662, 662, 662, 0, 662, 662, - 4, 5, 6, 0, 8, 0, 0, 0, 9, 10, - 0, 0, 0, 11, 0, 12, 13, 14, 15, 16, - 17, 18, 0, 0, 0, 0, 19, 20, 21, 214, - 215, 216, 217, 0, 0, 26, 0, 0, 0, 0, - 0, 0, 28, 0, 0, 218, 219, 220, 0, 221, - 35, 222, 223, 224, 225, 0, 40, 41, 42, 43, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 44, 45, 0, 0, 0, 0, - 0, 0, 226, 0, 0, 227, 0, 0, 48, 49, - 0, 50, 0, 0, 0, 0, 0, 52, 0, 0, - 0, 0, 0, 0, 0, 53, 0, 0, 0, 0, - 54, 55, 56, 57, 58, 59, 0, 0, 0, 60, - 0, 61, 62, 0, 63, 64, 65, 66, 0, 67, - 68, 4, 5, 6, 0, 8, 0, 0, 0, 9, - 10, 0, 0, 0, 11, 0, 12, 13, 14, 243, - 244, 17, 18, 0, 0, 0, 0, 19, 245, 246, - 214, 215, 216, 217, 0, 0, 251, 0, 0, 0, - 0, 0, 0, 28, 0, 0, 218, 219, 220, 0, - 221, 35, 222, 223, 224, 225, 0, 40, 41, 42, - 43, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 44, 45, 0, 0, 0, - 0, 0, 0, 226, 0, 0, 227, 0, 0, 48, - 49, 0, 50, 0, 0, 0, 0, 0, 52, 0, - 0, 0, 0, 0, 0, 0, 274, 0, 0, 0, - 0, 54, 55, 56, 57, 58, 59, 0, 0, 0, - 60, 0, 61, 62, 0, 63, 64, 65, 66, 0, - 67, 68, 4, 5, 6, 0, 8, 0, 0, 0, - 9, 10, 0, 0, 0, 11, 0, 12, 13, 14, - 15, 16, 17, 18, 0, 0, 0, 0, 19, 20, - 21, 214, 215, 216, 217, 0, 0, 251, 0, 0, - 0, 0, 0, 0, 28, 0, 0, 218, 219, 220, - 0, 221, 35, 222, 223, 224, 225, 0, 40, 41, - 42, 43, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 44, 45, 0, 0, - 0, 0, 0, 0, 226, 0, 0, 227, 0, 0, - 48, 49, 0, 50, 0, 0, 0, 0, 0, 52, - 0, 0, 0, 0, 0, 0, 0, 274, 0, 0, - 0, 0, 54, 55, 56, 57, 58, 59, 0, 0, - 0, 60, 0, 61, 62, 0, 63, 64, 65, 66, - 0, 67, 68, 662, 662, 662, 0, 662, 0, 0, - 0, 662, 662, 0, 0, 0, 662, 0, 662, 662, - 662, 662, 662, 662, 662, 0, 0, 0, 0, 662, - 662, 662, 662, 662, 662, 662, 0, 0, 662, 0, - 0, 0, 0, 0, 0, 662, 0, 0, 662, 662, - 662, 0, 662, 662, 662, 662, 662, 662, 0, 662, - 662, 662, 662, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 662, 662, 0, - 0, 0, 0, 0, 0, 662, 0, 0, 662, 0, - 0, 662, 662, 0, 662, 0, 0, 0, 0, 0, - 662, 0, 0, 0, 0, 0, 0, 0, 662, 0, - 0, 0, 0, 662, 662, 662, 662, 662, 662, 0, - 0, 0, 662, 0, 662, 662, 0, 662, 662, 662, - 662, 0, 662, 662, 4, 5, 6, 0, 8, 0, - 0, 0, 9, 10, 0, 0, 0, 11, 0, 12, - 13, 14, 243, 244, 17, 18, 0, 0, 0, 0, - 19, 245, 246, 247, 248, 249, 250, 0, 0, 251, - 0, 0, 0, 0, 0, 0, 252, 0, 0, 253, - 254, 255, 0, 256, 35, 257, 258, 259, 260, 0, - 40, 0, 0, 261, 0, 0, 0, 0, 0, 0, + 44, 45, 0, 0, 0, 0, 0, 0, 227, 0, + 0, 228, 502, 0, 48, 49, 0, 50, 0, 0, + 0, 0, 0, 52, 0, 0, 0, 0, 0, 0, + 0, 275, 0, 0, 0, 0, 54, 55, 56, 57, + 58, 59, 0, 0, 0, 60, 0, 61, 62, 0, + 63, 64, 65, 66, 0, 67, 68, 4, 5, 6, + 0, 8, 0, 0, 0, 9, 10, 0, 0, 0, + 11, 0, 12, 13, 14, 15, 16, 17, 18, 0, + 0, 0, 19, 20, 21, 215, 216, 217, 218, 0, + 0, 252, 0, 0, 0, 0, 0, 0, 28, 0, + 0, 219, 220, 221, 0, 222, 35, 223, 224, 225, + 226, 0, 40, 41, 42, 43, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 262, 0, 0, 47, - 0, 0, 48, 49, 0, 50, 0, 51, 0, 0, + 44, 45, 0, 0, 0, 0, 0, 0, 227, 0, + 0, 228, 0, 0, 48, 49, 0, 50, 0, 613, + 0, 0, 0, 52, 0, 0, 0, 0, 0, 0, + 0, 275, 0, 0, 0, 0, 54, 55, 56, 57, + 58, 59, 0, 0, 0, 60, 0, 61, 62, 0, + 63, 64, 65, 66, 0, 67, 68, 4, 5, 6, + 0, 8, 0, 0, 0, 9, 10, 0, 0, 0, + 11, 0, 12, 13, 14, 244, 245, 17, 18, 0, + 0, 0, 19, 246, 247, 215, 216, 217, 218, 0, + 0, 252, 0, 0, 0, 0, 0, 0, 28, 0, + 0, 219, 220, 221, 0, 222, 35, 223, 224, 225, + 226, 0, 40, 41, 42, 43, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 54, 55, 56, 57, 58, 59, - 0, 0, 0, 60, 0, 61, 62, 0, 63, 64, - 65, 66, 0, 67, 68, 4, 5, 6, 0, 8, - 0, 0, 0, 9, 10, 0, 0, 0, 11, 0, - 12, 13, 14, 243, 244, 17, 18, 0, 0, 0, - 0, 19, 245, 246, 327, 328, 329, 330, 0, 0, - 251, 0, 0, 0, 0, 0, 0, 252, 0, 0, - 331, 332, 333, 0, 334, 35, 335, 336, 337, 338, - 0, 40, 0, 0, 261, 0, 0, 0, 0, 0, + 44, 45, 0, 0, 0, 0, 0, 0, 227, 0, + 0, 228, 0, 0, 48, 49, 0, 50, 0, 273, + 0, 0, 0, 52, 0, 0, 0, 0, 0, 0, + 0, 275, 0, 0, 0, 0, 54, 55, 56, 57, + 58, 59, 0, 0, 0, 60, 0, 61, 62, 0, + 63, 64, 65, 66, 0, 67, 68, 4, 5, 6, + 0, 8, 0, 0, 0, 9, 10, 0, 0, 0, + 11, 0, 12, 13, 14, 244, 245, 17, 18, 0, + 0, 0, 19, 246, 247, 215, 216, 217, 218, 0, + 0, 252, 0, 0, 0, 0, 0, 0, 28, 0, + 0, 219, 220, 221, 0, 222, 35, 223, 224, 225, + 226, 0, 40, 41, 42, 43, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 339, 0, 0, - 414, 0, 0, 48, 49, 0, 50, 0, 415, 0, + 44, 45, 0, 0, 0, 0, 0, 0, 227, 0, + 0, 228, 0, 0, 48, 49, 0, 50, 0, 613, + 0, 0, 0, 52, 0, 0, 0, 0, 0, 0, + 0, 275, 0, 0, 0, 0, 54, 55, 56, 57, + 58, 59, 0, 0, 0, 60, 0, 61, 62, 0, + 63, 64, 65, 66, 0, 67, 68, 4, 5, 6, + 0, 8, 0, 0, 0, 9, 10, 0, 0, 0, + 11, 0, 12, 13, 14, 244, 245, 17, 18, 0, + 0, 0, 19, 246, 247, 215, 216, 217, 218, 0, + 0, 252, 0, 0, 0, 0, 0, 0, 28, 0, + 0, 219, 220, 221, 0, 222, 35, 223, 224, 225, + 226, 0, 40, 41, 42, 43, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 54, 55, 56, 57, 58, - 59, 0, 0, 0, 60, 0, 61, 62, 0, 63, - 64, 65, 66, 0, 67, 68, 4, 5, 6, 0, - 8, 0, 0, 0, 9, 10, 0, 0, 0, 11, - 0, 12, 13, 14, 243, 244, 17, 18, 0, 0, - 0, 0, 19, 245, 246, 425, 426, 427, 428, 0, - 0, 251, 0, 0, 0, 0, 0, 0, 252, 0, - 0, 429, 430, 431, 0, 432, 35, 158, 159, 433, - 161, 0, 40, 0, 0, 261, 0, 0, 0, 0, + 44, 45, 0, 0, 0, 0, 0, 0, 227, 0, + 0, 228, 0, 0, 48, 49, 0, 50, 0, 903, + 0, 0, 0, 52, 0, 0, 0, 0, 0, 0, + 0, 275, 0, 0, 0, 0, 54, 55, 56, 57, + 58, 59, 0, 0, 0, 60, 0, 61, 62, 0, + 63, 64, 65, 66, 0, 67, 68, 4, 5, 6, + 0, 8, 0, 0, 0, 9, 10, 0, 0, 0, + 11, 0, 12, 13, 14, 244, 245, 17, 18, 0, + 0, 0, 19, 246, 247, 215, 216, 217, 218, 0, + 0, 252, 0, 0, 0, 0, 0, 0, 28, 0, + 0, 219, 220, 221, 0, 222, 35, 223, 224, 225, + 226, 0, 40, 41, 42, 43, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 434, 0, 0, 0, 435, 0, - 0, 227, 0, 0, 48, 49, 0, 50, 0, 0, + 44, 45, 0, 0, 0, 0, 0, 0, 227, 0, + 0, 228, 0, 0, 48, 49, 0, 50, 0, 677, + 0, 0, 0, 52, 0, 0, 0, 0, 0, 0, + 0, 275, 0, 0, 0, 0, 54, 55, 56, 57, + 58, 59, 0, 0, 0, 60, 0, 61, 62, 0, + 63, 64, 65, 66, 0, 67, 68, 768, 768, 768, + 0, 768, 0, 0, 0, 768, 768, 0, 0, 0, + 768, 0, 768, 768, 768, 768, 768, 768, 768, 0, + 0, 0, 768, 768, 768, 768, 768, 768, 768, 0, + 0, 768, 0, 0, 0, 0, 0, 0, 768, 0, + 0, 768, 768, 768, 0, 768, 768, 768, 768, 768, + 768, 0, 768, 768, 768, 768, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 768, 768, 0, 0, 0, 0, 0, 0, 768, 0, + 0, 768, 768, 0, 768, 768, 0, 768, 0, 0, + 0, 0, 0, 768, 0, 0, 0, 0, 0, 0, + 0, 768, 0, 0, 0, 0, 768, 768, 768, 768, + 768, 768, 0, 0, 0, 768, 0, 768, 768, 0, + 768, 768, 768, 768, 0, 768, 768, 4, 5, 6, + 0, 8, 0, 0, 0, 9, 10, 0, 0, 0, + 11, 0, 12, 13, 14, 15, 16, 17, 18, 0, + 0, 0, 19, 20, 21, 215, 216, 217, 218, 0, + 0, 26, 0, 0, 0, 0, 0, 0, 28, 0, + 0, 219, 220, 221, 0, 222, 35, 223, 224, 225, + 226, 0, 40, 41, 42, 43, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 44, 45, 0, 0, 0, 0, 0, 0, 227, 0, + 0, 228, 0, 0, 48, 49, 0, 50, 0, 0, + 0, 0, 0, 52, 0, 0, 0, 0, 0, 0, + 0, 53, 0, 0, 0, 0, 54, 55, 56, 57, + 58, 59, 0, 0, 0, 60, 0, 61, 62, 0, + 63, 64, 65, 66, 0, 67, 68, 4, 5, 6, + 0, 8, 0, 0, 0, 9, 10, 0, 0, 0, + 11, 0, 12, 13, 14, 244, 245, 17, 18, 0, + 0, 0, 19, 246, 247, 215, 216, 217, 218, 0, + 0, 252, 0, 0, 0, 0, 0, 0, 28, 0, + 0, 219, 220, 221, 0, 222, 35, 223, 224, 225, + 226, 0, 40, 41, 42, 43, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 44, 45, 0, 0, 0, 0, 0, 0, 227, 0, + 0, 228, 0, 0, 48, 49, 0, 50, 0, 0, + 0, 0, 0, 52, 0, 0, 0, 0, 0, 0, + 0, 275, 0, 0, 0, 0, 54, 55, 56, 57, + 58, 59, 0, 0, 0, 60, 0, 61, 62, 0, + 63, 64, 65, 66, 0, 67, 68, 4, 5, 6, + 0, 8, 0, 0, 0, 9, 10, 0, 0, 0, + 11, 0, 12, 13, 14, 15, 16, 17, 18, 0, + 0, 0, 19, 20, 21, 215, 216, 217, 218, 0, + 0, 252, 0, 0, 0, 0, 0, 0, 28, 0, + 0, 219, 220, 221, 0, 222, 35, 223, 224, 225, + 226, 0, 40, 41, 42, 43, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 44, 45, 0, 0, 0, 0, 0, 0, 227, 0, + 0, 228, 0, 0, 48, 49, 0, 50, 0, 0, + 0, 0, 0, 52, 0, 0, 0, 0, 0, 0, + 0, 275, 0, 0, 0, 0, 54, 55, 56, 57, + 58, 59, 0, 0, 0, 60, 0, 61, 62, 0, + 63, 64, 65, 66, 0, 67, 68, 768, 768, 768, + 0, 768, 0, 0, 0, 768, 768, 0, 0, 0, + 768, 0, 768, 768, 768, 768, 768, 768, 768, 0, + 0, 0, 768, 768, 768, 768, 768, 768, 768, 0, + 0, 768, 0, 0, 0, 0, 0, 0, 768, 0, + 0, 768, 768, 768, 0, 768, 768, 768, 768, 768, + 768, 0, 768, 768, 768, 768, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 768, 768, 0, 0, 0, 0, 0, 0, 768, 0, + 0, 768, 0, 0, 768, 768, 0, 768, 0, 0, + 0, 0, 0, 768, 0, 0, 0, 0, 0, 0, + 0, 768, 0, 0, 0, 0, 768, 768, 768, 768, + 768, 768, 0, 0, 0, 768, 0, 768, 768, 0, + 768, 768, 768, 768, 0, 768, 768, 4, 5, 6, + 0, 8, 0, 0, 0, 9, 10, 0, 0, 0, + 11, 0, 12, 13, 14, 244, 245, 17, 18, 0, + 0, 0, 19, 246, 247, 248, 249, 250, 251, 0, + 0, 252, 0, 0, 0, 0, 0, 0, 253, 0, + 0, 254, 255, 256, 0, 257, 35, 258, 259, 260, + 261, 0, 40, 0, 0, 262, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 263, 0, + 0, 47, 0, 0, 48, 49, 0, 50, 0, 51, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, 55, 56, 57, 58, 59, 0, 0, 0, 60, 0, 61, 62, 0, 63, 64, 65, 66, 0, 67, 68, 4, 5, 6, 0, 8, 0, 0, 0, 9, 10, 0, 0, 0, - 11, 0, 12, 13, 14, 243, 244, 17, 18, 0, - 0, 0, 0, 19, 245, 246, 425, 426, 427, 428, - 0, 0, 251, 0, 0, 0, 0, 0, 0, 252, - 0, 0, 429, 430, 431, 0, 432, 35, 158, 159, - 433, 161, 0, 40, 0, 0, 261, 0, 0, 0, + 11, 0, 12, 13, 14, 244, 245, 17, 18, 0, + 0, 0, 19, 246, 247, 328, 329, 330, 331, 0, + 0, 252, 0, 0, 0, 0, 0, 0, 253, 0, + 0, 332, 333, 334, 0, 335, 35, 336, 337, 338, + 339, 0, 40, 0, 0, 262, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 435, - 0, 0, 227, 0, 0, 48, 49, 0, 50, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 340, 0, + 0, 414, 0, 0, 48, 49, 0, 50, 0, 415, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 54, 55, 56, - 57, 58, 59, 0, 0, 0, 60, 0, 61, 62, - 0, 63, 64, 65, 66, 0, 67, 68, 4, 5, - 6, 0, 8, 0, 0, 0, 9, 10, 0, 0, - 0, 11, 0, 12, 13, 14, 243, 244, 17, 18, - 0, 0, 0, 0, 19, 245, 246, 327, 328, 329, - 330, 0, 0, 251, 0, 0, 0, 0, 0, 0, - 252, 0, 0, 331, 332, 333, 0, 334, 35, 335, - 336, 337, 338, 0, 40, 0, 0, 261, 0, 0, + 0, 0, 0, 0, 0, 0, 54, 55, 56, 57, + 58, 59, 0, 0, 0, 60, 0, 61, 62, 0, + 63, 64, 65, 66, 0, 67, 68, 4, 5, 6, + 0, 8, 0, 0, 0, 9, 10, 0, 0, 0, + 11, 0, 12, 13, 14, 244, 245, 17, 18, 0, + 0, 0, 19, 246, 247, 425, 426, 427, 428, 0, + 0, 252, 0, 0, 0, 0, 0, 0, 253, 0, + 0, 429, 430, 431, 0, 432, 35, 158, 159, 433, + 161, 0, 40, 0, 0, 262, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 434, 0, 0, 0, 435, 0, + 0, 228, 0, 0, 48, 49, 0, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 54, 55, 56, 57, + 58, 59, 0, 0, 0, 60, 0, 61, 62, 0, + 63, 64, 65, 66, 0, 67, 68, 4, 5, 6, + 0, 8, 0, 0, 0, 9, 10, 0, 0, 0, + 11, 0, 12, 13, 14, 244, 245, 17, 18, 0, + 0, 0, 19, 246, 247, 425, 426, 427, 428, 0, + 0, 252, 0, 0, 0, 0, 0, 0, 253, 0, + 0, 429, 430, 431, 0, 432, 35, 158, 159, 433, + 161, 0, 40, 0, 0, 262, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 339, 0, 0, 414, 0, 0, 48, 49, 0, 50, + 0, 0, 0, 0, 0, 0, 0, 0, 435, 0, + 0, 228, 0, 0, 48, 49, 0, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 54, 55, - 56, 57, 58, 59, 0, 0, 0, 60, 0, 61, - 62, 0, 63, 64, 65, 66, 0, 67, 68, 4, - 5, 6, 0, 8, 0, 0, 0, 9, 10, 0, - 0, 0, 11, 0, 12, 13, 14, 243, 244, 17, - 18, 0, 0, 0, 0, 19, 245, 246, 979, 980, - 981, 982, 0, 0, 251, 0, 0, 0, 0, 0, - 0, 252, 0, 0, 983, 984, 985, 0, 986, 35, - 987, 988, 989, 990, 0, 40, 0, 0, 261, 0, + 0, 0, 0, 0, 0, 0, 54, 55, 56, 57, + 58, 59, 0, 0, 0, 60, 0, 61, 62, 0, + 63, 64, 65, 66, 0, 67, 68, 4, 5, 6, + 0, 8, 0, 0, 0, 9, 10, 0, 0, 0, + 11, 0, 12, 13, 14, 244, 245, 17, 18, 0, + 0, 0, 19, 246, 247, 328, 329, 330, 331, 0, + 0, 252, 0, 0, 0, 0, 0, 0, 253, 0, + 0, 332, 333, 334, 0, 335, 35, 336, 337, 338, + 339, 0, 40, 0, 0, 262, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 340, 0, + 0, 414, 0, 0, 48, 49, 0, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 991, 0, 0, 227, 0, 0, 48, 49, 0, - 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 54, - 55, 56, 57, 58, 59, 0, 0, 0, 60, 0, - 61, 62, 0, 63, 64, 65, 66, 0, 67, 68, - 4, 5, 6, 0, 8, 0, 0, 0, 9, 10, - 0, 0, 0, 11, 0, 12, 13, 14, 243, 244, - 17, 18, 0, 0, 0, 0, 19, 245, 246, 425, - 426, 427, 428, 0, 0, 251, 0, 0, 0, 0, - 0, 0, 252, 0, 0, 429, 430, 431, 0, 1075, - 35, 158, 159, 1076, 161, 0, 40, 0, 0, 261, + 0, 0, 0, 0, 0, 0, 54, 55, 56, 57, + 58, 59, 0, 0, 0, 60, 0, 61, 62, 0, + 63, 64, 65, 66, 0, 67, 68, 4, 5, 6, + 0, 8, 0, 0, 0, 9, 10, 0, 0, 0, + 11, 0, 12, 13, 14, 244, 245, 17, 18, 0, + 0, 0, 19, 246, 247, 979, 980, 981, 982, 0, + 0, 252, 0, 0, 0, 0, 0, 0, 253, 0, + 0, 983, 984, 985, 0, 986, 35, 987, 988, 989, + 990, 0, 40, 0, 0, 262, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 991, 0, + 0, 228, 0, 0, 48, 49, 0, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1077, 0, 0, 227, 0, 0, 48, 49, - 0, 50, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 54, 55, 56, 57, + 58, 59, 0, 0, 0, 60, 0, 61, 62, 0, + 63, 64, 65, 66, 0, 67, 68, 4, 5, 6, + 0, 8, 0, 0, 0, 9, 10, 0, 0, 0, + 11, 0, 12, 13, 14, 244, 245, 17, 18, 0, + 0, 0, 19, 246, 247, 425, 426, 427, 428, 0, + 0, 252, 0, 0, 0, 0, 0, 0, 253, 0, + 0, 429, 430, 431, 0, 1163, 35, 158, 159, 1164, + 161, 0, 40, 0, 0, 262, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 54, 55, 56, 57, 58, 59, 0, 0, 0, 60, - 0, 61, 62, 0, 63, 64, 65, 66, 0, 67, - 68, 701, 587, 0, 0, 702, 0, 0, 0, 162, + 0, 0, 0, 0, 0, 0, 0, 0, 1165, 0, + 0, 228, 0, 0, 48, 49, 0, 50, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 54, 55, 56, 57, + 58, 59, 0, 0, 0, 60, 0, 61, 62, 0, + 63, 64, 65, 66, 0, 67, 68, 655, 596, 0, + 0, 656, 0, 0, 0, 162, 163, 0, 164, 165, + 166, 167, 168, 169, 170, 0, 0, 171, 172, 0, + 0, 0, 0, 0, 173, 174, 175, 176, 0, 0, + 0, 0, 0, 0, 290, 0, 0, 0, 0, 0, + 0, 178, 179, 0, 180, 181, 182, 183, 184, 185, + 186, 187, 188, 189, 190, 667, 587, 191, 0, 668, + 0, 0, 0, 162, 163, 0, 164, 165, 166, 167, + 168, 169, 170, 0, 0, 171, 172, 0, 0, 192, + 0, 0, 173, 174, 175, 176, 0, 0, 0, 0, + 0, 0, 290, 0, 0, 0, 0, 0, 0, 178, + 179, 0, 180, 181, 182, 183, 184, 185, 186, 187, + 188, 189, 190, 671, 596, 191, 0, 672, 0, 0, + 0, 162, 163, 0, 164, 165, 166, 167, 168, 169, + 170, 0, 0, 171, 172, 0, 0, 192, 0, 0, + 173, 174, 175, 176, 0, 0, 0, 0, 0, 0, + 290, 0, 0, 0, 0, 0, 0, 178, 179, 0, + 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, + 190, 701, 587, 191, 0, 702, 0, 0, 0, 162, 163, 0, 164, 165, 166, 167, 168, 169, 170, 0, - 0, 171, 172, 0, 0, 0, 0, 0, 173, 174, - 175, 176, 0, 0, 0, 0, 0, 0, 289, 0, + 0, 171, 172, 0, 0, 192, 0, 0, 173, 174, + 175, 176, 0, 0, 0, 0, 0, 0, 290, 0, 0, 0, 0, 0, 0, 178, 179, 0, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 704, 596, 191, 0, 705, 0, 0, 0, 162, 163, 0, 164, 165, 166, 167, 168, 169, 170, 0, 0, 171, 172, 0, 0, 192, 0, 0, 173, 174, 175, 176, - 0, 0, 0, 0, 0, 0, 289, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 290, 0, 0, 0, 0, 0, 0, 178, 179, 0, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 791, 587, 191, 0, 792, 0, 0, 0, 162, 163, 0, 164, 165, 166, 167, 168, 169, 170, 0, 0, 171, 172, 0, 0, 192, 0, 0, 173, 174, 175, 176, 0, 0, - 0, 0, 0, 0, 289, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 290, 0, 0, 0, 0, 0, 0, 178, 179, 0, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 602, 596, 191, 0, 603, 0, 0, 0, 162, 163, 0, 164, 165, 166, 167, 168, 169, 170, 0, 0, 171, 172, 0, 0, 192, 0, 0, 173, 174, 175, 176, 0, 0, 0, 0, - 0, 0, 289, 0, 0, 0, 0, 0, 0, 178, + 0, 0, 290, 0, 0, 0, 0, 0, 0, 178, 179, 0, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 898, 587, 191, 0, 899, 0, 0, 0, 162, 163, 0, 164, 165, 166, 167, 168, 169, 170, 0, 0, 171, 172, 0, 0, 192, 0, 0, 173, 174, 175, 176, 0, 0, 0, 0, 0, 0, - 289, 0, 0, 0, 0, 0, 0, 178, 179, 0, + 290, 0, 0, 0, 0, 0, 0, 178, 179, 0, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 901, 596, 191, 0, 902, 0, 0, 0, 162, 163, 0, 164, 165, 166, 167, 168, 169, 170, 0, 0, 171, 172, 0, 0, 192, 0, 0, 173, 174, - 175, 176, 0, 0, 0, 0, 0, 0, 289, 0, + 175, 176, 0, 0, 0, 0, 0, 0, 290, 0, 0, 0, 0, 0, 0, 178, 179, 0, 180, 181, - 182, 183, 184, 185, 186, 187, 188, 189, 190, 1082, - 587, 191, 0, 1083, 0, 0, 0, 162, 163, 0, + 182, 183, 184, 185, 186, 187, 188, 189, 190, 1170, + 587, 191, 0, 1171, 0, 0, 0, 162, 163, 0, 164, 165, 166, 167, 168, 169, 170, 0, 0, 171, 172, 0, 0, 192, 0, 0, 173, 174, 175, 176, - 0, 0, 0, 0, 0, 0, 289, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 290, 0, 0, 0, 0, 0, 0, 178, 179, 0, 180, 181, 182, 183, - 184, 185, 186, 187, 188, 189, 190, 1085, 596, 191, - 0, 1086, 0, 0, 0, 162, 163, 0, 164, 165, + 184, 185, 186, 187, 188, 189, 190, 1173, 596, 191, + 0, 1174, 0, 0, 0, 162, 163, 0, 164, 165, 166, 167, 168, 169, 170, 0, 0, 171, 172, 0, 0, 192, 0, 0, 173, 174, 175, 176, 0, 0, - 0, 0, 0, 0, 289, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 290, 0, 0, 0, 0, 0, 0, 178, 179, 0, 180, 181, 182, 183, 184, 185, - 186, 187, 188, 189, 190, 1128, 587, 191, 0, 1129, + 186, 187, 188, 189, 190, 1266, 587, 191, 0, 1267, 0, 0, 0, 162, 163, 0, 164, 165, 166, 167, 168, 169, 170, 0, 0, 171, 172, 0, 0, 192, 0, 0, 173, 174, 175, 176, 0, 0, 0, 0, - 0, 0, 289, 0, 0, 0, 0, 0, 0, 178, + 0, 0, 290, 0, 0, 0, 0, 0, 0, 178, 179, 0, 180, 181, 182, 183, 184, 185, 186, 187, - 188, 189, 190, 602, 596, 191, 0, 603, 0, 0, - 0, 162, 163, 0, 164, 165, 166, 167, 168, 169, - 170, 0, 0, 171, 172, 0, 0, 192, 0, 0, - 173, 174, 175, 176, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 178, 179, 0, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 190, 0, 0, 191, 0, 0, 0, 0, 0, 0, + 188, 189, 190, 0, 0, 191, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 192, + 0, 0, 0, 0, 0, 0, 0, 192, }; } private static final short[] yyCheck1() { return new short[] { - 2, 3, 234, 26, 76, 28, 21, 9, 10, 11, - 7, 102, 14, 15, 16, 53, 90, 548, 14, 93, - 6, 7, 27, 7, 282, 460, 11, 289, 6, 298, - 27, 51, 2, 3, 3, 10, 0, 405, 15, 16, - 322, 27, 32, 27, 326, 47, 417, 10, 10, 51, - 10, 53, 866, 59, 482, 51, 479, 10, 280, 482, - 47, 59, 10, 10, 864, 343, 945, 10, 54, 21, - 43, 0, 0, 353, 1007, 355, 54, 654, 1071, 15, - 16, 435, 10, 280, 59, 10, 454, 10, 11, 2, - 44, 411, 465, 670, 109, 523, 59, 44, 418, 61, - 102, 10, 470, 9, 10, 11, 102, 61, 110, 111, - 112, 548, 59, 49, 50, 111, 112, 10, 15, 16, - 533, 10, 107, 309, 10, 411, 703, 413, 107, 1122, - 10, 59, 418, 110, 59, 10, 49, 50, 10, 10, - 10, 107, 364, 964, 10, 10, 343, 343, 10, 10, - 10, 10, 49, 10, 305, 44, 230, 109, 1091, 10, - 10, 0, 364, 531, 44, 10, 59, 364, 10, 44, - 59, 10, 44, 10, 110, 61, 10, 1056, 44, 59, - 10, 10, 44, 714, 59, 325, 404, 59, 406, 59, - 264, 32, 410, 10, 59, 61, 476, 59, 59, 59, - 59, 10, 44, 364, 10, 1026, 943, 44, 621, 59, - 10, 213, 10, 110, 59, 44, 10, 794, 310, 1019, - 59, 361, 10, 328, 10, 227, 377, 301, 414, 252, - 59, 10, 10, 338, 492, 453, 10, 455, 269, 241, - 242, 10, 648, 32, 10, 10, 44, 10, 279, 340, - 59, 657, 237, 471, 10, 1069, 10, 685, 237, 59, - 287, 684, 685, 10, 544, 44, 797, 341, 799, 549, - 10, 59, 640, 10, 344, 1012, 647, 714, 10, 306, - 59, 10, 10, 10, 286, 639, 288, 289, 261, 507, - 292, 361, 294, 32, 246, 347, 298, 299, 2, 3, - 271, 32, 306, 59, 368, 307, 310, 309, 279, 286, - 14, 288, 289, 365, 532, 44, 318, 269, 241, 242, - 32, 1058, 309, 900, 61, 279, 311, 59, 298, 340, - 59, 862, 311, 864, 61, 241, 242, 307, 340, 290, - 291, 764, 763, 47, 340, 311, 344, 51, 318, 770, - 286, 271, 288, 44, 10, 361, 281, 1094, 305, 279, - 797, 344, 799, 271, 366, 367, 368, 369, 370, 371, - 372, 279, 785, 411, 267, 413, 289, 282, 361, 417, - 418, 61, 344, 373, 374, 298, 292, 347, 294, 286, - 380, 288, 289, 279, 347, 415, 344, 344, 102, 347, - 370, 365, 365, 405, 347, 61, 61, 111, 112, 411, - 778, 413, 414, 415, 389, 417, 418, 699, 420, 415, - 406, 679, 684, 641, 410, 305, 695, 414, 405, 661, - 377, 711, 434, 964, 343, 50, 365, 365, 267, 441, - 760, 761, 533, 366, 367, 368, 369, 767, 768, 451, - 420, 420, 454, 826, 406, 264, 340, 459, 344, 10, - 366, 367, 368, 369, 344, 371, 372, 44, 470, 455, - 310, 751, 361, 344, 760, 761, 347, 454, 344, 464, - 465, 767, 768, 344, 47, 471, 361, 344, 1019, 361, - 347, 361, 405, 470, 780, 930, 501, 377, 10, 361, - 502, 361, 361, 455, 501, 305, 934, 1084, 59, 213, - 344, 934, 341, 515, 344, 501, 413, 501, 340, 471, - 417, 507, 61, 227, 930, 340, 305, 344, 434, 531, - 621, 533, 373, 374, 608, 441, 1067, 533, 344, 380, - 1071, 454, 279, 479, 344, 271, 532, 59, 10, 305, - 344, 59, 279, 10, 531, 507, 344, 470, 344, 777, - 583, 779, 290, 291, 461, 344, 344, 887, 268, 269, - 344, 594, 830, 305, 589, 344, 305, 377, 344, 344, - 532, 344, 361, 598, 520, 269, 818, 271, 344, 604, - 344, 1122, 998, 44, 298, 299, 502, 344, 377, 61, - 862, 887, 59, 307, 344, 309, 279, 344, 375, 700, - 343, 724, 344, 380, 318, 344, 10, 344, 531, 621, - 797, 377, 799, 279, 310, 621, 10, 10, 10, 361, - 308, 654, 361, 862, 91, 341, 340, 589, 640, 375, - 642, 646, 352, 353, 380, 377, 598, 670, 377, 646, - 10, 44, 604, 44, 10, 641, 271, 272, 273, 645, - 646, 276, 646, 640, 227, 59, 370, 645, 317, 44, - 263, 264, 674, 10, 317, 1043, 59, 61, 340, 61, - 703, 344, 347, 10, 365, 598, 918, 10, 344, 641, - 10, 604, 924, 695, 785, 44, 373, 374, 700, 59, - 378, 379, 774, 380, 700, 61, 310, 411, 385, 413, - 414, 415, 343, 264, 418, 44, 420, 669, 269, 44, - 10, 673, 760, 761, 349, 695, 359, 640, 279, 767, - 768, 262, 59, 267, 647, 648, 299, 650, 61, 852, - 853, 61, 780, 264, 657, 343, 309, 451, 684, 264, - 647, 674, 264, 344, 44, 459, 268, 269, 760, 761, - 673, 658, 91, 44, 44, 767, 768, 364, 674, 59, - 365, 794, 44, 775, 317, 365, 778, 264, 780, 15, - 16, 365, 695, 785, 786, 264, 1015, 789, 790, 785, - 91, 10, 340, 779, 340, 44, 798, 297, 413, 322, - 323, 778, 417, 788, 806, 775, 61, 809, 351, 328, - 267, 515, 355, 356, 357, 358, 786, 279, 337, 338, - 822, 823, 824, 280, 847, 297, 1044, 779, 764, 533, - 943, 745, 945, 263, 264, 749, 359, 360, 1067, 269, - 59, 826, 755, 0, 757, 340, 461, 849, 850, 887, - 340, 414, 44, 10, 44, 306, 269, 308, 309, 310, - 311, 343, 340, 478, 479, 778, 789, 482, 264, 340, - 340, 328, 340, 267, 110, 877, 32, 900, 880, 264, - 337, 338, 344, 789, 267, 887, 809, 44, 451, 1118, - 306, 804, 306, 44, 807, 279, 459, 279, 44, 1012, - 1013, 44, 59, 809, 264, 520, 908, 364, 523, 269, - 44, 271, 44, 61, 91, 917, 32, 621, 992, 921, - 411, 917, 58, 279, 909, 340, 928, 418, 347, 10, - 915, 306, 365, 308, 309, 310, 311, 264, 642, 2, - 3, 964, 269, 1056, 341, 1058, 9, 10, 11, 264, - 279, 280, 15, 16, 736, 737, 279, 10, 341, 279, - 344, 263, 344, 340, 264, 456, 264, 458, 44, 306, - 365, 308, 309, 310, 311, 312, 978, 267, 59, 44, - 317, 1094, 264, 344, 47, 373, 374, 375, 344, 264, - 53, 695, 380, 995, 264, 997, 700, 264, 613, 328, - 59, 264, 1004, 1026, 708, 342, 59, 365, 337, 338, - 91, 44, 44, 350, 351, 352, 353, 930, 509, 44, - 44, 344, 44, 264, 344, 308, 309, 328, 311, 306, - 1053, 310, 647, 642, 1036, 364, 337, 338, 91, 44, - 1036, 1043, 44, 658, 263, 264, 960, 110, 44, 1051, - 286, 388, 288, 44, 44, 361, 760, 761, 1044, 264, - 675, 1084, 677, 767, 768, 264, 1043, 61, 44, 684, - 685, 775, 44, 361, 10, 10, 780, 1079, 310, 389, - 44, 785, 786, 1079, 44, 998, 790, 44, 44, 44, - 2, 3, 1044, 271, 798, 378, 379, 9, 10, 11, - 347, 365, 806, 15, 16, 262, 263, 264, 343, 44, - 267, 268, 269, 344, 271, 365, 1030, 347, 822, 823, - 824, 1035, 279, 59, 1038, 347, 61, 373, 374, 375, - 1043, 746, 317, 1046, 380, 47, 293, 294, 295, 296, - 297, 53, 58, 347, 390, 849, 850, 264, 72, 764, - 213, 328, 0, 275, 312, 56, 91, 549, 112, 317, - 337, 338, 10, 515, 227, 947, 351, 782, 950, 951, - 355, 356, 954, 877, 956, 6, 880, 1046, 241, 242, - 862, 790, 864, 887, 341, 548, 267, 344, 757, 798, - 44, 916, 1106, 604, 352, 353, 998, 866, 110, 280, - 373, 374, 375, 862, 908, 964, 821, 380, 365, 292, - 631, 59, 1067, 917, 267, 1069, 44, 921, 293, 294, - 295, 296, 297, 286, 928, 288, 289, 280, 773, 292, - 388, 294, 389, 316, 317, 298, 299, 91, 400, 14, - 849, 1045, 852, 806, 307, 91, 309, 328, 381, 382, - 383, 384, 2, 3, 91, 318, 337, 338, 873, 822, - 823, 824, 343, 91, 14, 1091, 91, -1, 877, 760, - 761, -1, -1, -1, 978, 328, 767, 768, 1060, 1061, - 1062, 1063, 964, 364, 337, 338, -1, 850, 903, -1, - 343, 995, 10, 997, -1, -1, -1, 47, -1, 908, - 1004, 213, 0, 366, 367, 368, 369, 370, 371, 372, - -1, 364, 10, -1, -1, 227, -1, 880, -1, 934, - -1, 812, 813, -1, 815, 816, 262, 263, 264, 241, - 242, -1, 1036, 269, -1, 1117, -1, 1019, -1, 91, - -1, 59, 405, 44, 279, 44, 44, 1051, 411, -1, - 413, 414, -1, -1, 417, 418, -1, 420, 921, -1, - -1, 59, 964, -1, -1, 928, 44, 91, -1, 978, - -1, 434, -1, -1, 286, 1079, 288, 289, 441, -1, - 292, -1, 294, -1, -1, 1067, 298, 299, 451, 1071, - 91, 454, 91, 328, 91, 307, 459, 309, 91, -1, - -1, 484, 337, 338, 10, -1, 318, 470, 343, 344, - 493, 494, 495, 91, 262, 263, 264, -1, -1, 267, - 268, 269, -1, 271, 10, 279, -1, -1, -1, 512, - -1, 279, 995, 281, 997, -1, -1, -1, 44, 502, - 1122, 1004, 290, 291, -1, 293, 294, 295, 296, 297, - -1, 279, 515, 59, 366, 367, 368, 369, 370, 371, - 372, -1, 1064, 213, -1, 1067, -1, 1069, 531, 1071, - -1, -1, -1, 59, 328, -1, -1, 227, -1, 44, - 328, 10, 328, 337, 338, 91, -1, -1, 1051, 337, - 338, 337, 338, 405, 10, -1, 344, -1, -1, 411, - 328, 413, 414, 328, -1, 417, 418, -1, 420, 337, - 338, -1, 337, 338, -1, 44, 1118, 365, 1120, -1, - 1122, -1, 434, 1125, -1, -1, 91, -1, -1, 441, - 91, -1, 61, -1, 1136, -1, -1, 620, -1, 451, - -1, 389, 454, 59, 262, 263, 264, 459, 298, 299, - 268, 269, -1, 271, -1, 2, 3, 307, 470, 309, - 643, 279, 91, -1, 262, 263, 264, -1, 318, 267, - 268, 269, -1, 271, -1, 10, 328, 640, 279, 642, - 279, 279, -1, 281, 282, 337, 338, 373, 374, 375, - 502, -1, 290, 291, 380, 293, 294, 295, 296, 297, - 47, 279, 280, 515, 328, -1, -1, 690, -1, -1, - -1, 674, -1, 337, 338, 698, 373, 374, 375, 531, - 370, 10, -1, 380, 59, -1, 344, 328, -1, 328, - -1, 328, 695, -1, -1, 328, 337, 338, 337, 338, - 337, 338, 343, -1, 337, 338, 344, 365, -1, 347, - 328, 349, -1, -1, -1, 44, 91, -1, -1, 337, - 338, 411, -1, 413, 414, 343, -1, 365, 418, -1, - 420, 389, 61, 10, -1, -1, 262, 263, 264, -1, - -1, -1, 268, 269, -1, 271, 364, 10, -1, -1, - 0, 389, -1, 279, -1, -1, -1, 760, 761, -1, - 10, 451, 91, -1, 767, 768, -1, 44, -1, 459, - -1, -1, 775, -1, 279, 778, -1, 780, 373, 374, - 375, 44, 328, 786, 61, 380, 789, 790, 640, -1, - 642, 337, 338, -1, 44, 798, -1, 343, 61, -1, - 373, 374, 375, 806, 44, -1, 809, 380, 831, 59, - 279, -1, -1, -1, 91, 361, -1, 44, 344, 822, - 823, 824, 674, 328, -1, 515, 213, 328, 91, -1, - -1, -1, 337, 338, 857, -1, 337, 338, -1, 365, - 227, -1, -1, 695, -1, -1, 849, 850, -1, 10, - 306, 91, 308, 309, 310, 311, 312, -1, -1, 328, - 44, 317, -1, 389, 91, -1, -1, -1, 337, 338, - -1, -1, 328, -1, 877, 344, 332, 880, -1, -1, - 10, -1, 338, -1, 887, -1, 342, 343, -1, 44, - 913, -1, 267, -1, 350, 351, 352, 353, 59, 306, - 0, 308, 309, 310, 311, 908, -1, 91, 760, 761, - 10, 298, 299, -1, -1, 767, 768, -1, 921, 942, - 307, -1, 309, 775, -1, 928, 778, -1, 780, 59, - 91, 318, 388, -1, 786, 342, 91, 789, 790, -1, - -1, -1, -1, 350, -1, -1, 798, -1, -1, -1, - 279, -1, 642, 328, 806, -1, -1, 809, -1, 59, - -1, 91, 337, 338, -1, -1, -1, -1, 343, -1, - 822, 823, 824, -1, -1, 978, -1, -1, 0, -1, - -1, -1, 306, 370, 308, 309, 310, 311, 10, -1, - -1, -1, 995, -1, 997, -1, -1, 849, 850, 328, - -1, 1004, 279, 280, -1, 695, -1, -1, 337, 338, - -1, -1, 262, 263, 264, 344, 279, 267, 268, 269, - -1, 271, 44, -1, 411, 877, 413, 414, 880, 279, - -1, 418, -1, 420, -1, 887, 58, 59, -1, 279, - 1043, 63, 44, 293, 294, 295, 296, 297, 1051, -1, - -1, 328, 279, -1, -1, -1, 908, -1, -1, -1, - 337, 338, -1, -1, 451, 328, 343, 344, 10, 921, - 760, 761, 459, -1, 337, 338, 928, 767, 768, -1, - 10, 344, -1, 0, -1, 775, -1, 364, 328, 91, - 780, 341, -1, 10, 344, 279, 786, 337, 338, -1, - 790, 328, 44, -1, -1, -1, 267, -1, 798, -1, - 337, 338, 866, -1, 44, 365, 806, -1, -1, 61, - -1, 0, -1, -1, 279, 280, 978, -1, 515, 59, - -1, 10, 822, 823, 824, -1, -1, 267, -1, 389, - -1, -1, 59, 995, 328, 997, -1, -1, -1, 91, - 280, -1, 1004, 337, 338, 10, -1, -1, -1, 849, - 850, 91, 262, 263, 264, 44, -1, 328, 268, 269, - -1, 271, -1, 328, -1, -1, 337, 338, -1, 279, - 59, -1, 337, 338, -1, 15, 16, 877, 343, 44, - 880, 1043, -1, 293, 294, 295, 296, 887, 328, 1051, - -1, 10, -1, 44, -1, -1, 61, 337, 338, 364, - 964, 41, 42, 343, 44, 45, -1, -1, 908, 49, - 50, 10, 52, 53, -1, -1, -1, 917, -1, -1, - -1, 921, -1, -1, 364, 44, 91, -1, 928, -1, - 262, 263, 264, -1, 344, 267, 268, 269, -1, 271, - 91, -1, 61, -1, -1, 642, -1, 279, -1, 281, - 282, -1, -1, -1, -1, 365, -1, 10, 290, 291, - 59, 293, 294, 295, 296, 297, -1, 279, -1, -1, - 110, -1, 91, 305, -1, -1, -1, -1, 978, 389, - -1, -1, -1, 306, -1, 308, 309, 310, 311, 312, - -1, 44, 91, -1, 317, 995, -1, 997, 695, -1, - 1064, -1, -1, 1067, 1004, 1069, 10, 1071, 61, 341, - -1, -1, 344, -1, -1, 347, 328, 349, -1, 342, - -1, -1, -1, -1, -1, 337, 338, 279, 280, 352, - 353, -1, -1, 365, -1, 262, 263, 264, 91, -1, - 280, 268, 269, -1, 271, 377, -1, -1, -1, -1, - -1, 1051, 279, -1, 1118, 59, 1120, 389, 1122, -1, - 10, 1125, -1, 760, 761, 388, 293, 294, 295, 296, - 767, 768, 1136, 262, 263, 264, 328, -1, 775, 268, - 269, -1, 271, 780, -1, 337, 338, 91, 328, 786, - 279, 343, 344, 790, 44, -1, -1, 337, 338, -1, - -1, 798, -1, 343, 293, 294, 295, 296, 297, 806, - -1, 61, 364, -1, 279, 280, -1, 344, -1, -1, - -1, 361, -1, -1, 364, 822, 823, 824, 279, 280, - -1, 271, 272, 273, 274, -1, 276, -1, 365, -1, - -1, 91, -1, -1, 0, -1, 286, -1, 288, 289, - -1, -1, 849, 850, 10, 344, -1, 297, -1, -1, - 279, -1, 389, 328, -1, -1, -1, -1, 267, -1, - -1, -1, 337, 338, -1, -1, 365, 328, 343, 344, - 877, -1, -1, 880, -1, -1, 337, 338, -1, -1, - 887, -1, 343, -1, -1, -1, -1, -1, -1, 364, - 389, -1, -1, 59, -1, -1, -1, -1, -1, 328, - -1, 908, -1, 364, -1, -1, -1, -1, 337, 338, - -1, 10, -1, 10, 921, 344, 279, 280, -1, 328, - -1, 928, -1, 373, 374, 375, 376, 377, 337, 338, - 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, - 390, 391, 392, 393, -1, -1, 396, 397, 398, 399, - 10, -1, -1, 267, -1, 405, -1, 407, 44, -1, - 59, 411, 59, 413, -1, 328, -1, 417, 418, -1, - -1, 978, -1, 10, 337, 338, 10, -1, -1, 10, - 343, 344, 306, -1, 308, 309, 310, 311, 995, -1, - 997, -1, 91, 0, 91, -1, -1, 1004, -1, 59, - -1, 364, -1, 10, 454, 91, 456, 457, 458, -1, - -1, 461, -1, 44, 328, 44, -1, -1, 342, 279, - 470, -1, 59, 337, 338, 59, 350, -1, 478, 479, - 61, 91, 482, -1, -1, -1, -1, 44, 488, -1, - -1, -1, -1, 306, 1051, 308, 309, 310, 311, -1, - -1, 58, 59, -1, 91, -1, 63, 91, 508, 509, - 91, -1, 91, -1, -1, -1, -1, -1, 328, -1, - 520, -1, -1, 523, -1, -1, -1, 337, 338, 342, - -1, 531, -1, -1, 344, 44, 10, -1, -1, -1, + 2, 14, 276, 235, 648, 27, 76, 290, 90, 21, + 435, 93, 6, 657, 102, 460, 479, 283, 299, 482, + 15, 16, 862, 2, 3, 3, 10, 411, 10, 724, + 9, 10, 11, 7, 418, 14, 15, 16, 51, 10, + 11, 10, 482, 6, 7, 7, 51, 49, 50, 9, + 10, 11, 405, 27, 49, 50, 1057, 43, 59, 269, + 54, 44, 59, 0, 27, 27, 417, 10, 47, 2, + 3, 26, 51, 28, 53, 59, 0, 15, 16, 10, + 745, 323, 0, 523, 749, 327, 10, 465, 404, 102, + 406, 54, 61, 47, 410, 864, 10, 10, 110, 112, + 113, 454, 10, 10, 945, 108, 342, 10, 10, 44, + 10, 21, 44, 44, 10, 1126, 111, 470, 61, 310, + 10, 305, 1012, 102, 10, 309, 10, 271, 10, 61, + 304, 44, 111, 112, 113, 59, 10, 453, 271, 455, + 10, 44, 964, 736, 737, 59, 10, 10, 10, 231, + 10, 353, 59, 355, 356, 471, 10, 852, 853, 59, + 10, 1159, 44, 59, 10, 342, 10, 279, 10, 59, + 53, 374, 862, 111, 864, 59, 379, 59, 531, 548, + 390, 44, 44, 265, 44, 59, 10, 10, 324, 59, + 44, 507, 1008, 1009, 44, 279, 59, 59, 44, 763, + 110, 61, 376, 363, 10, 59, 770, 2, 3, 59, + 10, 271, 1213, 59, 639, 40, 532, 10, 10, 14, + 302, 684, 685, 414, 360, 1065, 492, 10, 286, 10, + 342, 411, 10, 413, 10, 214, 363, 47, 418, 10, + 1251, 10, 32, 1133, 1134, 685, 390, 305, 943, 228, + 945, 363, 47, 341, 1076, 61, 51, 390, 10, 327, + 342, 61, 1260, 242, 243, 309, 91, 59, 10, 337, + 10, 242, 243, 10, 964, 11, 262, 10, 61, 363, + 61, 32, 242, 243, 10, 61, 930, 640, 290, 32, + 10, 32, 287, 10, 289, 960, 647, 299, 253, 10, + 1069, 764, 32, 1144, 10, 346, 367, 102, 287, 312, + 289, 290, 1128, 1129, 293, 1155, 295, 112, 113, 10, + 299, 300, 305, 364, 61, 641, 59, 10, 341, 308, + 390, 310, 797, 293, 799, 295, 10, 247, 44, 59, + 319, 10, 544, 10, 61, 714, 343, 549, 10, 287, + 264, 289, 290, 59, 947, 269, 310, 950, 951, 360, + 270, 954, 341, 956, 346, 10, 299, 1062, 1063, 289, + 290, 267, 108, 10, 343, 308, 760, 761, 32, 1069, + 10, 289, 290, 767, 768, 267, 319, 366, 367, 368, + 369, 370, 371, 372, 61, 366, 367, 368, 369, 339, + 343, 684, 415, 405, 388, 340, 366, 367, 368, 369, + 415, 371, 372, 679, 695, 1080, 1256, 10, 228, 214, + 1085, 390, 59, 1088, 10, 778, 405, 364, 797, 661, + 799, 61, 411, 228, 413, 414, 415, 370, 417, 418, + 364, 420, 420, 406, 346, 533, 364, 410, 826, 1144, + 304, 1146, 454, 360, 44, 434, 342, 699, 390, 343, + 414, 777, 441, 779, 364, 1155, 59, 405, 470, 1159, + 360, 934, 451, 343, 434, 454, 390, 15, 16, 501, + 459, 441, 346, 343, 479, 930, 360, 420, 280, 343, + 300, 470, 455, 862, 934, 864, 406, 360, 360, 343, + 310, 91, 238, 887, 299, 300, 2, 3, 471, 711, + 360, 49, 337, 308, 360, 310, 454, 340, 14, 343, + 533, 1216, 376, 502, 319, 520, 608, 501, 411, 531, + 413, 343, 470, 621, 417, 418, 515, 343, 501, 501, + 286, 44, 502, 343, 507, 455, 341, 267, 360, 751, + 343, 47, 531, 346, 533, 1148, 1149, 1150, 1151, 305, + 343, 471, 343, 1228, 830, 343, 281, 343, 44, 532, + 1260, 304, 343, 111, 343, 370, 312, 589, 61, 862, + 760, 761, 372, 373, 390, 1010, 598, 767, 768, 379, + 390, 343, 604, 531, 346, 964, 598, 507, 304, 1243, + 780, 343, 604, 343, 414, 61, 343, 390, 621, 390, + 343, 269, 700, 271, 390, 91, 411, 343, 413, 414, + 415, 339, 532, 418, 646, 420, 343, 360, 583, 372, + 373, 10, 343, 293, 533, 50, 379, 343, 640, 594, + 44, 451, 621, 376, 108, 647, 648, 339, 650, 459, + 309, 645, 343, 390, 360, 657, 451, 317, 318, 10, + 343, 640, 1255, 642, 459, 44, 61, 304, 1111, 343, + 376, 673, 646, 390, 343, 10, 343, 346, 641, 589, + 59, 343, 645, 646, 646, 10, 918, 700, 598, 684, + 1133, 1134, 924, 695, 604, 674, 10, 785, 343, 654, + 1069, 548, 640, 674, 774, 1130, 343, 887, 59, 44, + 343, 304, 10, 343, 674, 670, 695, 10, 214, 339, + 515, 700, 621, 390, 59, 2, 3, 360, 464, 465, + 271, 641, 228, 59, 59, 10, 342, 327, 533, 376, + 1093, 1015, 10, 10, 309, 59, 336, 337, 703, 287, + 343, 289, 290, 755, 390, 757, 340, 343, 0, 669, + 390, 59, 695, 673, 943, 44, 59, 316, 10, 764, + 47, 305, 785, 44, 238, 309, 778, 316, 1094, 10, + 311, 760, 761, 376, 59, 316, 1155, 44, 767, 768, + 1159, 59, 59, 307, 44, 1027, 775, 15, 16, 778, + 390, 780, 804, 299, 300, 807, 785, 786, 372, 373, + 789, 790, 308, 44, 310, 379, 779, 59, 789, 798, + 91, 268, 269, 319, 484, 389, 621, 806, 59, 789, + 809, 10, 10, 493, 494, 495, 367, 339, 809, 794, + 778, 91, 775, 822, 823, 824, 346, 642, 312, 809, + 10, 327, 512, 786, 351, 352, 387, 272, 273, 274, + 336, 337, 277, 377, 378, 44, 342, 714, 374, 779, + 849, 850, 343, 379, 370, 413, 1238, 760, 761, 417, + 59, 59, 1244, 1062, 767, 768, 785, 1126, 309, 321, + 322, 1260, 847, 111, 1133, 1134, 10, 780, 877, 59, + 695, 880, 292, 293, 917, 700, 1268, 10, 887, 364, + 992, 1185, 10, 708, 390, 411, 860, 413, 414, 654, + 864, 10, 418, 461, 420, 304, 358, 359, 930, 908, + 44, 311, 328, 329, 44, 670, 316, 214, 917, 264, + 342, 44, 921, 44, 10, 900, 44, 61, 263, 264, + 797, 228, 799, 267, 44, 451, 348, 10, 61, 358, + 620, 59, 262, 459, 343, 760, 761, 1146, 703, 304, + 59, 264, 767, 768, 264, 268, 269, 91, 292, 293, + 775, 360, 267, 643, 364, 780, 264, 367, 91, 264, + 785, 786, 342, 59, 269, 790, 806, 376, 413, 978, + 267, 91, 417, 798, 887, 343, 59, 387, 343, 964, + 44, 806, 822, 823, 824, 327, 995, 44, 997, 515, + 964, 364, 299, 300, 336, 337, 124, 822, 823, 824, + 690, 308, 364, 310, 363, 44, 267, 1216, 698, 264, + 850, 376, 319, 364, 866, 264, 461, 10, 870, 10, + 866, 339, 788, 339, 849, 850, 327, 1012, 1013, 794, + 44, 292, 293, 478, 479, 336, 337, 482, 10, 287, + 880, 289, 296, 1086, 339, 1054, 339, 327, 263, 264, + 61, 44, 877, 44, 269, 880, 336, 337, 267, 267, + 826, 1093, 887, 370, 1096, 44, 44, 296, 61, 342, + 61, 269, 44, 263, 264, 520, 339, 1086, 523, 647, + 339, 921, 343, 908, 1093, 346, 339, 59, 339, 390, + 264, 1076, 917, 1067, 264, 1069, 921, 1071, 91, 32, + 91, 1094, 91, 364, 411, 305, 413, 414, 305, 1118, + 390, 418, 964, 420, 1123, 1124, 642, 1118, 964, 1104, + 1105, 642, 1123, 1124, 1167, 1093, 44, 44, 1118, 44, + 1139, 340, 340, 1123, 1124, 900, 44, 44, 44, 267, + 61, 831, 32, 909, 451, 58, 1131, 339, 267, 915, + 346, 364, 459, 978, 1094, 995, 1141, 997, 1167, 279, + 44, 264, 340, 263, 292, 293, 264, 857, 613, 695, + 995, 267, 997, 292, 293, 10, 339, 411, 1152, 264, + 1189, 264, 44, 327, 418, 1159, 269, 1172, 271, 364, + 44, 264, 336, 337, 327, 264, 292, 293, 342, 343, + 91, 1186, 647, 336, 337, 264, 264, 327, 515, 44, + 343, 1243, 340, 343, 1054, 343, 336, 337, 346, 1204, + 1205, 1206, 456, 913, 458, 59, 61, 264, 364, 1054, + 675, 44, 677, 44, 760, 761, 364, 44, 10, 684, + 685, 767, 768, 363, 1218, 44, 390, 1012, 44, 775, + 305, 264, 942, 309, 780, 305, 91, 390, 91, 124, + 786, 1086, 44, 44, 790, 44, 10, 44, 0, 790, + 390, 44, 798, 44, 44, 509, 360, 798, 10, 264, + 806, 61, 44, 44, 1258, 364, 1260, 59, 279, 1263, + 380, 381, 382, 383, 44, 267, 822, 823, 824, 1139, + 1152, 746, 340, 1155, 305, 1157, 1152, 1159, 264, 1155, + 1284, 1157, 44, 1159, 1139, 59, 44, 311, 44, 764, + 292, 293, 316, 849, 850, 360, 44, 59, 849, 91, + 44, 44, 14, 309, 327, 642, 327, 782, 327, 1104, + 1105, 91, 1167, 336, 337, 336, 337, 336, 337, 1189, + 343, 877, 343, 41, 880, 44, 877, 351, 352, 41, + 42, 887, 44, 45, 1189, 388, 1131, 49, 50, 51, + 52, 343, 363, 91, 346, 0, 821, 372, 373, 374, + 44, 91, 908, 44, 379, 10, 866, 908, 695, 44, + 44, 917, 364, 387, 389, 921, 44, 390, 305, 390, + 307, 308, 309, 310, 1256, 91, 1258, 1172, 1260, 44, + 1256, 1263, 1258, 44, 1260, 10, 44, 1263, 271, 44, + 102, 305, 346, 307, 308, 309, 310, 364, 873, 10, + 112, 113, 1284, 10, 59, 346, 327, 91, 1284, 1204, + 1205, 1206, 1132, 316, 342, 336, 337, 343, 928, 44, + 364, 91, 978, 760, 761, 58, 264, 978, 903, 346, + 767, 768, 364, 372, 373, 374, 61, 44, 775, 995, + 379, 997, 346, 780, 72, 549, 56, 350, 59, 786, + 389, 354, 355, 790, 61, 515, 113, 1177, 1096, 934, + 6, 798, 327, 604, 327, 267, 91, 757, 916, 806, + 548, 336, 337, 336, 337, 862, 316, 91, 343, 0, + 91, 1201, 1202, 1203, 91, 822, 823, 824, 964, 10, + 292, 293, 10, 267, 334, 335, 760, 761, 1054, 866, + 262, 263, 264, 767, 768, 267, 268, 269, 1157, 271, + 350, 773, 849, 850, 354, 355, 356, 357, 292, 293, + 1155, 307, 308, 44, 310, 390, 44, 400, 14, 631, + 292, 293, 294, 295, 296, 327, 0, 1095, 59, 852, + 877, 59, 1213, 880, 336, 337, 10, 327, 812, 813, + 887, 815, 816, 91, 1243, 1127, 336, 337, 928, 1135, + 272, 273, 274, 275, 1125, 277, 1135, 1186, -1, 343, + -1, 908, 346, 91, -1, -1, -1, 41, 340, 327, + 44, 343, 10, 1139, 921, -1, 298, 327, 336, 337, + 364, 377, 378, -1, 58, 59, 336, 337, 390, 63, + -1, 1111, 364, -1, -1, 372, 373, 262, 263, 264, + 390, 327, 379, 268, 269, -1, 271, 384, -1, -1, + 336, 337, -1, 1133, 1134, 1135, 388, 91, 390, 341, + -1, 59, 91, 1189, 289, 290, 44, 292, 293, 294, + 295, 978, 390, 327, 372, 373, 374, 1157, 10, -1, + 10, 379, 336, 337, 44, -1, 267, 327, 995, -1, + 997, 373, 374, 375, 376, 377, 336, 337, 380, 381, + 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, + 392, 393, 44, 91, 396, 397, 398, 399, 343, -1, + -1, 10, -1, -1, -1, 407, -1, 59, 0, 59, + -1, 91, 327, 415, 10, -1, 390, -1, 10, 364, + -1, 336, 337, 327, 10, -1, 327, 1054, 343, -1, + 327, -1, 336, 337, -1, 336, 337, -1, -1, 336, + 337, 342, -1, 388, -1, 390, 343, -1, 44, -1, + 59, 262, 263, 264, 456, 457, 458, 268, 269, 461, + 271, 14, 372, 373, 374, 61, -1, 59, -1, 379, + -1, 279, 124, 59, -1, 390, 478, 479, -1, -1, + 482, 292, 293, 294, 295, 296, 488, -1, 41, 42, + -1, 44, 45, 390, -1, 91, 49, 50, 51, 52, + 305, -1, 307, 308, 309, 310, 508, 509, 262, 263, + 264, -1, 1139, 267, 268, 269, -1, 271, 520, 327, + -1, 523, -1, 91, -1, -1, 280, 281, 336, 337, + -1, 533, 343, -1, 342, 289, 290, -1, 292, 293, + 294, 295, 296, -1, 262, 263, 264, -1, -1, 102, + 304, 269, 360, 364, -1, 363, -1, -1, -1, 112, + 113, -1, 1189, 317, 318, 319, 320, 321, 322, 323, + 324, 325, 326, 327, 328, 329, 44, 388, 327, 390, + 334, 335, 336, 337, -1, -1, 340, 336, 337, 343, + -1, -1, 346, -1, 348, 10, 350, -1, 352, -1, + 354, 355, 356, 357, 358, 359, 360, -1, 362, -1, + 364, 613, -1, -1, -1, 267, -1, 267, -1, 621, + -1, -1, 376, 91, -1, -1, -1, 10, 305, 327, + 307, 308, 309, 310, 388, -1, 390, -1, 336, 337, + 292, 293, 292, 293, 59, 647, 316, 327, 292, 293, + 294, 295, 296, 262, 263, 264, 336, 337, -1, 268, + 269, 44, 271, 305, 341, 307, 308, -1, 310, -1, + 262, 263, 264, 675, -1, 677, 268, 269, 61, 271, + 350, 267, 684, 685, 354, 355, 356, 357, 340, -1, + 44, 343, 390, 343, 346, 0, 346, -1, 700, 341, + 292, 293, 294, 295, 296, 10, 292, 293, 91, -1, + 390, -1, 364, -1, 364, -1, 372, 373, 374, 272, + 273, 274, 275, 379, 277, 372, 373, 374, -1, -1, + -1, 327, 379, 0, 343, 1106, 41, 91, -1, 44, + 336, 337, -1, 10, 746, 298, -1, 343, -1, -1, + -1, 343, -1, 58, 59, 364, 61, 343, 63, 327, + 346, -1, 764, -1, -1, 1136, 316, -1, 336, 337, + -1, -1, 364, -1, 776, 372, 373, 374, 364, 388, + 782, 390, 379, 785, 334, 335, 91, -1, 341, -1, + -1, -1, 59, -1, 390, -1, 388, -1, 390, -1, + 350, -1, 352, 44, 354, 355, 356, 357, -1, -1, + 812, 813, -1, 815, 816, -1, -1, -1, -1, 821, + 373, 374, 375, 376, 377, -1, -1, 380, 381, 382, + 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, + 393, -1, -1, 396, 397, 398, 399, 10, 0, 10, + 91, -1, 267, -1, 407, -1, -1, -1, 10, 327, + -1, -1, 415, 44, -1, -1, -1, 1238, 336, 337, + 10, 873, -1, 1244, 372, 373, 374, 292, 293, 881, + 1251, 379, -1, 44, -1, -1, -1, -1, 10, 41, + -1, 10, 44, -1, -1, -1, 59, 1268, 59, -1, + -1, 903, -1, 456, 457, 458, -1, 59, 461, -1, + 91, 1282, 15, 16, -1, 917, -1, 10, -1, 59, + -1, -1, 390, -1, 926, 478, 479, -1, 343, 482, + 91, 346, 934, -1, -1, 488, -1, 59, 41, 42, + 59, 44, 45, -1, 327, -1, 49, 50, -1, 52, + 53, 44, -1, 336, 337, 508, 509, 262, 263, 264, + 343, -1, 267, 268, 269, -1, 271, 520, 61, 91, + 523, -1, 91, 327, 279, 280, 281, -1, -1, -1, + 533, -1, 336, 337, 289, 290, -1, 292, 293, 294, + 295, 296, -1, -1, -1, 262, 263, 264, 91, 304, + -1, 268, 269, -1, 271, -1, -1, 390, 111, -1, + 10, 316, 317, 318, 319, 320, 321, 322, 323, 324, + 325, 326, 327, 328, 329, 292, 293, 294, 295, 334, + 335, 336, 337, -1, -1, 340, 390, -1, 343, -1, + -1, 346, -1, 348, 44, 350, -1, 352, -1, 354, + 355, 356, 357, 358, 359, 360, -1, 362, 363, 364, + 613, 61, -1, -1, -1, -1, -1, -1, 621, 10, + -1, 376, -1, -1, -1, -1, 343, -1, -1, -1, + -1, -1, -1, 388, 1086, 390, 327, -1, -1, -1, + -1, 91, -1, -1, 647, 336, 337, 364, 279, 262, + 263, 264, -1, 44, -1, 268, 269, -1, 271, -1, + 262, 263, 264, -1, -1, 267, 268, 269, 279, 271, + 61, 388, 675, 390, 677, -1, -1, 267, 280, 281, + -1, 684, 685, -1, -1, -1, -1, 289, 290, -1, + 292, 293, 294, 295, 296, 267, 327, 700, 267, 390, + 91, -1, 292, 293, -1, 336, 337, 279, -1, -1, + -1, 342, -1, 0, -1, 1167, 327, -1, -1, 272, + 273, 274, 275, 10, 277, 336, 337, -1, -1, -1, + 343, 342, 363, -1, 287, -1, 289, 290, -1, -1, + -1, 343, -1, 746, 346, 298, 348, -1, -1, 360, + -1, 364, 363, 343, 41, 327, 346, 44, 327, 390, + -1, 764, 364, -1, 336, 337, -1, 336, 337, -1, + 342, 58, 59, 776, 61, 388, 63, 390, -1, 782, + -1, -1, 785, -1, 327, -1, 388, -1, 390, -1, + -1, 363, -1, 336, 337, -1, -1, -1, 10, -1, + 343, 10, -1, -1, 91, -1, -1, -1, -1, 812, + 813, -1, 815, 816, -1, -1, -1, 10, 821, -1, + 373, 374, 375, 376, 377, 10, -1, 380, 381, 382, + 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, + 393, 10, -1, 396, 397, 398, 399, 390, -1, -1, + 59, 44, 405, -1, 407, -1, -1, -1, 411, -1, + 413, -1, -1, -1, 417, 418, -1, -1, 61, -1, + 873, -1, -1, -1, 59, 44, -1, 327, 881, -1, + -1, -1, 91, -1, -1, -1, 336, 337, 279, -1, + -1, -1, 61, 343, -1, -1, -1, -1, 91, 10, + 903, 454, -1, 456, 457, 458, 91, 10, 461, 0, + -1, -1, -1, -1, 917, -1, -1, 470, -1, 10, + 10, -1, 91, 926, -1, 478, 479, -1, -1, 482, + -1, 934, -1, 44, -1, 488, 327, -1, -1, -1, + 390, 44, -1, -1, -1, 336, 337, -1, 59, -1, + 41, 342, 343, 44, 44, 508, 509, -1, 61, -1, + -1, -1, 10, -1, -1, 10, -1, 520, 59, -1, + 523, 61, 363, -1, -1, 262, 263, 264, 531, -1, + 267, 268, 269, -1, 271, -1, -1, -1, 91, -1, + -1, -1, -1, 280, 281, -1, 44, -1, -1, 390, + -1, 91, 289, 290, -1, 292, 293, 294, 295, 296, + 44, -1, -1, 61, 59, -1, -1, 304, -1, 262, + 263, 264, -1, -1, -1, 268, 269, 10, 271, 316, + 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, + 327, 328, 329, 91, -1, -1, 91, 334, 335, 336, + 337, -1, 339, 340, -1, -1, 343, 91, 267, 346, + 613, 348, -1, 350, -1, 352, -1, 354, 355, 356, + 357, 358, 359, 360, -1, 362, 59, 364, -1, -1, + -1, -1, 267, 1086, -1, -1, 279, 640, -1, 376, + -1, -1, -1, 305, 647, 307, 308, 309, 310, 311, + 343, 388, -1, 390, 316, -1, -1, -1, 91, -1, + 262, 263, 264, -1, -1, -1, 268, 269, 327, 271, + -1, 364, 675, -1, 677, 0, -1, 336, 337, 341, + -1, 684, 685, -1, 327, 10, -1, 349, 350, 351, + 352, -1, 327, 336, 337, 388, -1, 390, -1, 342, + 343, 336, 337, -1, -1, -1, 267, -1, 327, -1, + -1, 1077, -1, -1, 1167, 1081, 41, 336, 337, 44, + 363, 262, 263, 264, 343, 387, 267, 268, 269, -1, + 271, 292, 293, 58, 59, -1, 61, -1, 63, 280, + 281, 343, -1, 746, -1, -1, -1, 390, 289, 290, + -1, 292, 293, 294, 295, 296, -1, 760, 761, -1, + -1, 764, 364, 304, 767, 768, 91, -1, -1, -1, + -1, 390, 267, 776, 327, 778, -1, 780, -1, 782, + -1, 279, 343, 336, 337, 346, 388, 327, 390, 305, + 343, 307, 308, 309, 310, 279, 336, 337, -1, 340, + -1, -1, 343, 343, -1, 346, -1, 348, -1, 812, + 813, -1, 815, 816, -1, -1, -1, -1, 821, -1, + -1, -1, -1, 364, -1, 341, -1, -1, -1, 327, + 0, -1, 327, 349, 267, 376, -1, 390, 336, 337, + 10, 336, 337, 327, 342, 343, 279, 388, -1, 390, + 390, -1, 336, 337, -1, -1, 1222, -1, 342, 1225, + 1226, -1, -1, 1229, 1230, 363, -1, -1, -1, -1, + 873, 41, -1, -1, 44, -1, -1, -1, 881, 363, + -1, -1, -1, -1, 887, -1, -1, -1, 58, 59, + -1, 61, 390, 63, 327, -1, -1, -1, -1, -1, + 903, -1, -1, 336, 337, -1, 390, -1, -1, 342, + -1, 1277, 1278, 1279, 1280, -1, -1, -1, -1, -1, + -1, 91, 1288, 926, -1, -1, -1, -1, -1, -1, + 363, 934, 257, 258, 259, -1, 261, 262, 263, 264, + 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, + 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, + 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, + 295, 296, -1, 298, -1, -1, 301, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, + 325, 326, 327, 328, 329, 330, 331, 44, -1, 334, + 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, + 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, + 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, + -1, 366, 367, 368, 369, 370, 371, -1, 964, -1, + 375, 376, 377, 378, 91, 380, 381, 382, 383, -1, + 385, 386, 387, 388, -1, 390, -1, -1, 0, -1, + -1, -1, -1, 964, -1, -1, -1, -1, 10, -1, + -1, -1, -1, -1, -1, -1, -1, 257, 258, 259, + 1093, 261, 262, 263, 264, 265, 266, 267, 268, 269, + 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, + 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, + 290, 291, 292, 293, 294, 295, 296, 59, 298, -1, + -1, 301, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, + 330, 331, -1, -1, 334, 335, 336, 337, 338, 339, + 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, + 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, + 360, 361, 362, 363, 364, -1, 366, 367, 368, 369, + 370, 371, 928, -1, 0, 375, 376, 377, 378, -1, + 380, 381, 382, 383, 10, 385, 386, 387, 388, -1, + 390, -1, -1, -1, 305, -1, 307, 308, 309, 310, + 311, -1, -1, -1, -1, 316, 1152, -1, 316, 1155, + -1, 1157, 279, 1159, -1, 41, 304, 305, 44, 307, + 308, 309, 310, 311, -1, -1, 334, 335, 316, -1, + 341, 1152, 58, 59, 1155, 61, -1, 63, 1159, -1, + 351, 352, 350, 331, 352, -1, 354, 355, 356, 357, + -1, -1, 360, 341, 362, -1, 1012, -1, -1, -1, + 327, 349, 350, 351, 352, 91, -1, -1, -1, 336, + 337, -1, -1, -1, -1, 342, 387, -1, -1, -1, + 305, -1, 307, 308, 309, 310, 311, -1, 376, -1, + -1, 316, 1048, -1, -1, -1, 363, -1, -1, 387, + 262, 263, 264, -1, -1, -1, 268, 269, 0, 271, + 1256, -1, 1258, -1, 1260, -1, 341, 1263, 10, -1, + -1, -1, -1, 390, 349, 350, 351, 352, -1, -1, + 292, 293, 294, 295, 296, 1256, -1, 1258, 1284, 1260, + -1, -1, 1263, -1, -1, 1101, -1, -1, -1, 41, + -1, 305, 44, 307, 308, 309, 310, -1, -1, -1, + -1, -1, 387, 1284, -1, -1, 58, 59, -1, 61, + 1126, 63, -1, -1, 316, -1, -1, 1133, 1134, 321, + 322, 343, -1, -1, -1, -1, -1, 341, -1, -1, + -1, -1, 334, 335, -1, 349, -1, -1, -1, 91, + -1, -1, 364, -1, -1, -1, -1, -1, 350, -1, + 352, -1, 354, 355, 356, 357, 358, 359, 360, -1, + 362, -1, -1, -1, -1, -1, 388, -1, 390, 10, -1, 257, 258, 259, -1, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, - 276, 277, 278, 279, 280, 281, -1, 283, 284, 285, + 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, - 296, 297, 91, 299, -1, 59, 302, 303, 304, -1, + 296, -1, 298, -1, -1, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 10, -1, 328, 613, -1, 331, 332, 91, 267, -1, - 267, 337, 338, 339, -1, -1, 342, 10, 344, 345, - 346, 280, 348, 280, 350, -1, 352, -1, 354, -1, - 640, -1, -1, 279, -1, -1, 362, 647, 364, 365, - -1, 367, 368, 369, 370, 371, 372, 267, 658, 59, - 376, 44, 378, 379, -1, 381, 382, 383, 384, -1, - 386, 387, 388, 389, -1, 675, -1, 677, 61, 328, - 267, 328, -1, 267, 684, 685, -1, -1, 337, 338, - 337, 338, 328, -1, 343, 964, 343, -1, 279, 280, - 279, 337, 338, -1, -1, 262, 263, 264, 91, -1, - 267, 268, 269, -1, 271, 364, -1, 364, 328, -1, - -1, -1, 279, -1, 281, 282, 866, 337, 338, -1, - 870, -1, -1, 290, 291, -1, 293, 294, 295, 296, - 297, 328, 0, -1, 328, -1, 746, 328, 305, 328, - 337, 338, 10, 337, 338, -1, 337, 338, 337, 338, - 760, 761, 343, 344, 764, -1, -1, 767, 768, -1, - 279, 280, -1, -1, -1, -1, 776, -1, 778, -1, - 780, -1, 782, 364, 341, -1, 44, 344, -1, -1, - 347, -1, 349, 267, -1, 1064, -1, -1, 1067, -1, - 58, 59, 1071, 61, -1, 63, -1, -1, 365, -1, - -1, -1, 812, 813, -1, 815, 816, -1, -1, 328, - 377, 821, -1, -1, 964, -1, -1, -1, 337, 338, - -1, -1, 389, 91, 343, -1, -1, -1, -1, -1, - -1, 262, 263, 264, -1, -1, -1, 268, 269, 1118, - 271, 1120, 317, 1122, 328, 364, 1125, -1, 279, -1, - -1, -1, -1, 337, 338, -1, -1, 1136, -1, -1, - 335, 336, -1, 873, -1, -1, -1, -1, 0, -1, - 317, 881, -1, -1, -1, -1, 351, 887, 10, -1, - 355, 356, 357, 358, -1, -1, 279, 280, 335, 336, - -1, -1, -1, 903, -1, -1, 306, -1, 308, 309, - 310, 311, 312, -1, 351, -1, 353, 317, 355, 356, - 357, 358, 44, 344, 1064, -1, 926, 1067, 328, 1069, - -1, 1071, 332, -1, 934, -1, 58, 59, 338, 61, - -1, 63, 342, 343, 365, 328, -1, -1, -1, -1, - 350, 351, 352, 353, 337, 338, -1, -1, -1, -1, - -1, 344, -1, -1, -1, -1, -1, -1, 389, 91, - -1, -1, -1, -1, -1, -1, -1, -1, 1118, -1, - 1120, 364, 1122, -1, -1, 1125, -1, -1, 388, -1, - -1, 10, -1, -1, -1, -1, 1136, -1, -1, 257, - 258, 259, -1, 261, 262, 263, 264, 265, 266, 267, - 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, - 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, - 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, - 59, 299, -1, 1043, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, - 328, 329, 330, 331, 332, -1, -1, 335, 336, 337, - 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, - 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, - 358, 359, 360, 361, 362, 363, 364, 365, -1, 367, - 368, 369, 370, 371, 372, -1, -1, 63, 376, 377, - 378, 379, -1, 381, 382, 383, 384, -1, 386, 387, - 388, 389, 44, -1, -1, 257, 258, 259, -1, 261, + 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, + 326, 327, 328, 329, 330, 331, -1, -1, 334, 335, + 336, 337, 338, 94, 340, 341, 342, 343, 344, 345, + 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, + 356, 357, 358, 359, 360, 361, 362, 363, 364, -1, + 366, 367, 368, 369, 370, 371, -1, -1, -1, 375, + 376, 377, 378, -1, 380, 381, 382, 383, 44, 385, + 386, 387, 388, -1, 390, 257, 258, 259, -1, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, - 292, 293, 294, 295, 296, 297, -1, 299, -1, 91, + 292, 293, 294, 295, 296, 91, 298, -1, -1, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, - 332, 44, -1, 335, 336, 337, 338, 339, 340, 341, + -1, -1, 334, 335, 336, 337, 338, -1, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, - 362, 363, 364, 365, -1, 367, 368, 369, 370, 371, - 372, -1, -1, 0, 376, 377, 378, 379, 91, 381, - 382, 383, 384, 10, 386, 387, 388, 389, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 262, - 263, 264, -1, -1, -1, 268, 269, 306, 271, 308, - 309, 310, 311, 312, -1, -1, 279, 44, 317, -1, - -1, -1, 317, -1, -1, -1, -1, -1, -1, 328, - -1, 58, 59, 332, 61, -1, 63, -1, -1, 338, - 335, 336, -1, 342, 343, -1, -1, -1, -1, -1, - -1, 350, 351, 352, 353, -1, 351, -1, 353, -1, - 355, 356, 357, 358, 91, -1, 361, -1, 363, -1, - -1, 297, -1, -1, -1, -1, 1027, -1, -1, -1, - 1031, 344, -1, -1, -1, -1, -1, 279, 280, 388, - -1, 317, 318, 319, 320, 321, 322, 323, 324, 325, - 326, 327, 365, 329, 330, -1, 0, -1, -1, 335, - 336, -1, -1, -1, -1, -1, 10, -1, -1, -1, - -1, -1, -1, -1, -1, 351, 389, 353, -1, 355, - 356, 357, 358, 359, 360, 361, 328, 363, -1, -1, - -1, -1, -1, -1, -1, 337, 338, -1, -1, 1100, - 44, 343, 1103, 1104, -1, -1, 1107, 1108, -1, -1, - -1, -1, -1, -1, 58, 59, 279, 61, 317, 63, - -1, -1, 364, 322, 323, -1, -1, -1, -1, -1, - 1131, 1132, 1133, 1134, -1, -1, 335, 336, -1, 1140, - -1, -1, -1, -1, -1, -1, -1, 91, -1, -1, - -1, -1, 351, -1, 353, -1, 355, 356, 357, 358, - 359, 360, 361, -1, 363, 328, -1, -1, -1, -1, - -1, -1, -1, -1, 337, 338, -1, -1, -1, -1, - 257, 258, 259, -1, 261, 262, 263, 264, 265, 266, - 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, - 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, - 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, - 297, -1, 299, -1, -1, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, - 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, - 327, 328, 329, 330, 331, 332, -1, 63, 335, 336, - 337, 338, 339, -1, 341, 342, 343, 344, 345, 346, - 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, - 357, 358, 359, 360, 361, 362, 363, 364, 365, -1, - 367, 368, 369, 370, 371, 372, -1, -1, 0, 376, - 377, 378, 379, -1, 381, 382, 383, 384, 10, 386, - 387, 388, 389, 257, 258, 259, -1, 261, 262, 263, + 362, 363, 364, -1, 366, 367, 368, 369, 370, 371, + -1, -1, 0, 375, 376, 377, 378, -1, 380, 381, + 382, 383, 10, 385, 386, 387, 388, -1, 390, -1, + -1, -1, -1, -1, 285, 286, 287, 288, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 301, 302, 303, 41, 305, -1, 44, -1, 309, -1, + -1, 312, -1, 305, 315, 307, 308, 309, 310, 311, + 58, 59, -1, 61, 316, 63, -1, -1, -1, 330, + 331, -1, -1, -1, -1, -1, -1, 338, -1, 331, + 341, -1, -1, -1, 345, -1, 347, -1, 349, 341, + -1, -1, -1, 91, -1, -1, -1, 349, 350, 351, + 352, -1, -1, -1, -1, 366, 367, 368, 369, 370, + 371, -1, -1, 279, 375, -1, -1, -1, -1, 380, + 381, 382, 383, -1, 385, 386, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 387, 0, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 10, -1, 285, 286, + 287, 288, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 327, -1, -1, 301, 302, 303, -1, -1, -1, + 336, 337, -1, -1, -1, 312, 342, 41, 315, -1, + 44, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 58, 59, -1, 363, -1, 63, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 390, -1, -1, 91, -1, 366, + 367, 368, 369, 370, 371, -1, -1, -1, 375, -1, + -1, -1, -1, 380, 381, 382, 383, -1, 385, 386, + -1, -1, 10, -1, -1, -1, -1, -1, -1, 257, + 258, 259, -1, 261, 262, 263, 264, 265, 266, 267, + 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, + 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, + 288, 289, 290, 291, 292, 293, 294, 295, 296, -1, + 298, 59, -1, 301, 302, 303, 304, 305, 306, 307, + 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, + 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, + 328, 329, 330, 331, -1, -1, 334, 335, 336, 337, + 338, -1, 340, 341, 342, 343, 344, 345, 346, 347, + 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 360, 361, 362, 363, 364, -1, 366, 367, + 368, 369, 370, 371, -1, -1, -1, 375, 376, 377, + 378, -1, 380, 381, 382, 383, 44, 385, 386, 387, + 388, -1, 390, 257, 258, 259, -1, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, - 294, 295, 296, 297, -1, 299, -1, 59, 302, 303, + 294, 295, 296, 91, 298, -1, -1, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, - 324, 325, 326, 327, 328, 329, 330, 331, 332, 44, - -1, 335, 336, 337, 338, 339, -1, 341, 342, 343, + 324, 325, 326, 327, 328, 329, 330, 331, -1, -1, + 334, 335, 336, 337, 338, -1, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, - 364, 365, -1, 367, 368, 369, 370, 371, 372, -1, - -1, 0, 376, 377, 378, 379, 91, 381, 382, 383, - 384, 10, 386, 387, 388, 389, -1, -1, -1, -1, - -1, -1, -1, -1, 305, 306, -1, 308, 309, 310, - 311, 312, -1, -1, -1, -1, 317, -1, -1, -1, - -1, -1, -1, -1, -1, 44, -1, -1, -1, -1, - -1, 332, -1, -1, -1, -1, -1, -1, -1, 58, - 59, 342, 61, -1, 63, -1, -1, -1, -1, 350, - 351, 352, 353, -1, -1, -1, -1, -1, -1, -1, - -1, 317, 318, 319, 320, 321, 322, 323, 324, 325, - 326, 327, 91, 329, 330, -1, 377, -1, -1, 335, - 336, -1, -1, -1, -1, -1, -1, 388, -1, -1, - -1, -1, -1, -1, -1, 351, -1, 353, -1, 355, - 356, 357, 358, 359, 360, 361, -1, 363, -1, -1, - 262, 263, 264, -1, 0, 267, 268, 269, -1, 271, - -1, -1, -1, -1, 10, -1, -1, 279, -1, 281, - 282, -1, -1, -1, -1, -1, -1, -1, 290, 291, - -1, 293, 294, 295, 296, 297, -1, 317, 318, 319, - 320, 321, 322, 323, 324, 325, 326, 327, 44, -1, - -1, -1, -1, -1, -1, 335, 336, -1, -1, -1, - -1, -1, 58, 59, 279, -1, -1, 63, -1, -1, - -1, 351, -1, 353, -1, 355, 356, 357, 358, 359, - 360, 361, 344, 363, -1, 347, -1, 349, -1, -1, - -1, -1, -1, -1, -1, 91, -1, -1, -1, -1, - -1, -1, -1, 365, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 328, -1, -1, -1, -1, -1, -1, - -1, -1, 337, 338, -1, -1, -1, 389, 257, 258, - 259, -1, 261, 262, 263, 264, 265, 266, 267, 268, - 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, - 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, - 289, 290, 291, 292, 293, 294, 295, 296, 297, -1, - 299, -1, -1, 302, 303, 304, 305, 306, 307, 308, - 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, - 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, - 329, 330, 331, 332, -1, -1, 335, 336, 337, 338, - 339, -1, 341, 342, 343, 344, 345, 346, 347, 348, - 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 360, 361, 362, 363, 364, 365, -1, 367, 368, - 369, 370, 371, 372, -1, -1, 0, 376, 377, 378, - 379, -1, 381, 382, 383, 384, 10, 386, 387, 388, - 389, 257, 258, 259, -1, 261, 262, 263, 264, 265, + 364, -1, 366, 367, 368, 369, 370, 371, -1, 267, + 0, 375, 376, 377, 378, -1, 380, 381, 382, 383, + 10, 385, 386, 387, 388, -1, 390, -1, -1, -1, + -1, -1, -1, -1, 292, 293, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 41, -1, -1, 44, -1, -1, -1, -1, -1, + -1, -1, -1, 305, 306, -1, -1, 309, 58, 59, + -1, 313, 314, 63, 316, 317, 318, 319, 320, 321, + 322, -1, -1, 325, 326, 343, -1, -1, 346, -1, + 332, 333, 334, 335, -1, -1, -1, -1, -1, -1, + 342, 91, -1, -1, -1, -1, -1, 349, 350, -1, + 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, + 362, 279, -1, 365, 316, 317, 318, 319, 320, 321, + 322, 323, 324, 325, 326, -1, -1, -1, -1, -1, + -1, -1, 334, 335, 0, 387, -1, -1, -1, -1, + -1, -1, -1, -1, 10, -1, -1, -1, 350, -1, + 352, -1, 354, 355, 356, 357, 358, 359, 360, 327, + 362, -1, -1, -1, -1, -1, -1, -1, 336, 337, + -1, -1, -1, -1, 342, 41, -1, -1, 44, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 58, 59, -1, 363, -1, 63, 316, 317, + 318, 319, 320, 321, 322, 323, -1, 325, 326, -1, + -1, -1, -1, -1, -1, -1, 334, 335, -1, -1, + -1, -1, 390, -1, -1, 91, -1, -1, -1, -1, + -1, -1, 350, -1, 352, -1, 354, 355, 356, 357, + 358, 359, 360, -1, 362, -1, -1, -1, -1, -1, + 10, -1, -1, -1, -1, -1, -1, 257, 258, 259, + -1, 261, 262, 263, 264, 265, 266, 267, 268, 269, + 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, + 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, + 290, 291, 292, 293, 294, 295, 296, -1, 298, 59, + -1, 301, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, + 330, 331, -1, -1, 334, 335, 336, 337, 338, -1, + 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, + 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, + 360, 361, 362, 363, 364, -1, 366, 367, 368, 369, + 370, 371, -1, -1, -1, 375, 376, 377, 378, -1, + 380, 381, 382, 383, 10, 385, 386, 387, 388, -1, + 390, 257, 258, 259, -1, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, - 296, 297, -1, 299, -1, 59, 302, 303, 304, 305, + 296, -1, 298, 59, -1, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, - 326, 327, 328, 329, 330, 331, 332, -1, -1, 335, - 336, 337, 338, 339, -1, 341, 342, 343, 344, 345, + 326, 327, 328, 329, 330, 331, -1, -1, 334, 335, + 336, 337, 338, -1, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, - 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, - -1, 367, 368, 369, 370, 371, 372, -1, -1, 0, - 376, 377, 378, 379, -1, 381, 382, 383, 384, 10, - 386, 387, 388, 389, -1, -1, -1, -1, -1, 306, - 307, -1, -1, 310, -1, -1, -1, 314, 315, -1, - 317, 318, 319, 320, 321, 322, 323, -1, -1, 326, - 327, -1, -1, 44, -1, -1, 333, 334, 335, 336, - -1, -1, -1, -1, -1, -1, 343, 58, 59, -1, - -1, -1, 63, 350, 351, -1, 353, 354, 355, 356, - 357, 358, 359, 360, 361, 362, 363, -1, -1, 366, + 356, 357, 358, 359, 360, 361, 362, 363, 364, -1, + 366, 367, 368, 369, 370, 371, -1, 267, 0, 375, + 376, 377, 378, -1, 380, 381, 382, 383, 10, 385, + 386, 387, 388, -1, 390, -1, -1, -1, -1, -1, + -1, -1, 292, 293, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 41, + -1, -1, 44, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 305, 306, 58, 59, 309, 61, + -1, 63, 313, 314, -1, 316, 317, 318, 319, 320, + 321, 322, -1, 343, 325, 326, 346, -1, -1, -1, + -1, 332, 333, 334, 335, -1, -1, -1, -1, 91, + -1, 342, -1, -1, -1, -1, -1, -1, 349, 350, + -1, 352, 353, 354, 355, 356, 357, 358, 359, 360, + 361, 362, -1, -1, 365, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 91, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 388, -1, -1, -1, 306, -1, 308, 309, 310, - 311, 312, -1, -1, -1, -1, 317, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 262, 263, - 264, 332, 0, 267, 268, 269, -1, 271, -1, -1, - -1, 342, 10, -1, -1, 279, -1, 281, 282, 350, - 351, 352, 353, -1, -1, -1, 290, 291, -1, 293, - 294, 295, 296, 297, -1, 317, 318, 319, 320, 321, - 322, 323, 324, -1, 326, 327, 44, -1, -1, -1, - -1, -1, -1, 335, 336, -1, -1, 388, -1, -1, - 58, 59, -1, -1, -1, 63, -1, -1, -1, 351, - -1, 353, -1, 355, 356, 357, 358, 359, 360, 361, - 344, 363, -1, 347, -1, 349, -1, -1, -1, -1, + -1, 267, 0, -1, -1, -1, 387, -1, -1, -1, + -1, -1, 10, 316, 317, 318, 319, 320, 321, 322, + -1, -1, 325, 326, -1, -1, 292, 293, -1, -1, + -1, 334, 335, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 41, -1, -1, 44, 350, -1, 352, + -1, 354, 355, 356, 357, 358, 359, 360, -1, 362, + -1, 59, -1, -1, -1, 63, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 343, -1, -1, + 346, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 91, -1, -1, -1, -1, -1, -1, - -1, 365, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 389, 257, 258, 259, -1, - 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, - 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, - 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, - 291, 292, 293, 294, 295, 296, 297, -1, 299, -1, - -1, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, - 331, 332, -1, -1, 335, 336, 337, 338, 339, -1, - 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, - 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, - 361, 362, 363, 364, 365, -1, 367, 368, 369, 370, - 371, 372, -1, -1, 0, 376, 377, 378, 379, -1, - 381, 382, 383, 384, 10, 386, 387, 388, 389, 257, + -1, -1, -1, -1, -1, -1, 10, -1, -1, 10, + -1, -1, -1, -1, -1, 257, 258, 259, -1, 261, + 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, + 272, 273, 274, 275, 276, 277, 278, -1, 280, 281, + 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, + 292, 293, 294, 295, 296, 59, 298, -1, 59, 301, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, + 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, + 91, -1, 334, 335, 336, 337, 338, -1, 340, 341, + 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, + 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, + 362, -1, 364, -1, 366, 367, 368, 369, 370, 371, + -1, -1, -1, 375, 376, 377, 378, -1, 380, 381, + 382, 383, -1, 385, 386, 387, 388, -1, 390, 257, 258, 259, -1, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, - 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, - -1, 299, -1, 59, 302, 303, 304, 305, 306, 307, + 288, 289, 290, 291, 292, 293, 294, 295, 296, -1, + 298, -1, -1, 301, 302, 303, -1, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, - 328, 329, 330, 331, 332, -1, -1, 335, 336, 337, - 338, 339, -1, 341, 342, 343, 344, 345, 346, 347, + 328, 329, 330, 331, 0, -1, 334, 335, 336, 337, + 338, -1, 340, 341, 10, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, - 358, 359, 360, 361, 362, 363, 364, 365, -1, 367, - 368, 369, 370, 371, 372, -1, -1, 0, 376, 377, - 378, 379, -1, 381, 382, 383, 384, 10, 386, 387, - 388, 389, -1, -1, -1, -1, -1, 306, 307, -1, - -1, 310, -1, -1, -1, 314, 315, -1, 317, 318, - 319, 320, 321, 322, 323, -1, -1, 326, 327, -1, - -1, 44, -1, -1, 333, 334, 335, 336, -1, -1, - -1, -1, -1, -1, 343, 58, 59, -1, 61, -1, - 63, 350, 351, -1, 353, 354, 355, 356, 357, 358, - 359, 360, 361, 362, 363, -1, -1, 366, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 91, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 388, - -1, -1, -1, 306, -1, 308, 309, 310, 311, 312, - -1, -1, -1, -1, 317, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 262, 263, 264, -1, - 0, 267, 268, 269, -1, 271, -1, -1, -1, 342, - 10, -1, -1, 279, -1, 281, 282, 350, 351, 352, - 353, -1, -1, -1, 290, 291, -1, 293, 294, 295, - 296, 297, -1, 317, 318, 319, 320, 321, 322, 323, - -1, -1, 326, 327, 44, -1, -1, -1, -1, -1, - -1, 335, 336, -1, -1, 388, -1, -1, -1, 59, - -1, -1, -1, 63, -1, -1, -1, 351, -1, 353, - -1, 355, 356, 357, 358, 359, 360, 361, 344, 363, - -1, 347, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 91, -1, -1, -1, -1, -1, -1, -1, 365, + 358, 359, 360, 361, 362, 363, 364, -1, 366, 367, + 368, 369, 370, 371, -1, 41, 267, 375, 44, 377, + 378, -1, 380, 381, 382, 383, -1, 385, 386, 387, + 388, -1, 390, 59, -1, -1, -1, 63, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 10, -1, -1, -1, - -1, -1, -1, 389, 257, 258, 259, -1, 261, 262, - 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, - 273, 274, 275, 276, 277, 278, 279, -1, 281, 282, - 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, - 293, 294, 295, 296, 297, 59, 299, -1, -1, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, - 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, - -1, -1, 335, 336, 337, 338, 339, -1, 341, 342, - 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, - 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, - 363, -1, 365, -1, 367, 368, 369, 370, 371, 372, - -1, -1, -1, 376, 377, 378, 379, -1, 381, 382, - 383, 384, -1, 386, 387, 388, 389, 257, 258, 259, - -1, 261, 262, 263, 264, 265, 266, 267, 268, 269, + -1, 305, -1, 307, 308, 309, 310, 311, -1, -1, + -1, -1, 316, -1, -1, 91, -1, -1, -1, -1, + -1, -1, -1, 327, -1, -1, 327, 331, -1, -1, + -1, -1, -1, 337, -1, 336, 337, 341, 342, -1, + -1, -1, -1, -1, -1, 349, 350, 351, 352, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 10, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 305, 306, -1, 387, 309, -1, -1, -1, 313, 314, + -1, 316, 317, 318, 319, 320, 321, 322, -1, 41, + 325, 326, 44, -1, -1, -1, -1, 332, 333, 334, + 335, -1, -1, -1, -1, -1, -1, 59, -1, -1, + -1, 63, -1, -1, 349, 350, -1, 352, 353, 354, + 355, 356, 357, 358, 359, 360, 361, 362, -1, -1, + 365, -1, -1, -1, -1, -1, -1, -1, -1, 91, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 387, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 10, -1, 10, 10, -1, -1, -1, -1, + -1, 257, 258, 259, -1, 261, 262, 263, 264, 265, + 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, + 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, + 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, + 296, 59, 298, 59, 59, 301, 302, 303, -1, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, + 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, + 326, 327, 328, 329, 330, 331, 91, -1, 334, 335, + 336, 337, 338, -1, 340, 341, -1, 343, 344, 345, + 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, + 356, 357, 358, 359, 360, 361, 362, 363, 364, -1, + 366, 367, 368, 369, 370, 371, -1, -1, -1, 375, + -1, 377, 378, -1, 380, 381, 382, 383, 10, 385, + 386, 387, 388, -1, 390, 257, 258, 259, -1, 261, + 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, + 272, 273, 274, 275, 276, 277, 278, -1, 280, 281, + 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, + 292, 293, 294, 295, 296, -1, 298, 59, -1, 301, + 302, 303, -1, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, + 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, + 0, -1, 334, 335, 336, 337, 338, -1, 340, 341, + 10, 343, 344, 345, 346, 347, 348, 349, 350, 351, + 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, + 362, -1, 364, -1, 366, 367, 368, 369, 370, 371, + -1, 267, 267, 375, 44, 377, 378, -1, 380, 381, + 382, 383, -1, 385, 386, 387, 388, -1, 390, 59, + -1, 61, -1, 63, -1, -1, 292, 293, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 305, -1, 307, + 308, 309, 310, 311, -1, -1, -1, -1, 316, -1, + -1, 91, -1, -1, -1, -1, -1, -1, -1, 327, + -1, -1, 327, 331, -1, -1, -1, -1, -1, 337, + -1, 336, 337, 341, 342, -1, -1, 343, -1, -1, + 346, 349, 350, 351, 352, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 0, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 10, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 387, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 267, -1, -1, 44, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 59, -1, 61, -1, 63, -1, -1, + 292, 293, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 10, -1, + -1, -1, -1, -1, -1, 91, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 343, 44, -1, 346, -1, -1, 257, 258, 259, + -1, 261, 262, 263, 264, 265, 266, 59, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, - 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, - 290, 291, 292, 293, 294, 295, 296, 297, -1, 299, - -1, -1, 302, 303, 304, -1, 306, 307, 308, 309, + -1, -1, 282, 283, 284, 285, 286, 287, 288, 289, + 290, 291, 292, 293, 294, 295, 296, 10, 298, 91, + -1, 301, 302, 303, -1, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, - 330, 331, 332, 0, -1, 335, 336, 337, 338, 339, - -1, 341, 342, 10, 344, 345, 346, 347, 348, 349, + 330, 331, -1, -1, 334, 335, 336, 337, 338, 339, + -1, 341, 342, 343, 344, 345, 59, 347, 10, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, - 360, 361, 362, 363, 364, 365, -1, 367, 368, 369, - 370, 371, 372, -1, -1, -1, 376, 44, 378, 379, - -1, 381, 382, 383, 384, -1, 386, 387, 388, 389, - -1, -1, 59, -1, -1, -1, 63, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 306, -1, 308, 309, 310, 311, 312, -1, - -1, -1, -1, 317, 91, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 328, -1, -1, -1, 332, -1, - -1, -1, -1, -1, 338, -1, -1, -1, 342, 343, - -1, -1, -1, -1, -1, -1, 350, 351, 352, 353, - -1, -1, -1, -1, -1, -1, 0, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 10, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 306, 307, -1, - -1, 310, -1, -1, 388, 314, 315, -1, 317, 318, - 319, 320, 321, 322, 323, -1, -1, 326, 327, -1, - 44, -1, -1, -1, 333, 334, 335, 336, -1, -1, - -1, -1, -1, -1, 343, 59, -1, -1, -1, 63, - -1, 350, 351, -1, 353, 354, 355, 356, 357, 358, - 359, 360, 361, 362, 363, -1, -1, 366, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 91, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 388, + 360, 361, 362, 363, 364, -1, 366, 367, 368, 369, + 370, 371, -1, -1, -1, 375, -1, 377, 378, -1, + 380, 381, 382, 383, -1, 385, 386, 387, 388, -1, + 390, 257, 258, 259, -1, 261, 262, 263, 264, 265, + 266, 63, 268, 269, 270, 271, 272, 273, 274, 275, + 276, 277, 278, 279, -1, -1, 282, 283, 284, 285, + 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, + 296, -1, 298, -1, -1, 301, 302, 303, -1, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, + 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, + 326, 327, 328, 329, 330, 331, -1, -1, 334, 335, + 336, 337, 338, 339, -1, 341, 342, 343, 344, 345, + -1, 347, -1, 349, 350, 351, 352, 353, 354, 355, + 356, 357, 358, 359, 360, 361, 362, 363, 364, -1, + 366, 367, 368, 369, 370, 371, -1, -1, 0, 375, + -1, 377, 378, -1, 380, 381, 382, 383, 10, 385, + 386, 387, 388, -1, 390, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 327, -1, -1, -1, -1, + -1, -1, -1, -1, 336, 337, -1, -1, -1, -1, + 342, -1, 44, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 59, 360, 61, + -1, 63, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 10, -1, -1, -1, -1, -1, -1, -1, - 257, 258, 259, -1, 261, 262, 263, 264, 265, 266, - 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, - 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, - 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, - 297, 59, 299, -1, -1, 302, 303, 304, -1, 306, - 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, - 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, - 327, 328, 329, 330, 331, 332, -1, -1, 335, 336, - 337, 338, 339, -1, 341, 342, -1, 344, 345, 346, - 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, - 357, 358, 359, 360, 361, 362, 363, 364, 365, -1, - 367, 368, 369, 370, 371, 372, -1, -1, -1, 376, - -1, 378, 379, -1, 381, 382, 383, 384, -1, 386, - 387, 388, 389, 257, 258, 259, -1, 261, 262, 263, - 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, - 274, 275, 276, 277, 278, 279, -1, 281, 282, 283, - 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, - 294, 295, 296, 297, -1, 299, -1, -1, 302, 303, - 304, -1, 306, 307, 308, 309, 310, 311, 312, 313, - 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, - 324, 325, 326, 327, 328, 329, 330, 331, 332, 0, - -1, 335, 336, 337, 338, 339, -1, 341, 342, 10, - 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, - -1, 365, -1, 367, 368, 369, 370, 371, 372, -1, - -1, -1, 376, 44, 378, 379, -1, 381, 382, 383, - 384, -1, 386, 387, 388, 389, -1, -1, 59, -1, - 61, -1, 63, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 306, -1, - 308, 309, 310, 311, 312, -1, -1, -1, -1, 317, - 91, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 328, -1, -1, -1, 332, -1, -1, -1, -1, -1, - 338, -1, -1, -1, 342, 343, -1, -1, -1, -1, - -1, -1, 350, 351, 352, 353, -1, -1, -1, -1, + -1, -1, 305, -1, 307, 308, 309, 310, 311, 91, + -1, -1, -1, 316, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 327, -1, -1, -1, 331, -1, + -1, -1, -1, -1, 337, -1, -1, -1, 341, 342, + -1, -1, -1, -1, -1, -1, 349, 350, 351, 352, -1, -1, 0, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 10, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 306, 307, -1, -1, 310, -1, -1, - 388, 314, 315, -1, 317, 318, 319, 320, 321, 322, - 323, -1, -1, 326, 327, -1, 44, -1, -1, -1, - 333, 334, 335, 336, -1, -1, -1, -1, -1, -1, - 343, 59, -1, 61, -1, 63, -1, 350, 351, -1, - 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, - 363, -1, -1, 366, -1, -1, -1, -1, -1, -1, + -1, -1, 10, -1, 316, 317, 318, 319, 320, 321, + 322, 323, 324, 325, 326, -1, 328, 329, -1, -1, + -1, -1, 334, 335, 387, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 44, -1, 350, -1, + 352, -1, 354, 355, 356, 357, 358, 359, 360, -1, + 362, 59, -1, 61, -1, 63, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 91, -1, -1, -1, -1, -1, -1, - -1, 10, -1, -1, -1, 388, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 257, 258, 259, -1, - 261, 262, 263, 264, 265, 266, -1, 268, 269, 270, - 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, - 59, -1, 283, 284, 285, 286, 287, 288, 289, 290, - 291, 292, 293, 294, 295, 296, 297, -1, 299, -1, - -1, 302, 303, 304, -1, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, - 331, 332, -1, -1, 335, 336, 337, 338, 339, 340, - -1, 342, 343, 344, 345, 346, -1, 348, -1, 350, - 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, - 361, 362, 363, 364, 365, -1, 367, 368, 369, 370, - 371, 372, -1, -1, 0, 376, -1, 378, 379, -1, - 381, 382, 383, 384, 10, 386, 387, 388, 389, 257, - 258, 259, -1, 261, 262, 263, 264, 265, 266, -1, - 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, - 278, 279, 280, -1, -1, 283, 284, 285, 286, 287, - 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, - -1, 299, -1, 59, 302, 303, 304, -1, 306, 307, - 308, 309, 310, 311, 312, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 257, 258, 259, -1, 261, + 262, 263, 264, 265, 266, -1, 268, 269, 270, 271, + 272, 273, 274, 275, 276, 277, 278, 279, -1, -1, + 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, + 292, 293, 294, 295, 296, 10, 298, 10, -1, 301, + 302, 303, -1, 305, 306, 307, 308, }; } private static final short[] yyCheck2() { return new short[] { - 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, - 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, - -1, -1, 335, 336, 337, 338, 339, 340, -1, 342, - 343, 344, 345, 346, -1, 348, -1, 350, 351, 352, - 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, - 363, 364, 365, -1, 367, 368, 369, 370, 371, 372, - -1, -1, 0, 376, -1, 378, 379, -1, 381, 382, - 383, 384, 10, 386, 387, 388, 389, -1, -1, -1, - -1, -1, 306, -1, 308, 309, 310, 311, 312, -1, - -1, -1, -1, 317, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 328, -1, 44, -1, 332, -1, - -1, -1, -1, -1, 338, -1, -1, -1, 342, 343, - -1, 59, -1, 61, -1, 63, 350, 351, 352, 353, - 306, 307, -1, -1, 310, -1, -1, -1, 314, 315, - -1, 317, 318, 319, 320, 321, 322, 323, -1, -1, - 326, 327, -1, 91, -1, -1, -1, 333, 334, 335, - 336, -1, -1, -1, 388, -1, -1, 343, -1, -1, - -1, -1, -1, -1, 350, 351, -1, 353, 354, 355, - 356, 357, 358, 359, 360, 361, 362, 363, -1, -1, - 366, 262, 263, 264, -1, 0, 267, 268, 269, -1, - 271, -1, -1, -1, -1, 10, -1, -1, 279, -1, - 281, 282, 388, -1, -1, -1, -1, -1, -1, 290, - 291, -1, 293, 294, 295, 296, 297, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 44, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 59, -1, 61, -1, 63, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 344, -1, -1, 347, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 91, -1, -1, -1, - -1, -1, -1, -1, 365, 10, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 389, 257, - 258, 259, -1, 261, 262, 263, 264, 265, 266, -1, - 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, - 278, 279, 280, 10, 59, 283, 284, 285, 286, 287, - 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, - -1, 299, -1, -1, 302, 303, 304, -1, 306, 307, - 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, - 328, 329, 330, 331, 332, -1, 63, 335, 336, 337, - 338, 339, -1, -1, 342, 343, 344, 345, 346, -1, - 348, -1, 350, 351, 352, 353, 354, 355, 356, 357, - 358, 359, 360, 361, 362, 363, 364, 365, -1, 367, - 368, 369, 370, 371, 372, -1, -1, 0, 376, -1, - 378, 379, -1, 381, 382, 383, 384, 10, 386, 387, - 388, 389, 257, 258, 259, -1, 261, 262, 263, 264, + 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, + 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, + 329, 330, 331, -1, 44, 334, 335, 336, 337, 338, + -1, -1, 341, 342, 343, 344, 345, 59, 347, 59, + 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, + 359, 360, 361, 362, 363, 364, -1, 366, 367, 368, + 369, 370, 371, -1, -1, -1, 375, -1, 377, 378, + -1, 380, 381, 382, 383, 10, 385, 386, 387, 388, + -1, 390, 257, 258, 259, -1, 261, 262, 263, 264, 265, 266, -1, 268, 269, 270, 271, 272, 273, 274, - 275, 276, 277, 278, 279, 280, -1, -1, 283, 284, + 275, 276, 277, 278, 279, -1, -1, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, - 295, 296, 297, -1, 299, -1, 59, 302, 303, 304, - -1, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 295, 296, -1, 298, 59, -1, 301, 302, 303, -1, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, - 325, 326, 327, 328, 329, 330, 331, 332, -1, -1, - 335, 336, 337, 338, 339, -1, -1, 342, 343, 344, - 345, 346, -1, 348, -1, 350, 351, 352, 353, 354, + 325, 326, 327, 328, 329, 330, 331, -1, -1, 334, + 335, 336, 337, 338, -1, -1, 341, 342, 343, 344, + 345, -1, 347, -1, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, - 365, -1, 367, 368, 369, 370, 371, 372, -1, -1, - 0, 376, -1, 378, 379, -1, 381, 382, 383, 384, - 10, 386, 387, 388, 389, -1, -1, -1, -1, -1, - -1, 306, -1, 308, 309, 310, 311, 312, -1, -1, - -1, -1, 317, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 328, 44, -1, -1, 332, -1, -1, - -1, -1, -1, 338, -1, -1, -1, 342, 343, 59, - -1, 61, -1, 63, -1, 350, 351, 352, 353, -1, + -1, 366, 367, 368, 369, 370, 371, -1, -1, 0, + 375, -1, 377, 378, -1, 380, 381, 382, 383, 10, + 385, 386, 387, 388, -1, 390, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, - 327, 91, 329, 330, -1, -1, -1, -1, 335, 336, - -1, -1, -1, 388, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 351, -1, 353, -1, 355, 356, - 357, 358, 359, 360, 361, -1, 363, -1, -1, 262, - 263, 264, -1, 0, 267, 268, 269, -1, 271, -1, - -1, -1, -1, 10, -1, -1, 279, -1, 281, 282, - -1, -1, -1, -1, -1, -1, -1, 290, 291, -1, - 293, 294, 295, 296, 297, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 44, -1, -1, -1, 267, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 59, -1, + 61, -1, 63, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 292, 293, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 305, -1, 307, 308, 309, 310, 311, + 91, -1, -1, -1, 316, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 327, -1, -1, -1, 331, + -1, -1, -1, -1, -1, 337, -1, -1, -1, 341, + 342, -1, -1, 343, -1, -1, 346, 349, 350, 351, + 352, -1, 267, 0, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 10, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 292, 293, -1, + -1, -1, -1, -1, -1, 387, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 44, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 59, -1, 61, -1, 63, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 344, -1, -1, 347, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 343, -1, + -1, 346, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 91, -1, -1, -1, -1, -1, - -1, -1, 365, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 389, 257, 258, 259, - -1, 261, 262, 263, 264, 265, 266, -1, 268, 269, - 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, - 280, -1, 59, 283, 284, 285, 286, 287, 288, 289, - 290, 291, 292, 293, 294, 295, 296, 297, -1, 299, - -1, -1, 302, 303, 304, -1, 306, 307, 308, 309, - 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, - 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, - 330, 331, 332, -1, -1, 335, 336, 337, 338, 339, - -1, -1, 342, 343, 344, 345, 346, -1, 348, -1, - 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, - 360, 361, 362, 363, 364, 365, -1, 367, 368, 369, - 370, 371, 372, -1, -1, 0, 376, -1, 378, 379, - -1, 381, 382, 383, 384, 10, 386, 387, 388, 389, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 257, 258, 259, -1, + 261, 262, 263, 264, 265, 266, -1, 268, 269, 270, + 271, 272, 273, 274, 275, 276, 277, 278, 279, -1, + -1, 282, 283, 284, 285, 286, 287, 288, 289, 290, + 291, 292, 293, 294, 295, 296, 10, 298, 10, -1, + 301, 302, 303, -1, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, + 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, + 331, -1, 44, 334, 335, 336, 337, 338, -1, -1, + 341, 342, 343, 344, 345, 59, 347, 59, 349, 350, + 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, + 361, 362, 363, 364, -1, 366, 367, 368, 369, 370, + 371, -1, -1, -1, 375, -1, 377, 378, -1, 380, + 381, 382, 383, -1, 385, 386, 387, 388, -1, 390, 257, 258, 259, -1, 261, 262, 263, 264, 265, 266, - -1, 268, 269, 270, 271, 272, 273, 274, 275, 276, - 277, 278, 279, 280, -1, -1, 283, 284, 285, 286, + 63, 268, 269, 270, 271, 272, 273, 274, 275, 276, + 277, 278, 279, -1, -1, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, - 297, -1, 299, -1, 59, 302, 303, 304, -1, 306, + -1, 298, -1, -1, 301, 302, 303, -1, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, - 327, 328, 329, 330, 331, 332, -1, -1, 335, 336, - 337, 338, 339, -1, -1, 342, 343, 344, 345, 346, - -1, 348, -1, 350, 351, 352, 353, 354, 355, 356, - 357, 358, 359, 360, 361, 362, 363, 364, 365, -1, - 367, 368, 369, 370, 371, 372, -1, -1, 0, 376, - -1, 378, 379, -1, 381, 382, 383, 384, 10, 386, - 387, 388, 389, -1, -1, -1, -1, -1, -1, 306, - -1, 308, 309, 310, 311, 312, -1, -1, -1, -1, - 317, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 328, 44, -1, -1, 332, -1, -1, -1, -1, - -1, 338, -1, -1, -1, 342, 343, 59, -1, 61, - -1, 63, -1, 350, 351, 352, 353, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 91, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 388, -1, -1, -1, -1, -1, -1, -1, -1, + 327, 328, 329, 330, 331, -1, -1, 334, 335, 336, + 337, 338, -1, -1, 341, 342, 343, 344, 345, -1, + 347, -1, 349, 350, 351, 352, 353, 354, 355, 356, + 357, 358, 359, 360, 361, 362, 363, 364, -1, 366, + 367, 368, 369, 370, 371, -1, -1, 0, 375, -1, + 377, 378, -1, 380, 381, 382, 383, 10, 385, 386, + 387, 388, -1, 390, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 262, 263, 264, - -1, 0, 267, 268, 269, -1, 271, -1, -1, -1, - -1, 10, -1, -1, 279, -1, 281, -1, -1, -1, - -1, -1, -1, -1, -1, 290, 291, -1, 293, 294, - 295, 296, 297, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 44, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 44, -1, -1, -1, 267, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 59, -1, 61, -1, + 63, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 292, 293, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 305, -1, 307, 308, 309, 310, 311, 91, -1, + -1, -1, 316, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 327, -1, -1, -1, 331, -1, -1, + -1, -1, -1, 337, -1, -1, -1, 341, 342, -1, + -1, 343, -1, 296, 346, 349, 350, 351, 352, -1, + -1, 0, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 10, -1, 316, 317, 318, 319, 320, 321, 322, + 323, 324, 325, 326, -1, 328, 329, -1, -1, -1, + -1, 334, 335, 387, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 44, -1, 350, -1, 352, + -1, 354, 355, 356, 357, 358, 359, 360, -1, 362, 59, -1, 61, -1, 63, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 344, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 91, -1, -1, -1, -1, -1, -1, -1, - 365, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 389, 257, 258, 259, -1, 261, - 262, 263, 264, 265, 266, -1, 268, 269, 270, 271, - 272, 273, 274, 275, 276, 277, 278, 279, 280, -1, - 59, 283, 284, 285, 286, 287, 288, 289, 290, 291, - 292, 293, 294, 295, 296, 297, -1, 299, -1, -1, - 302, 303, 304, -1, 306, 307, 308, 309, 310, 311, - 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, - 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, - 332, -1, -1, 335, 336, 337, 338, 339, -1, -1, - 342, 343, 344, 345, 346, -1, 348, -1, 350, 351, - 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, - 362, 363, 364, 365, -1, 367, 368, 369, 370, 371, - 372, -1, -1, 0, 376, -1, 378, 379, -1, 381, - 382, 383, 384, 10, 386, 387, 388, 389, 257, 258, - 259, -1, 261, 262, 263, 264, 265, 266, -1, 268, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 257, 258, 259, -1, 261, 262, + 263, 264, 265, 266, -1, 268, 269, 270, 271, 272, + 273, 274, 275, 276, 277, 278, 279, -1, -1, 282, + 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, + 293, 294, 295, 296, 10, 298, -1, -1, 301, 302, + 303, -1, 305, 306, 307, 308, 309, 310, 311, 312, + 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, + 323, 324, 325, 326, 327, 328, 329, 330, 331, -1, + -1, 334, 335, 336, 337, 338, -1, -1, 341, 342, + 343, 344, 345, 59, 347, -1, 349, 350, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, + 363, 364, -1, 366, 367, 368, 369, 370, 371, -1, + -1, -1, 375, -1, 377, 378, -1, 380, 381, 382, + 383, -1, 385, 386, 387, 388, -1, 390, 257, 258, + 259, -1, 261, 262, 263, 264, 265, 266, 63, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, - 279, 280, -1, -1, 283, 284, 285, 286, 287, 288, - 289, 290, 291, 292, 293, 294, 295, 296, 297, -1, - 299, -1, 59, 302, 303, 304, -1, 306, 307, 308, + 279, -1, -1, 282, 283, 284, 285, 286, 287, 288, + 289, 290, 291, 292, 293, 294, 295, 296, -1, 298, + -1, -1, 301, 302, 303, -1, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, - 329, 330, 331, 332, -1, -1, 335, 336, 337, 338, - 339, -1, -1, 342, 343, 344, 345, 346, -1, 348, - -1, 350, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 360, 361, 362, 363, 364, 365, -1, 367, 368, - 369, 370, 371, 372, -1, -1, 0, 376, -1, 378, - 379, -1, 381, 382, 383, 384, 10, 386, 387, 388, - 389, -1, -1, -1, -1, -1, -1, 306, -1, 308, - 309, 310, 311, 312, -1, -1, -1, -1, 317, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 328, - 44, -1, -1, 332, -1, -1, -1, -1, -1, 338, - -1, -1, -1, 342, 343, 59, -1, 61, -1, 63, - -1, 350, 351, 352, 353, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 91, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 388, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 262, 263, 264, -1, 0, - 267, 268, 269, -1, 271, -1, -1, -1, -1, 10, - -1, -1, 279, -1, 281, -1, -1, -1, -1, -1, - -1, -1, -1, 290, 291, -1, 293, 294, 295, 296, - 297, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 44, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 59, -1, + 329, 330, 331, -1, -1, 334, 335, 336, 337, 338, + -1, -1, 341, 342, 343, 344, 345, -1, 347, -1, + 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, + 359, 360, 361, 362, 363, 364, -1, 366, 367, 368, + 369, 370, 371, -1, -1, 0, 375, -1, 377, 378, + -1, 380, 381, 382, 383, 10, 385, 386, 387, 388, + -1, 390, -1, -1, -1, 305, 306, -1, -1, 309, + -1, -1, -1, 313, 314, -1, 316, 317, 318, 319, + 320, 321, 322, -1, -1, 325, 326, -1, -1, 44, + -1, -1, 332, 333, 334, 335, -1, -1, -1, -1, + -1, -1, 342, -1, 59, -1, 61, -1, 63, 349, + 350, -1, 352, 353, 354, 355, 356, 357, 358, 359, + 360, 361, 362, -1, -1, 365, -1, -1, -1, 305, + -1, 307, 308, 309, 310, 311, 91, -1, -1, -1, + 316, -1, -1, -1, -1, -1, -1, 387, -1, -1, + -1, 327, -1, -1, -1, 331, -1, -1, -1, -1, + -1, 337, -1, -1, -1, 341, 342, -1, -1, -1, + -1, -1, -1, 349, 350, 351, 352, -1, -1, 0, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 10, + -1, 316, 317, 318, 319, 320, 321, 322, 323, 324, + 325, 326, -1, 328, 329, -1, -1, -1, -1, 334, + 335, 387, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 44, -1, 350, -1, 352, -1, 354, + 355, 356, 357, 358, 359, 360, -1, 362, 59, -1, 61, -1, 63, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 344, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 91, -1, -1, -1, -1, -1, -1, 10, 365, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 91, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 389, 257, 258, 259, -1, 261, 262, 263, - 264, 265, 266, -1, 268, 269, 270, 271, 272, 273, - 274, 275, 276, 277, 278, 279, 59, -1, -1, 283, - 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, - 294, 295, 296, 297, -1, 299, -1, -1, 302, 303, - 304, -1, 306, 307, 308, 309, 310, 311, 312, 313, - 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, - 324, 325, 326, 327, 328, 329, 330, 331, 332, -1, - -1, 335, 336, 337, 338, 339, -1, -1, 342, 343, - 344, 345, 346, -1, 348, -1, 350, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, - -1, 365, -1, 367, 368, 369, 370, 371, 372, -1, - -1, -1, 376, -1, 378, 379, -1, 381, 382, 383, - 384, -1, 386, 387, 388, 389, 257, 258, 259, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 257, 258, 259, -1, 261, 262, 263, 264, + 265, 266, -1, 268, 269, 270, 271, 272, 273, 274, + 275, 276, 277, 278, -1, -1, -1, 282, 283, 284, + 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, + 295, 296, -1, 298, -1, -1, 301, 302, 303, -1, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, + 325, 326, 327, 328, 329, 330, 331, -1, -1, 334, + 335, 336, 337, 338, -1, -1, 341, 342, 343, 344, + 345, -1, 347, -1, 349, 350, 351, 352, 353, 354, + 355, 356, 357, 358, 359, 360, 361, 362, -1, 364, + -1, 366, 367, 368, 369, 370, 371, -1, -1, 0, + 375, -1, 377, 378, -1, 380, 381, 382, 383, 10, + 385, 386, 387, 388, -1, 390, 257, 258, 259, -1, 261, 262, 263, 264, 265, 266, -1, 268, 269, 270, - 271, 272, 273, 274, 275, 276, 277, 278, 279, -1, - -1, -1, 283, 284, 285, 286, 287, 288, 289, 290, - 291, 292, 293, 294, 295, 296, 297, -1, 299, -1, - -1, 302, 303, 304, -1, 306, 307, 308, 309, 310, + 271, 272, 273, 274, 275, 276, 277, 278, -1, -1, + 41, 282, 283, 284, 285, 286, 287, 288, 289, 290, + 291, 292, 293, 294, 295, 296, -1, 298, 59, -1, + 301, 302, 303, -1, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, - 331, 332, -1, -1, 335, 336, 337, 338, 339, -1, - -1, 342, 343, 344, 345, 346, -1, 348, -1, 350, + 331, -1, -1, 334, 335, 336, 337, 338, -1, -1, + 341, 342, 343, 344, 345, -1, 347, -1, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, - 361, 362, 363, 0, 365, -1, 367, 368, 369, 370, - 371, 372, -1, 10, -1, 376, -1, 378, 379, -1, - 381, 382, 383, 384, -1, 386, 387, 388, 389, -1, - -1, -1, -1, 306, -1, 308, 309, 310, 311, 312, - -1, -1, -1, -1, 317, -1, -1, 44, -1, -1, - -1, -1, -1, -1, 10, -1, -1, -1, -1, 332, - -1, 58, 59, -1, 61, -1, 63, -1, -1, 342, - -1, -1, -1, -1, -1, -1, -1, 350, 351, 352, - 353, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 10, -1, 91, -1, -1, -1, -1, -1, - -1, -1, -1, 59, -1, -1, -1, 0, -1, -1, - -1, -1, -1, -1, -1, 388, -1, 10, -1, -1, - -1, -1, 10, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 91, -1, -1, -1, -1, - -1, 59, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 44, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 58, 59, -1, 61, -1, - 63, 59, -1, 91, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 306, 307, -1, -1, 310, 91, -1, - -1, 314, 315, 91, 317, 318, 319, 320, 321, 322, - 323, -1, -1, 326, 327, -1, -1, -1, 0, -1, - 333, 334, 335, 336, -1, -1, -1, -1, 10, -1, - 343, -1, -1, -1, -1, -1, -1, 350, 351, -1, - 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, - 363, -1, -1, 366, -1, -1, -1, -1, -1, -1, - -1, -1, 44, -1, 10, 262, 263, 264, -1, -1, - 267, 268, 269, -1, 271, 388, 58, 59, -1, 61, - -1, 63, 279, 280, 281, 282, -1, -1, -1, -1, - -1, -1, -1, 290, 291, -1, 293, 294, 295, 296, - 297, -1, -1, -1, -1, -1, -1, -1, 305, 91, - -1, 267, -1, 59, -1, -1, -1, -1, -1, -1, + 361, 362, -1, 364, -1, 366, 367, 368, 369, 370, + 371, -1, -1, 0, 375, -1, 377, 378, -1, 380, + 381, 382, 383, 10, 385, 386, 387, 388, -1, 390, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 0, -1, -1, 41, -1, -1, 44, -1, -1, + -1, 10, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 58, 59, -1, 61, -1, 63, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 91, -1, -1, -1, -1, -1, + 59, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 10, -1, -1, + 10, -1, -1, -1, -1, -1, 257, 258, 259, -1, + 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, + 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, + -1, 282, 283, 284, 285, 286, 287, 288, 289, 290, + 291, 292, 293, 294, 295, 296, 59, 298, -1, 59, + 301, 302, 303, -1, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, 315, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 327, -1, 91, 330, + 331, 91, -1, -1, -1, 336, 337, 338, -1, -1, + 341, -1, 343, 344, 345, -1, 347, 0, 349, -1, + 351, -1, 353, -1, -1, -1, -1, 10, -1, -1, + 361, -1, 363, 364, -1, 366, 367, 368, 369, 370, + 371, -1, -1, -1, 375, -1, 377, 378, -1, 380, + 381, 382, 383, -1, 385, 386, 387, 388, 41, 390, + -1, 44, -1, -1, -1, 262, 263, 264, -1, 10, + 267, 268, 269, -1, 271, 58, 59, -1, 61, -1, + 63, -1, -1, 280, 281, -1, -1, -1, -1, -1, + -1, -1, 289, 290, -1, 292, 293, 294, 295, 296, + -1, -1, -1, 262, 263, 264, -1, 304, 91, 268, + 269, -1, 271, -1, -1, -1, -1, -1, 59, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, - 327, 328, 329, 330, -1, -1, 10, -1, 335, 336, - 337, 338, -1, -1, 341, 91, -1, 344, -1, 267, - 347, -1, 349, -1, 351, 0, 353, -1, 355, 356, - 357, 358, 359, 360, 361, 10, 363, 364, 365, 262, - 263, 264, 328, -1, 267, 268, 269, -1, 271, 267, - 377, 337, 338, -1, -1, 59, 279, -1, 281, 282, - -1, -1, 389, -1, -1, -1, -1, 290, 291, 44, - 293, 294, 295, 296, 297, -1, -1, -1, -1, -1, - 328, -1, 305, 58, 59, -1, 61, 91, 63, 337, - 338, -1, -1, -1, 317, 318, 319, 320, 321, 322, - 323, 324, 325, 326, 327, 328, 329, 330, -1, -1, - 328, -1, 335, 336, 337, 338, 91, 340, 341, 337, - 338, 344, -1, -1, 347, -1, 349, -1, 351, 0, - 353, -1, 355, 356, 357, 358, 359, 360, 361, 10, - 363, -1, 365, -1, -1, -1, -1, -1, -1, -1, - 262, 263, 264, -1, 377, 267, 268, 269, -1, 271, - -1, -1, -1, -1, -1, -1, 389, 279, -1, 281, - 282, -1, -1, 44, -1, -1, -1, -1, 290, 291, - -1, 293, 294, 295, 296, 297, -1, 58, 59, -1, - 61, 267, 63, 305, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 317, 318, 319, 320, 321, - 322, 323, 324, 325, 326, 327, 328, 329, 330, -1, - 91, -1, -1, 335, 336, 337, 338, -1, 340, 341, - -1, -1, 344, -1, -1, 347, -1, 349, -1, 351, - 0, 353, -1, 355, 356, 357, 358, 359, 360, 361, - 10, 363, 328, 365, -1, -1, -1, -1, -1, -1, - -1, 337, 338, 267, -1, 377, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 389, -1, -1, - -1, -1, -1, -1, 44, -1, -1, 262, 263, 264, - -1, -1, 267, 268, 269, -1, 271, -1, 58, 59, - -1, 61, -1, 63, 279, -1, 281, 282, -1, -1, - -1, -1, -1, -1, -1, 290, 291, -1, 293, 294, - 295, 296, 297, -1, 328, -1, -1, -1, -1, -1, - 305, 91, -1, 337, 338, -1, -1, -1, -1, -1, - -1, -1, 317, 318, 319, 320, 321, 322, 323, 324, - 325, 326, 327, 328, 329, 330, -1, -1, -1, -1, - 335, 336, 337, 338, -1, 340, 341, -1, -1, 344, - -1, -1, 347, -1, 349, -1, 351, 0, 353, -1, - 355, 356, 357, 358, 359, 360, 361, 10, 363, -1, - 365, 262, 263, 264, -1, -1, 267, 268, 269, -1, - 271, -1, 377, -1, -1, -1, -1, -1, 279, -1, - 281, 282, -1, -1, 389, -1, -1, -1, -1, 290, - 291, 44, 293, 294, 295, 296, 297, -1, -1, -1, - -1, -1, -1, -1, 305, 58, 59, -1, 61, -1, - 63, -1, -1, -1, -1, -1, 317, 318, 319, 320, - 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, - -1, -1, -1, -1, 335, 336, 337, 338, 91, 340, - 341, -1, -1, 344, -1, -1, 347, -1, 349, -1, - 351, 0, 353, -1, 355, 356, 357, 358, 359, 360, - 361, 10, 363, -1, 365, -1, -1, -1, -1, -1, - -1, -1, 262, 263, 264, -1, 377, 267, 268, 269, - -1, 271, -1, -1, -1, -1, -1, -1, 389, 279, - -1, 281, 282, -1, -1, 44, -1, -1, -1, -1, - 290, 291, -1, 293, 294, 295, 296, 297, -1, 58, - 59, -1, 61, -1, 63, 305, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 317, 318, 319, - 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, - 330, -1, 91, -1, -1, 335, 336, 337, 338, -1, - 340, 341, -1, -1, 344, -1, -1, 347, -1, 349, - -1, 351, 0, 353, -1, 355, 356, 357, 358, 359, - 360, 361, 10, 363, -1, 365, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 377, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 389, - -1, -1, -1, -1, -1, -1, 44, -1, -1, 262, + 327, 328, 329, 292, 293, 294, 295, 334, 335, 336, + 337, -1, 339, 340, -1, -1, 343, -1, -1, 346, + 91, 348, -1, 350, 0, 352, -1, 354, 355, 356, + 357, 358, 359, 360, 10, 362, -1, 364, -1, 10, + -1, -1, -1, -1, 267, -1, -1, 267, -1, 376, + -1, -1, -1, -1, 343, -1, 279, -1, -1, 279, + -1, 388, -1, 390, -1, 41, -1, -1, 44, -1, + -1, -1, -1, 44, -1, 364, -1, -1, -1, -1, + -1, -1, 58, 59, -1, 61, -1, 63, 59, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 388, + -1, 390, -1, -1, 327, -1, -1, 327, -1, -1, + -1, 10, -1, 336, 337, 91, 336, 337, -1, 342, + 91, -1, 342, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 0, -1, -1, -1, -1, -1, + 363, -1, -1, 363, 10, 44, -1, -1, -1, 262, 263, 264, -1, -1, 267, 268, 269, -1, 271, -1, - 58, 59, -1, 61, -1, 63, 279, -1, 281, 282, - -1, -1, -1, -1, -1, -1, -1, 290, 291, -1, - 293, 294, 295, 296, 297, -1, -1, -1, -1, -1, - -1, -1, 305, 91, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 317, 318, 319, 320, 321, 322, - 323, 324, 325, 326, 327, 328, 329, 330, -1, -1, - -1, -1, 335, 336, 337, 338, -1, 340, 341, -1, - -1, 344, -1, -1, 347, -1, 349, -1, 351, 0, - 353, -1, 355, 356, 357, 358, 359, 360, 361, 10, - 363, -1, 365, 262, 263, 264, -1, -1, 267, 268, - 269, -1, 271, -1, 377, -1, -1, -1, -1, -1, - 279, -1, 281, 282, -1, -1, 389, -1, -1, -1, - -1, 290, 291, 44, 293, 294, 295, 296, 297, -1, - -1, -1, -1, -1, -1, -1, 305, 58, 59, -1, - 61, -1, 63, -1, -1, -1, -1, -1, 317, 318, + 59, -1, -1, -1, -1, -1, -1, 280, 281, -1, + -1, -1, -1, -1, -1, -1, 289, 290, 44, 292, + 293, 294, 295, 296, -1, -1, -1, -1, -1, -1, + -1, 304, -1, 59, -1, 61, 267, 63, -1, -1, + -1, -1, -1, 316, 317, 318, 319, 320, 321, 322, + 323, 324, 325, 326, 327, 328, 329, -1, -1, -1, + -1, 334, 335, 336, 337, 91, 339, 340, -1, -1, + 343, -1, -1, 346, -1, 348, -1, 350, 0, 352, + -1, 354, 355, 356, 357, 358, 359, 360, 10, 362, + -1, 364, -1, 10, -1, -1, 327, -1, -1, -1, + -1, -1, -1, 376, -1, 336, 337, -1, -1, -1, + -1, -1, -1, -1, -1, 388, -1, 390, -1, 41, + -1, -1, 44, -1, -1, -1, 262, 263, 264, -1, + -1, 267, 268, 269, -1, 271, 58, 59, -1, 61, + -1, 63, 59, -1, 280, 281, -1, -1, 279, -1, + -1, -1, -1, 289, 290, -1, 292, 293, 294, 295, + 296, -1, -1, -1, -1, -1, -1, -1, 304, 91, + -1, -1, -1, -1, 91, -1, -1, -1, -1, -1, + 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, + 326, 327, 328, 329, -1, -1, 327, -1, 334, 335, + 336, 337, -1, 339, 340, 336, 337, 343, 267, -1, + 346, 342, 348, -1, 350, 0, 352, -1, 354, 355, + 356, 357, 358, 359, 360, 10, 362, -1, 364, 360, + -1, -1, 363, 292, 293, -1, 262, 263, 264, -1, + 376, -1, 268, 269, -1, 271, -1, -1, -1, -1, + -1, -1, 388, 279, 390, -1, 41, -1, -1, 44, + -1, -1, -1, 289, 290, -1, 292, 293, 294, 295, + 296, -1, -1, 58, 59, -1, 61, -1, 63, -1, + -1, 340, -1, -1, 343, -1, -1, 346, -1, -1, + 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, + 326, 327, 328, 329, -1, 364, 91, -1, 334, 335, + 336, 337, -1, -1, -1, -1, -1, 343, -1, -1, + -1, -1, -1, -1, 350, 0, 352, -1, 354, 355, + 356, 357, 358, 359, 360, 10, 362, 363, 364, -1, + 262, 263, 264, -1, -1, 267, 268, 269, -1, 271, + 267, -1, -1, -1, -1, -1, -1, -1, 280, 281, + -1, -1, 388, -1, 390, -1, -1, 289, 290, 44, + 292, 293, 294, 295, 296, -1, -1, -1, 10, -1, + -1, -1, 304, -1, 59, -1, 61, -1, 63, -1, + -1, -1, -1, -1, 316, 317, 318, 319, 320, 321, + 322, 323, 324, 325, 326, 327, 328, 329, -1, -1, + 327, -1, 334, 335, 336, 337, 91, 339, 340, 336, + 337, 343, -1, -1, 346, -1, 348, 59, 350, 0, + 352, -1, 354, 355, 356, 357, 358, 359, 360, 10, + 362, -1, 364, -1, 10, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 376, -1, -1, -1, -1, 91, + -1, -1, -1, -1, -1, -1, 388, -1, 390, -1, + 41, -1, -1, 44, -1, 10, -1, 262, 263, 264, + -1, 10, 267, 268, 269, -1, 271, 58, 59, -1, + 61, -1, 63, 59, -1, 280, 281, -1, -1, -1, + -1, -1, -1, -1, 289, 290, -1, 292, 293, 294, + 295, 296, -1, -1, -1, -1, -1, -1, -1, 304, + 91, -1, -1, -1, 59, 91, -1, -1, -1, -1, + 59, 316, 317, 318, 319, 320, 321, 322, 323, 324, + 325, 326, 327, 328, 329, -1, -1, -1, -1, 334, + 335, 336, 337, -1, 339, 340, 91, -1, 343, -1, + -1, 346, 91, 348, -1, 350, 0, 352, -1, 354, + 355, 356, 357, 358, 359, 360, 10, 362, -1, 364, + -1, -1, -1, -1, -1, -1, -1, 262, 263, 264, + -1, 376, -1, 268, 269, -1, 271, -1, -1, -1, + -1, -1, -1, 388, 279, 390, -1, 41, -1, -1, + 44, -1, -1, -1, 289, 290, -1, 292, 293, 294, + 295, 296, -1, -1, 58, 59, -1, 61, -1, 63, + -1, -1, -1, -1, -1, 267, -1, -1, -1, -1, + -1, 316, 317, 318, 319, 320, 321, 322, 323, 324, + 325, 326, 327, 328, 329, -1, -1, 91, -1, 334, + 335, 336, 337, -1, -1, -1, -1, -1, 343, -1, + -1, -1, -1, -1, -1, 350, 0, 352, -1, 354, + 355, 356, 357, 358, 359, 360, 10, 362, 363, 364, + -1, 262, 263, 264, -1, 327, 267, 268, 269, -1, + 271, 267, -1, -1, 336, 337, -1, -1, -1, 280, + 281, -1, -1, 388, -1, 390, -1, -1, 289, 290, + 44, 292, 293, 294, 295, 296, -1, -1, -1, -1, + -1, -1, 267, 304, -1, 59, -1, 61, 267, 63, + -1, -1, -1, -1, -1, 316, 317, 318, 319, 320, + 321, 322, 323, 324, 325, 326, 327, 328, 329, -1, + -1, 327, -1, 334, 335, 336, 337, 91, 339, 340, + 336, 337, 343, -1, -1, 346, -1, 348, -1, 350, + 0, 352, -1, 354, 355, 356, 357, 358, 359, 360, + 10, 362, 327, 364, -1, -1, -1, -1, 327, -1, + -1, 336, 337, -1, -1, 376, -1, 336, 337, -1, + -1, -1, -1, -1, -1, -1, -1, 388, -1, 390, + -1, 41, -1, -1, 44, -1, -1, -1, 262, 263, + 264, -1, -1, 267, 268, 269, -1, 271, 58, 59, + -1, 61, -1, 63, -1, -1, 280, 281, -1, -1, + -1, -1, -1, -1, -1, 289, 290, -1, 292, 293, + 294, 295, 296, -1, -1, -1, -1, -1, -1, -1, + 304, 91, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 316, 317, 318, 319, 320, 321, 322, 323, + 324, 325, 326, 327, 328, 329, -1, -1, -1, -1, + 334, 335, 336, 337, -1, 339, 340, -1, -1, 343, + -1, -1, 346, -1, 348, -1, 350, 0, 352, -1, + 354, 355, 356, 357, 358, 359, 360, 10, 362, -1, + 364, -1, -1, -1, -1, -1, -1, -1, 262, 263, + 264, -1, 376, -1, 268, 269, -1, 271, -1, -1, + -1, -1, -1, -1, 388, -1, 390, -1, 41, -1, + -1, 44, -1, -1, -1, 289, 290, -1, 292, 293, + 294, 295, 296, -1, -1, 58, 59, -1, 61, -1, + 63, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 316, 317, 318, 319, 320, 321, 322, 323, + 324, 325, 326, 327, 328, 329, -1, -1, 91, -1, + 334, 335, 336, 337, -1, 339, -1, -1, -1, 343, + -1, -1, -1, -1, -1, -1, 350, 0, 352, -1, + 354, 355, 356, 357, 358, 359, 360, 10, 362, -1, + 364, -1, 262, 263, 264, -1, -1, 267, 268, 269, + -1, 271, -1, -1, -1, -1, -1, -1, -1, -1, + 280, 281, -1, -1, 388, -1, 390, -1, -1, 289, + 290, 44, 292, 293, 294, 295, 296, -1, -1, -1, + -1, -1, -1, -1, 304, -1, 59, -1, 61, -1, + 63, -1, -1, -1, -1, -1, 316, 317, 318, 319, + 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, + -1, -1, -1, -1, 334, 335, 336, 337, 91, 339, + 340, -1, -1, 343, -1, -1, 346, -1, 348, -1, + 350, 0, 352, -1, 354, 355, 356, 357, 358, 359, + 360, 10, 362, -1, 364, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 376, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 388, -1, + 390, -1, 41, -1, -1, 44, -1, -1, -1, 262, + 263, 264, -1, -1, 267, 268, 269, -1, 271, 58, + 59, -1, -1, -1, 63, -1, -1, 280, 281, -1, + -1, -1, -1, -1, -1, -1, 289, 290, -1, 292, + 293, 294, 295, 296, -1, -1, -1, -1, -1, -1, + -1, 304, 91, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 316, 317, 318, 319, 320, 321, 322, + 323, 324, 325, 326, 327, 328, 329, -1, 10, -1, + -1, 334, 335, 336, 337, -1, 339, 340, -1, -1, + 343, -1, -1, 346, -1, 348, -1, 350, 0, 352, + -1, 354, 355, 356, 357, 358, 359, 360, 10, 362, + -1, 364, -1, -1, -1, -1, -1, -1, -1, 262, + 263, 264, -1, 376, -1, 268, 269, 59, 271, -1, + -1, -1, -1, -1, -1, 388, -1, 390, -1, 41, + -1, -1, 44, -1, -1, -1, 289, 290, -1, 292, + 293, 294, 295, 296, -1, -1, 58, 59, -1, 91, + -1, 63, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 316, 317, 318, 319, 320, 321, 322, + 323, 324, 325, 326, 327, 328, 329, -1, -1, 91, + -1, 334, 335, 336, 337, -1, 339, -1, -1, -1, + 343, -1, -1, -1, -1, -1, -1, 350, 0, 352, + -1, 354, 355, 356, 357, 358, 359, 360, 10, 362, + -1, 364, -1, 262, 263, 264, -1, -1, 267, 268, + 269, -1, 271, -1, -1, -1, -1, -1, -1, -1, + 279, 280, 281, -1, -1, 388, -1, 390, -1, -1, + 289, 290, 44, 292, 293, 294, 295, 296, -1, -1, + -1, -1, -1, -1, -1, 304, -1, 59, -1, 61, + -1, 63, -1, -1, -1, -1, -1, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, - 329, 330, -1, -1, 10, -1, 335, 336, 337, 338, - 91, 340, 341, -1, -1, 344, -1, -1, 347, -1, - 349, -1, 351, 0, 353, -1, 355, 356, 357, 358, - 359, 360, 361, 10, 363, -1, 365, -1, 44, -1, - -1, -1, -1, -1, 262, 263, 264, -1, 377, 267, - 268, 269, -1, 271, -1, 61, -1, -1, -1, -1, - 389, 279, -1, 281, 282, -1, -1, 44, -1, -1, - -1, -1, 290, 291, -1, 293, 294, 295, 296, 297, - -1, 58, 59, -1, 61, 91, 63, 305, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 317, + 329, -1, -1, -1, -1, 334, 335, 336, 337, 91, + -1, 340, -1, -1, 343, -1, -1, 346, -1, 348, + -1, 350, 0, 352, -1, 354, 355, 356, 357, 358, + 359, 360, 10, 362, 363, 364, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 267, -1, 376, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 279, -1, 388, + -1, 390, -1, 41, -1, -1, 44, -1, -1, -1, + 262, 263, 264, -1, -1, 267, 268, 269, -1, 271, + 58, 59, -1, -1, -1, 63, -1, 279, 280, 281, + -1, -1, -1, -1, -1, -1, -1, 289, 290, -1, + 292, 293, 294, 295, 296, 327, -1, -1, -1, -1, + -1, -1, 304, 91, 336, 337, -1, -1, -1, -1, + 342, -1, -1, -1, 316, 317, 318, 319, 320, 321, + 322, 323, 324, 325, 326, 327, 328, 329, -1, -1, + -1, 363, 334, 335, 336, 337, 124, -1, 340, -1, + -1, 343, -1, -1, 346, -1, 348, -1, 350, 0, + 352, -1, 354, 355, 356, 357, 358, 359, 360, 10, + 362, 363, 364, -1, -1, -1, -1, -1, -1, -1, + 262, 263, 264, -1, 376, -1, 268, 269, -1, 271, + -1, -1, -1, -1, -1, -1, 388, -1, 390, -1, + 41, -1, -1, 44, -1, -1, -1, 289, 290, -1, + 292, 293, 294, 295, 296, -1, -1, 58, 59, -1, + 61, -1, 63, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 316, 317, 318, 319, 320, 321, + 322, 323, 324, 325, 326, 327, 328, 329, -1, -1, + 91, -1, 334, 335, 336, 337, -1, 339, -1, -1, + -1, 343, -1, -1, -1, -1, -1, -1, 350, 0, + 352, -1, 354, 355, 356, 357, 358, 359, 360, 10, + 362, -1, 364, -1, 262, 263, 264, -1, -1, 267, + 268, 269, -1, 271, -1, -1, -1, -1, -1, -1, + -1, -1, 280, 281, -1, -1, 388, -1, 390, -1, + -1, 289, 290, 44, 292, 293, 294, 295, 296, -1, + -1, -1, -1, -1, -1, -1, 304, -1, 59, -1, + 61, -1, 63, -1, -1, -1, -1, -1, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, - 328, 329, 330, -1, 91, -1, -1, 335, 336, 337, - 338, -1, 340, 341, -1, -1, 344, -1, -1, 347, - -1, 349, -1, 351, 0, 353, -1, 355, 356, 357, - 358, 359, 360, 361, 10, 363, -1, 365, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 377, + 328, 329, -1, -1, -1, -1, 334, 335, 336, 337, + 91, -1, 340, -1, -1, 343, -1, -1, 346, -1, + 348, -1, 350, 0, 352, -1, 354, 355, 356, 357, + 358, 359, 360, 10, 362, -1, 364, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 376, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 389, -1, -1, -1, -1, -1, -1, 44, -1, + 388, -1, 390, -1, 41, -1, -1, 44, -1, -1, -1, 262, 263, 264, -1, -1, 267, 268, 269, -1, - 271, -1, 58, 59, -1, -1, -1, 63, 279, -1, - 281, 282, -1, -1, -1, -1, -1, -1, -1, 290, - 291, -1, 293, 294, 295, 296, 297, -1, -1, -1, - -1, -1, -1, -1, 305, 91, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 317, 318, 319, 320, - 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, - -1, -1, -1, -1, 335, 336, 337, 338, -1, 340, - 341, -1, -1, 344, -1, -1, 347, -1, 349, -1, - 351, 0, 353, 279, 355, 356, 357, 358, 359, 360, - 361, 10, 363, -1, 365, 262, 263, 264, -1, -1, - 267, 268, 269, -1, 271, -1, 377, -1, -1, -1, - -1, -1, 279, -1, 281, 282, -1, -1, 389, -1, - -1, -1, -1, 290, 291, 44, 293, 294, 295, 296, - 297, -1, 328, -1, -1, -1, -1, -1, 305, 58, - 59, 337, 338, -1, 63, -1, -1, -1, 344, -1, + 271, 58, 59, -1, 61, -1, 63, -1, -1, 280, + 281, -1, -1, -1, -1, -1, -1, -1, 289, 290, + -1, 292, 293, 294, 295, 296, -1, -1, -1, -1, + -1, -1, -1, 304, 91, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 316, 317, 318, 319, 320, + 321, 322, 323, 324, 325, 326, 327, 328, 329, -1, + 10, -1, -1, 334, 335, 336, 337, -1, -1, 340, + -1, -1, 343, -1, -1, 346, -1, 348, -1, 350, + 0, 352, -1, 354, 355, 356, 357, 358, 359, 360, + 10, 362, -1, 364, -1, -1, -1, -1, -1, -1, + -1, 262, 263, 264, -1, 376, -1, 268, 269, 59, + 271, -1, -1, -1, -1, -1, -1, 388, -1, 390, + -1, 41, -1, -1, 44, -1, -1, -1, 289, 290, + -1, 292, 293, 294, 295, 296, -1, -1, 58, 59, + -1, 91, -1, 63, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 316, 317, 318, 319, 320, + 321, 322, 323, 324, 325, 326, 327, 328, 329, -1, + -1, 91, -1, 334, 335, 336, 337, -1, 339, -1, + -1, -1, 343, -1, -1, -1, -1, -1, -1, 350, + 0, 352, -1, 354, 355, 356, 357, 358, 359, 360, + 10, 362, -1, 364, -1, 262, 263, 264, -1, -1, + 267, 268, 269, -1, 271, -1, -1, -1, -1, -1, + -1, -1, -1, 280, 281, -1, -1, 388, -1, 390, + -1, -1, 289, 290, 44, 292, 293, 294, 295, 296, + -1, -1, -1, -1, -1, -1, -1, 304, -1, 59, + -1, 61, -1, 63, -1, -1, -1, -1, -1, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, - 327, 328, 329, 330, -1, -1, 10, -1, 335, 336, - 337, 338, 91, 340, 341, -1, -1, 344, -1, -1, - 347, -1, 349, -1, 351, 0, 353, -1, 355, 356, - 357, 358, 359, 360, 361, 10, 363, -1, 365, -1, - 44, -1, -1, -1, -1, -1, 262, 263, 264, -1, - 377, 267, 268, 269, -1, 271, -1, 61, -1, -1, - -1, -1, 389, 279, 280, 281, 282, -1, -1, 44, - -1, -1, -1, -1, 290, 291, -1, 293, 294, 295, - 296, 297, -1, 58, 59, -1, 61, 91, 63, 305, + 327, 328, 329, -1, -1, -1, -1, 334, 335, 336, + 337, 91, -1, 340, -1, -1, 343, -1, -1, 346, + -1, 348, -1, 350, 0, 352, -1, 354, 355, 356, + 357, 358, 359, 360, 10, 362, -1, 364, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 267, -1, 376, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 279, + -1, 388, -1, 390, -1, 41, -1, -1, 44, -1, + -1, -1, 262, 263, 264, -1, -1, 267, 268, 269, + -1, 271, 58, 59, -1, -1, -1, 63, -1, -1, + 280, 281, -1, -1, -1, -1, -1, -1, -1, 289, + 290, -1, 292, 293, 294, 295, 296, 327, -1, -1, + -1, -1, -1, -1, 304, 91, 336, 337, -1, -1, + -1, -1, -1, -1, -1, -1, 316, 317, 318, 319, + 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, + -1, -1, -1, 363, 334, 335, 336, 337, -1, -1, + 340, -1, -1, 343, -1, -1, 346, -1, 348, -1, + 350, 0, 352, -1, 354, 355, 356, 357, 358, 359, + 360, 10, 362, -1, 364, -1, -1, -1, -1, -1, + -1, -1, 262, 263, 264, -1, 376, -1, 268, 269, + -1, 271, -1, -1, -1, -1, -1, -1, 388, -1, + 390, -1, 41, -1, -1, 44, -1, -1, -1, 289, + 290, -1, 292, 293, 294, 295, 296, -1, -1, 58, + 59, -1, -1, -1, 63, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 316, 317, 318, 319, + 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, + -1, -1, 91, -1, 334, 335, 336, 337, -1, 339, + -1, -1, -1, 343, -1, -1, -1, -1, -1, -1, + 350, -1, 352, -1, 354, 355, 356, 357, 358, 359, + 360, -1, 362, -1, 364, -1, 262, 263, 264, -1, + -1, 267, 268, 269, -1, 271, -1, 0, -1, -1, + -1, -1, -1, -1, 280, 281, -1, 10, 388, -1, + 390, -1, -1, 289, 290, -1, 292, 293, 294, 295, + 296, -1, -1, -1, -1, -1, -1, -1, 304, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 41, -1, + 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, + 326, 327, 328, 329, -1, -1, 59, -1, 334, 335, + 336, 337, -1, -1, 340, -1, -1, 343, -1, -1, + 346, -1, 348, -1, 350, 0, 352, -1, 354, 355, + 356, 357, 358, 359, 360, 10, 362, -1, 364, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 317, 318, 319, 320, 321, 322, 323, 324, 325, - 326, 327, 328, 329, 330, -1, 91, -1, -1, 335, - 336, 337, 338, -1, -1, 341, -1, -1, 344, -1, - -1, 347, -1, 349, -1, 351, 0, 353, -1, 355, - 356, 357, 358, 359, 360, 361, 10, 363, 364, 365, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 377, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 389, -1, -1, -1, -1, -1, -1, - 44, -1, -1, 262, 263, 264, -1, -1, 267, 268, - 269, -1, 271, -1, 58, 59, -1, 61, -1, 63, - 279, 280, 281, 282, -1, -1, -1, -1, -1, -1, - -1, 290, 291, -1, 293, 294, 295, 296, 297, -1, - -1, -1, -1, -1, -1, -1, 305, 91, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 317, 318, + 376, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 388, -1, 390, -1, 41, -1, -1, 44, + -1, -1, -1, 262, 263, 264, -1, -1, 267, 268, + 269, -1, 271, -1, 59, -1, -1, -1, 63, -1, + -1, 280, 281, -1, -1, -1, -1, -1, -1, -1, + 289, 290, -1, 292, 293, 294, 295, 296, -1, -1, + -1, -1, -1, -1, -1, 304, 91, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, - 329, 330, -1, -1, -1, -1, 335, 336, 337, 338, - -1, -1, 341, -1, -1, 344, -1, -1, 347, -1, - 349, -1, 351, 0, 353, 279, 355, 356, 357, 358, - 359, 360, 361, 10, 363, 364, 365, 262, 263, 264, - -1, -1, 267, 268, 269, -1, 271, -1, 377, -1, - -1, -1, -1, -1, 279, -1, 281, 282, -1, -1, - 389, -1, -1, -1, -1, 290, 291, 44, 293, 294, - 295, 296, 297, -1, 328, -1, -1, -1, -1, -1, - 305, 58, 59, 337, 338, -1, 63, -1, -1, -1, - 344, -1, 317, 318, 319, 320, 321, 322, 323, 324, - 325, 326, 327, 328, 329, 330, -1, -1, 10, -1, - 335, 336, 337, 338, 91, -1, 341, -1, -1, 344, - -1, -1, 347, -1, 349, -1, 351, 0, 353, -1, - 355, 356, 357, 358, 359, 360, 361, 10, 363, -1, - 365, -1, 44, -1, -1, -1, -1, -1, 262, 263, - 264, -1, 377, 267, 268, 269, -1, 271, -1, 61, - -1, -1, -1, -1, 389, 279, -1, 281, 282, -1, - -1, 44, -1, -1, -1, -1, 290, 291, -1, 293, - 294, 295, 296, 297, -1, 58, 59, -1, -1, 91, - 63, 305, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 317, 318, 319, 320, 321, 322, 323, - 324, 325, 326, 327, 328, 329, 330, -1, 91, -1, - -1, 335, 336, 337, 338, -1, -1, 341, -1, -1, - 344, -1, -1, 347, -1, 349, -1, 351, 0, 353, - -1, 355, 356, 357, 358, 359, 360, 361, 10, 363, - -1, 365, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 377, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 389, -1, -1, -1, -1, - -1, -1, 44, -1, -1, 262, 263, 264, -1, -1, - 267, 268, 269, -1, 271, -1, 58, 59, -1, -1, - -1, 63, 279, -1, 281, 282, -1, -1, -1, -1, - -1, -1, -1, 290, 291, -1, 293, 294, 295, 296, - 297, -1, -1, -1, -1, -1, -1, -1, 305, 91, + 329, -1, -1, -1, -1, 334, 335, 336, 337, -1, + -1, 340, -1, -1, 343, -1, -1, 346, -1, 348, + -1, 350, 0, 352, -1, 354, 355, 356, 357, 358, + 359, 360, 10, 362, -1, 364, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 376, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 388, + -1, 390, -1, 41, -1, -1, 44, -1, -1, 262, + 263, 264, 10, -1, 267, 268, 269, -1, 271, -1, + -1, 59, -1, -1, -1, 63, -1, 280, -1, -1, + -1, -1, -1, -1, -1, -1, 289, 290, -1, 292, + 293, 294, 295, 296, -1, -1, 44, -1, -1, -1, + -1, -1, -1, 91, -1, -1, -1, -1, -1, -1, + -1, 59, -1, -1, -1, -1, 0, -1, -1, -1, + -1, -1, -1, -1, 327, -1, 10, -1, -1, -1, + -1, -1, -1, 336, 337, -1, -1, 262, 263, 264, + 343, -1, 267, 268, 269, -1, 271, -1, -1, -1, + -1, -1, -1, -1, -1, 280, 281, 41, -1, -1, + 44, 364, -1, -1, 289, 290, -1, 292, 293, 294, + 295, 296, -1, -1, -1, 59, 124, -1, -1, 63, + -1, -1, -1, -1, -1, 388, -1, 390, -1, -1, + -1, 316, 317, 318, 319, 320, 321, 322, 323, 324, + 325, 326, 327, 328, 329, -1, -1, 91, -1, 334, + 335, 336, 337, -1, -1, 340, -1, -1, 343, -1, + -1, 346, -1, 348, -1, 350, -1, 352, 0, 354, + 355, 356, 357, 358, 359, 360, -1, 362, 10, 364, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 388, -1, 390, -1, -1, -1, 41, + -1, -1, 44, -1, 262, 263, 264, -1, -1, 267, + 268, 269, -1, 271, -1, -1, 58, 59, -1, -1, + -1, 63, 280, 281, -1, -1, -1, -1, -1, -1, + -1, 289, 290, -1, 292, 293, 294, 295, 296, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 267, + -1, -1, -1, -1, -1, -1, -1, -1, 316, 317, + 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, + 328, 329, -1, -1, 292, 293, 334, 335, 336, 337, + -1, -1, 340, -1, -1, 343, -1, -1, 346, -1, + 348, -1, 350, 0, 352, -1, 354, 355, 356, 357, + 358, 359, 360, 10, 362, -1, 364, -1, 262, 263, + 264, -1, -1, 267, 268, 269, -1, 271, -1, -1, + -1, -1, 340, -1, -1, 343, 280, 281, 346, -1, + 388, -1, 390, -1, 41, 289, 290, 44, 292, 293, + 294, 295, 296, -1, -1, -1, 364, -1, -1, -1, + -1, 58, 59, -1, -1, -1, 63, -1, -1, -1, + -1, -1, 316, 317, 318, 319, 320, 321, 322, 323, + 324, 325, 326, 327, 328, 329, -1, -1, -1, -1, + 334, 335, 336, 337, -1, -1, 340, -1, -1, 343, + 10, -1, 346, -1, 348, -1, 350, 10, 352, -1, + 354, 355, 356, 357, 358, 359, 360, -1, 362, -1, + 364, -1, -1, -1, -1, 10, -1, -1, -1, -1, + 262, 263, 264, -1, 44, 267, 268, 269, -1, 271, + -1, -1, -1, -1, 388, -1, 390, -1, 280, 281, + -1, 61, -1, -1, -1, -1, 59, 289, 290, 44, + 292, 293, 294, 295, 296, -1, -1, -1, -1, -1, + -1, -1, 304, -1, -1, -1, 61, -1, -1, -1, + -1, 91, -1, -1, 316, 317, 318, 319, 320, 321, + 322, 323, 324, 325, 326, -1, 328, 329, -1, -1, + -1, -1, 334, 335, -1, 0, 91, -1, 340, -1, + -1, 343, -1, -1, 346, 10, 348, -1, 350, -1, + 352, -1, 354, 355, 356, 357, 358, 359, 360, -1, + 362, -1, 364, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 376, -1, 41, -1, -1, 44, + -1, -1, -1, -1, -1, -1, 388, -1, 390, -1, + -1, -1, -1, 58, 59, 262, 263, 264, 63, -1, + 267, 268, 269, -1, 271, -1, -1, -1, -1, -1, + -1, -1, -1, 280, 281, -1, -1, -1, -1, -1, + -1, -1, 289, 290, -1, 292, 293, 294, 295, 296, + -1, -1, -1, -1, -1, -1, -1, 304, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, - 327, 328, 329, 330, -1, -1, -1, -1, 335, 336, - 337, 338, -1, -1, 341, -1, -1, 344, -1, -1, - 347, -1, 349, -1, 351, 0, 353, 279, 355, 356, - 357, 358, 359, 360, 361, 10, 363, -1, 365, 262, - 263, 264, -1, -1, 267, 268, 269, -1, 271, -1, - 377, -1, -1, -1, -1, -1, 279, -1, 281, 282, - -1, -1, 389, -1, -1, -1, -1, 290, 291, 44, - 293, 294, 295, 296, 297, -1, 328, -1, -1, -1, - -1, -1, 305, 58, 59, 337, 338, -1, 63, -1, - -1, -1, 344, -1, 317, 318, 319, 320, 321, 322, - 323, 324, 325, 326, 327, 328, 329, 330, -1, -1, - 10, -1, 335, 336, 337, 338, 91, -1, 341, -1, - -1, 344, -1, -1, 347, -1, 349, -1, 351, 0, - 353, -1, 355, 356, 357, 358, 359, 360, 361, 10, - 363, -1, 365, -1, 44, -1, -1, -1, -1, -1, - 262, 263, 264, -1, 377, 267, 268, 269, -1, 271, - -1, 61, -1, -1, -1, -1, 389, 279, -1, 281, - 282, -1, -1, 44, -1, -1, -1, -1, 290, 291, - -1, 293, 294, 295, 296, 297, -1, 58, 59, -1, - -1, 91, 63, 305, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 317, 318, 319, 320, 321, - 322, 323, 324, 325, 326, 327, 328, 329, 330, -1, - 91, -1, -1, 335, 336, 337, 338, -1, -1, 341, - -1, -1, 344, -1, -1, 347, -1, 349, -1, 351, - 0, 353, -1, 355, 356, 357, 358, 359, 360, 361, - 10, 363, -1, 365, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 377, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 389, -1, -1, - -1, -1, -1, -1, 44, -1, -1, 262, 263, 264, - -1, -1, 267, 268, 269, -1, 271, -1, -1, 59, - -1, -1, -1, 63, 279, -1, 281, 282, -1, -1, - -1, -1, -1, -1, -1, 290, 291, -1, 293, 294, - 295, 296, 297, -1, -1, -1, -1, -1, -1, -1, - 305, 91, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 317, 318, 319, 320, 321, 322, 323, 324, - 325, 326, 327, 328, 329, 330, -1, -1, -1, -1, - 335, 336, 337, 338, -1, -1, 341, -1, -1, 344, - -1, -1, 347, -1, 349, -1, 351, 0, 353, 279, - 355, 356, 357, 358, 359, 360, 361, 10, 363, -1, - 365, 262, 263, 264, -1, -1, 267, 268, 269, -1, - 271, -1, 377, -1, -1, -1, -1, -1, 279, -1, - 281, 282, -1, -1, 389, -1, -1, -1, -1, 290, - 291, 44, 293, 294, 295, 296, 297, -1, 328, -1, - -1, -1, -1, -1, 305, -1, 59, 337, 338, -1, - 63, -1, -1, -1, 344, -1, -1, 318, 319, 320, - 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, - -1, -1, 10, -1, 335, 336, 337, 338, 91, -1, - 341, -1, -1, 344, -1, -1, 347, -1, 349, -1, - 351, 0, 353, -1, 355, 356, 357, 358, 359, 360, - 361, 10, 363, -1, 365, -1, 44, -1, -1, -1, - -1, -1, 262, 263, 264, -1, 377, 267, 268, 269, - -1, 271, -1, 61, -1, -1, -1, -1, 389, 279, - -1, 281, 282, -1, -1, 44, -1, -1, -1, -1, - 290, 291, -1, 293, 294, 295, 296, 297, -1, -1, - 59, -1, -1, 91, 63, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 317, 318, 319, - 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, - 330, -1, 91, -1, -1, 335, 336, 337, 338, -1, - -1, 341, -1, -1, 344, -1, -1, 347, -1, 349, - -1, 351, 0, 353, -1, 355, 356, 357, 358, 359, - 360, 361, 10, 363, -1, 365, -1, -1, -1, -1, + -1, 328, 329, -1, -1, -1, -1, 334, 335, -1, + 0, -1, -1, 340, -1, -1, 343, -1, -1, 346, + 10, 348, -1, 350, -1, 352, -1, 354, 355, 356, + 357, 358, 359, 360, -1, 362, -1, 364, -1, 279, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 376, + -1, 41, -1, -1, 44, -1, -1, -1, -1, -1, + -1, 388, -1, 390, 279, -1, -1, -1, 58, 59, + -1, -1, 305, 63, 307, 308, 309, 310, 311, -1, + -1, -1, -1, 316, -1, -1, -1, 327, -1, -1, + -1, -1, -1, -1, 327, -1, 336, 337, 331, -1, + -1, -1, 342, 343, 337, -1, -1, -1, 341, 342, + -1, -1, 327, -1, 10, -1, 349, 350, 351, 352, + -1, 336, 337, 363, -1, -1, -1, 342, 343, -1, + -1, -1, -1, -1, -1, -1, -1, 262, 263, 264, + -1, -1, 267, 268, 269, -1, 271, -1, 363, -1, + 390, -1, -1, -1, 387, 280, 281, -1, -1, -1, + -1, -1, -1, 59, 289, 290, -1, 292, 293, 294, + 295, 296, -1, -1, -1, 390, -1, -1, -1, 304, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 389, - -1, -1, -1, -1, -1, -1, 44, -1, -1, 262, - 263, 264, -1, -1, 267, 268, 269, -1, 271, -1, - 58, 59, -1, -1, -1, 63, 279, -1, 281, 282, - -1, -1, -1, -1, -1, -1, -1, 290, 291, -1, - 293, 294, 295, 296, 297, -1, -1, -1, -1, -1, + -1, -1, 317, 318, 319, 320, 321, 322, 323, 324, + 325, 326, -1, 328, 329, -1, -1, -1, -1, 334, + 335, -1, 0, -1, -1, 340, -1, -1, 343, -1, + -1, 346, 10, 348, -1, 350, -1, 352, -1, 354, + 355, 356, 357, 358, 359, 360, -1, 362, -1, 364, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 317, 318, 319, 320, 321, 322, - 323, 324, 325, 326, 327, 328, 329, 330, -1, -1, - -1, -1, 335, 336, 337, 338, -1, -1, 341, -1, - -1, 344, -1, -1, 347, -1, 349, -1, 351, 0, - 353, 279, 355, 356, 357, 358, 359, 360, 361, 10, - 363, -1, 365, 262, 263, 264, -1, -1, 267, 268, - 269, -1, 271, -1, -1, -1, -1, -1, -1, -1, - 279, -1, 281, 282, -1, -1, 389, -1, -1, -1, - -1, 290, 291, 44, 293, 294, 295, 296, 297, -1, - 328, -1, -1, -1, -1, -1, -1, 58, 59, 337, - 338, -1, 63, -1, -1, -1, 344, -1, 317, 318, - 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, - 329, 330, -1, -1, 10, -1, 335, 336, 337, 338, - -1, -1, 341, -1, -1, 344, -1, -1, 347, -1, - 349, -1, 351, 0, 353, -1, 355, 356, 357, 358, - 359, 360, 361, 10, 363, -1, 365, -1, 44, -1, + -1, 376, -1, 41, -1, -1, 44, -1, -1, -1, + -1, -1, -1, 388, -1, 390, -1, -1, -1, -1, + 58, 59, 262, 263, 264, 63, -1, 267, 268, 269, + -1, 271, -1, -1, -1, -1, -1, -1, -1, -1, + 280, 281, -1, -1, -1, -1, -1, -1, -1, 289, + 290, -1, 292, 293, 294, 295, 296, -1, -1, -1, + -1, -1, -1, -1, 304, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 317, 318, 319, + 320, 321, 322, 323, 324, 325, 326, -1, 328, 329, + -1, -1, -1, -1, 334, 335, -1, 0, -1, -1, + 340, -1, -1, 343, -1, -1, 346, 10, 348, -1, + 350, -1, 352, -1, 354, 355, 356, 357, 358, 359, + 360, -1, 362, -1, 364, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 376, -1, 41, -1, + -1, 44, -1, -1, -1, -1, -1, -1, 388, -1, + 390, -1, -1, -1, -1, 58, 59, -1, -1, 305, + 63, 307, 308, 309, 310, 311, -1, -1, -1, -1, + 316, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 327, -1, -1, -1, 331, -1, -1, -1, -1, + -1, 337, -1, -1, -1, 341, 342, -1, -1, -1, + -1, 10, -1, 349, 350, 351, 352, -1, -1, -1, + -1, -1, -1, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 262, 263, 264, -1, -1, 267, - 268, 269, -1, 271, -1, 61, -1, -1, -1, -1, - 389, 279, -1, 281, 282, -1, -1, 44, -1, -1, - -1, -1, 290, 291, -1, 293, 294, 295, 296, 297, - -1, 58, 59, -1, -1, 91, 63, 305, -1, -1, + 268, 269, -1, 271, -1, -1, -1, -1, -1, -1, + -1, 387, 280, 281, -1, -1, -1, -1, -1, -1, + 59, 289, 290, -1, 292, 293, 294, 295, 296, -1, + -1, -1, 59, -1, -1, -1, 304, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 317, - 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, - -1, 329, 330, -1, -1, -1, -1, 335, 336, -1, - -1, -1, -1, 341, -1, -1, 344, -1, -1, 347, - -1, 349, -1, 351, 0, 353, -1, 355, 356, 357, - 358, 359, 360, 361, 10, 363, -1, 365, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 377, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 389, -1, -1, -1, -1, -1, -1, 44, -1, + 318, 319, 320, 321, 322, 323, 324, 325, 326, -1, + 328, 329, -1, -1, -1, -1, 334, 335, -1, 0, + -1, -1, 340, -1, -1, 343, -1, -1, 346, 10, + 348, -1, 350, -1, 352, -1, 354, 355, 356, 357, + 358, 359, 360, -1, 362, -1, 364, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 376, -1, + 41, -1, -1, 44, -1, -1, -1, -1, -1, -1, + 388, -1, 390, -1, -1, -1, -1, 58, 59, 262, + 263, 264, 63, -1, 267, 268, 269, -1, 271, -1, + -1, -1, -1, -1, -1, -1, -1, 280, 281, -1, + -1, -1, -1, -1, -1, -1, 289, 290, -1, 292, + 293, 294, 295, 296, -1, -1, -1, -1, -1, -1, + -1, 304, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 317, 318, 319, 320, 321, 322, + 323, 324, 325, 326, -1, 328, 329, -1, -1, -1, + -1, 334, 335, -1, 0, -1, -1, 340, -1, -1, + 343, -1, -1, 346, 10, 348, -1, 350, -1, 352, + -1, 354, 355, 356, 357, 358, 359, 360, -1, 362, + -1, 364, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 376, -1, 41, -1, -1, 44, -1, + -1, -1, 10, -1, -1, 388, -1, 390, -1, -1, + -1, -1, 58, 59, -1, -1, 305, 63, 307, 308, + 309, 310, 311, -1, -1, -1, -1, 316, 305, -1, + 307, 308, 309, 310, 311, -1, 44, -1, 327, 316, + -1, -1, 331, -1, -1, -1, -1, -1, 337, -1, + -1, 59, 341, 342, 331, -1, -1, -1, 0, -1, + 349, 350, 351, 352, 341, -1, -1, -1, 10, -1, + -1, -1, 349, 350, 351, 352, -1, -1, -1, -1, -1, 262, 263, 264, -1, -1, 267, 268, 269, -1, - 271, -1, 58, 59, -1, -1, -1, 63, 279, -1, - 281, 282, -1, -1, -1, -1, -1, -1, -1, 290, - 291, -1, 293, 294, 295, 296, 297, -1, -1, -1, - -1, -1, -1, -1, 305, -1, -1, -1, -1, -1, + 271, -1, -1, -1, -1, -1, -1, -1, 387, 280, + 281, -1, 44, -1, -1, -1, -1, -1, 289, 290, + 387, 292, 293, 294, 295, 296, 124, 59, -1, 61, + -1, 63, -1, 304, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 317, 318, 319, 320, - 321, 322, 323, 324, 325, 326, 327, -1, 329, 330, - -1, -1, -1, -1, 335, 336, -1, -1, -1, -1, - 341, -1, -1, 344, -1, -1, 347, -1, 349, -1, - 351, 0, 353, 279, 355, 356, 357, 358, 359, 360, - 361, 10, 363, -1, 365, 262, 263, 264, -1, -1, - 267, 268, 269, -1, 271, -1, 377, -1, -1, -1, - -1, -1, 279, -1, 281, 282, -1, -1, 389, -1, - -1, -1, -1, 290, 291, 44, 293, 294, 295, 296, - 297, -1, 328, -1, -1, -1, -1, -1, 305, 58, - 59, 337, 338, -1, 63, -1, -1, -1, 344, -1, - -1, 318, 319, 320, 321, 322, 323, 324, 325, 326, - 327, -1, 329, 330, -1, -1, 10, -1, 335, 336, - -1, -1, -1, -1, 341, -1, -1, 344, -1, -1, - 347, -1, 349, -1, 351, 0, 353, -1, 355, 356, - 357, 358, 359, 360, 361, 10, 363, -1, 365, -1, - 44, -1, -1, -1, -1, -1, 262, 263, 264, -1, - 377, 267, 268, 269, -1, 271, -1, 61, -1, -1, - -1, -1, 389, 279, -1, 281, 282, -1, -1, 44, - -1, -1, -1, -1, 290, 291, -1, 293, 294, 295, - 296, 297, -1, 58, 59, -1, -1, 91, 63, 305, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 318, 319, 320, 321, 322, 323, 324, 325, - 326, 327, -1, 329, 330, -1, -1, -1, -1, 335, - 336, -1, -1, -1, -1, 341, -1, -1, 344, -1, - -1, 347, -1, 349, -1, 351, 0, 353, -1, 355, - 356, 357, 358, 359, 360, 361, 10, 363, -1, 365, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 377, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 389, -1, -1, -1, -1, -1, -1, - 44, -1, -1, 262, 263, 264, -1, -1, 267, 268, - 269, -1, 271, -1, 58, 59, -1, -1, -1, 63, - 279, -1, 281, 282, -1, -1, -1, -1, -1, -1, - -1, 290, 291, -1, 293, 294, 295, 296, 297, -1, - -1, -1, -1, -1, -1, -1, 305, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 318, - 319, 320, 321, 322, 323, 324, 325, 326, 327, -1, - 329, 330, -1, -1, -1, -1, 335, 336, -1, -1, - -1, -1, 341, -1, -1, 344, -1, -1, 347, -1, - 349, -1, 351, 0, 353, 279, 355, 356, 357, 358, - 359, 360, 361, 10, 363, -1, 365, 262, 263, 264, - -1, -1, 267, 268, 269, -1, 271, -1, 377, -1, - -1, -1, -1, -1, 279, -1, 281, 282, -1, -1, - 389, -1, -1, -1, -1, 290, 291, 44, 293, 294, - 295, 296, 297, -1, 328, -1, -1, -1, -1, -1, - 305, 58, 59, 337, 338, -1, 63, -1, -1, -1, - 344, -1, -1, 318, 319, 320, 321, 322, 323, 324, - 325, 326, 327, -1, 329, 330, -1, -1, -1, -1, - 335, 336, -1, -1, -1, -1, 341, -1, -1, 344, - -1, -1, 347, -1, 349, -1, 351, 0, 353, -1, - 355, 356, 357, 358, 359, 360, 361, 10, 363, -1, - 365, -1, -1, -1, -1, -1, -1, -1, 262, 263, - 264, -1, 377, 267, 268, 269, -1, 271, -1, -1, - -1, -1, -1, -1, 389, 279, -1, 281, 282, -1, - -1, 44, -1, -1, -1, -1, 290, 291, -1, 293, - 294, 295, 296, 297, -1, -1, 59, -1, 61, -1, - 63, 305, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 318, 319, 320, 321, 322, 323, - 324, 325, 326, 327, -1, 329, 330, -1, 91, -1, - -1, 335, 336, -1, -1, -1, -1, 341, -1, -1, - 344, -1, -1, 347, -1, 349, -1, 351, 0, 353, - -1, 355, 356, 357, 358, 359, 360, 361, 10, 363, - -1, 365, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 377, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 389, -1, -1, -1, -1, - -1, -1, 44, -1, -1, 262, 263, 264, -1, -1, - 267, 268, 269, -1, 271, -1, -1, 59, -1, 61, - -1, 63, 279, -1, 281, 282, -1, -1, -1, -1, - -1, -1, -1, 290, 291, -1, 293, 294, 295, 296, - 297, -1, -1, -1, -1, -1, -1, -1, 305, 91, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 318, 319, 320, 321, 322, 323, 324, 325, 326, - 327, -1, 329, 330, -1, -1, -1, -1, 335, 336, - -1, -1, -1, -1, 341, -1, -1, 344, -1, -1, - 347, -1, 349, -1, 351, 0, 353, -1, 355, 356, - 357, 358, 359, 360, 361, 10, 363, -1, 365, 262, - 263, 264, -1, -1, -1, 268, 269, -1, 271, -1, - 377, -1, -1, -1, -1, -1, 279, 280, -1, -1, - -1, -1, 389, -1, -1, -1, -1, 290, 291, 44, - 293, 294, 295, 296, 297, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 59, -1, 61, -1, 63, -1, - -1, -1, -1, -1, 317, 318, 319, 320, 321, 322, - 323, 324, 325, 326, 327, 328, 329, 330, -1, -1, - -1, -1, 335, 336, 337, 338, 91, -1, -1, -1, - -1, 344, -1, -1, -1, -1, -1, -1, 351, 0, - 353, -1, 355, 356, 357, 358, 359, 360, 361, 10, - 363, 364, 365, -1, -1, -1, -1, -1, -1, -1, + 321, 322, 323, 324, 325, 326, -1, 328, 329, 91, + -1, -1, -1, 334, 335, -1, -1, -1, -1, 340, + -1, -1, 343, -1, -1, 346, -1, 348, -1, 350, + 0, 352, -1, 354, 355, 356, 357, 358, 359, 360, + 10, 362, -1, 364, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 376, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 388, -1, 390, + -1, -1, -1, -1, 44, -1, 262, 263, 264, -1, + -1, 267, 268, 269, -1, 271, -1, -1, -1, 59, + -1, 61, -1, 63, 280, 281, -1, -1, -1, -1, + -1, -1, -1, 289, 290, -1, 292, 293, 294, 295, + 296, -1, -1, -1, -1, -1, -1, -1, 304, 267, + -1, 91, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 317, 318, 319, 320, 321, 322, 323, 324, 325, + 326, -1, 328, 329, 292, 293, -1, -1, 334, 335, + -1, -1, -1, -1, 340, -1, -1, 343, -1, -1, + 346, -1, 348, -1, 350, 0, 352, -1, 354, 355, + 356, 357, 358, 359, 360, 10, 362, -1, 364, -1, 262, 263, 264, -1, -1, -1, 268, 269, -1, 271, - -1, -1, -1, -1, -1, -1, 389, 279, 280, -1, - -1, -1, -1, 44, -1, -1, -1, -1, 290, 291, - -1, 293, 294, 295, 296, 297, -1, -1, 59, -1, - 61, -1, 63, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 317, 318, 319, 320, 321, - 322, 323, 324, 325, 326, 327, 328, 329, 330, -1, - 91, -1, -1, 335, 336, 337, 338, -1, -1, -1, - -1, -1, 344, -1, -1, -1, -1, -1, -1, 351, - 0, 353, -1, 355, 356, 357, 358, 359, 360, 361, - 10, 363, 364, 365, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 389, -1, -1, - -1, -1, -1, -1, 44, -1, -1, 262, 263, 264, - -1, -1, -1, 268, 269, -1, 271, -1, -1, 59, - -1, 61, -1, 63, 279, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 290, 291, -1, 293, 294, - 295, 296, 297, -1, -1, -1, -1, -1, -1, -1, - -1, 91, -1, -1, -1, -1, + 376, -1, 340, -1, -1, 343, -1, -1, 346, -1, + -1, -1, 388, -1, 390, -1, -1, 289, 290, 44, + 292, 293, 294, 295, 296, -1, 364, -1, -1, -1, + -1, -1, -1, -1, 59, -1, 61, -1, 63, -1, + -1, -1, -1, -1, 316, 317, 318, 319, 320, 321, + 322, 323, 324, 325, 326, 327, 328, 329, -1, -1, + -1, -1, 334, 335, 336, 337, 91, 339, -1, -1, + -1, 343, -1, -1, -1, -1, -1, -1, 350, 0, + 352, -1, 354, 355, 356, 357, 358, 359, 360, 10, + 362, -1, 364, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 262, 263, 264, -1, -1, -1, }; } private static final short[] yyCheck3() { return new short[] { - -1, -1, -1, -1, -1, -1, 317, 318, 319, 320, - 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, - -1, -1, -1, -1, 335, 336, 337, 338, -1, 340, - -1, -1, -1, 344, -1, -1, -1, -1, -1, -1, - 351, 0, 353, -1, 355, 356, 357, 358, 359, 360, - 361, 10, 363, -1, 365, 262, 263, 264, -1, -1, - -1, 268, 269, -1, 271, -1, -1, -1, -1, -1, - -1, -1, 279, -1, -1, -1, -1, -1, 389, -1, - -1, -1, -1, 290, 291, 44, 293, 294, 295, 296, - 297, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 268, 269, -1, 271, -1, -1, -1, -1, 388, -1, + 390, -1, -1, -1, -1, 44, -1, -1, -1, -1, + -1, 289, 290, -1, 292, 293, 294, 295, 296, -1, 59, -1, 61, -1, 63, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 316, 317, + 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, + 328, 329, 91, -1, -1, -1, 334, 335, 336, 337, + -1, 339, -1, -1, -1, 343, -1, -1, -1, -1, + -1, -1, 350, 0, 352, -1, 354, 355, 356, 357, + 358, 359, 360, 10, 362, -1, 364, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 388, -1, 390, -1, -1, -1, -1, 44, -1, 262, + 263, 264, -1, -1, -1, 268, 269, -1, 271, -1, + -1, -1, 59, -1, 61, -1, 63, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 289, 290, -1, 292, + 293, 294, 295, 296, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 91, -1, -1, -1, -1, -1, + -1, -1, -1, 316, 317, 318, 319, 320, 321, 322, + 323, 324, 325, 326, 327, 328, 329, -1, -1, -1, + -1, 334, 335, 336, 337, -1, 339, -1, -1, -1, + 343, -1, -1, -1, -1, -1, -1, 350, 0, 352, + -1, 354, 355, 356, 357, 358, 359, 360, 10, 362, + -1, 364, -1, 262, 263, 264, -1, -1, -1, 268, + 269, -1, 271, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 388, -1, 390, -1, 41, + 289, 290, 44, 292, 293, 294, 295, 296, -1, -1, + -1, -1, -1, -1, -1, -1, 58, 59, -1, -1, + -1, 63, -1, -1, -1, -1, -1, 316, 317, 318, + 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, + 329, -1, -1, -1, -1, 334, 335, 336, 337, -1, + 339, -1, -1, -1, 343, -1, -1, -1, -1, -1, + -1, 350, 0, 352, -1, 354, 355, 356, 357, 358, + 359, 360, 10, 362, -1, 364, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 262, 263, 264, -1, -1, + -1, 268, 269, -1, 271, -1, -1, -1, -1, 388, + -1, 390, -1, 41, -1, -1, 44, -1, -1, -1, + -1, -1, 289, 290, -1, 292, 293, 294, 295, 296, + 58, 59, -1, -1, -1, 63, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, - 327, 328, 329, 330, -1, -1, -1, -1, 335, 336, - 337, 338, 91, 340, -1, -1, -1, 344, -1, -1, - -1, -1, -1, -1, 351, 0, 353, -1, 355, 356, - 357, 358, 359, 360, 361, 10, 363, -1, 365, -1, - -1, -1, -1, -1, -1, -1, 262, 263, 264, -1, - -1, -1, 268, 269, -1, 271, -1, -1, -1, -1, - -1, -1, 389, 279, 860, -1, -1, -1, 864, 44, - -1, -1, -1, -1, 290, 291, -1, 293, 294, 295, - 296, 297, -1, -1, 59, -1, 61, -1, 63, -1, + 327, 328, 329, -1, -1, -1, -1, 334, 335, 336, + 337, -1, 339, -1, -1, -1, 343, -1, -1, -1, + -1, -1, -1, 350, -1, 352, -1, 354, 355, 356, + 357, 358, 359, 360, -1, 362, -1, 364, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 317, 318, 319, 320, 321, 322, 323, 324, 325, - 326, 327, 328, 329, 330, -1, 91, -1, -1, 335, - 336, 337, 338, -1, 340, -1, -1, -1, 344, -1, - -1, -1, -1, -1, -1, 351, 0, 353, -1, 355, - 356, 357, 358, 359, 360, 361, 10, 363, -1, 365, + 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 10, 388, -1, 390, -1, -1, -1, -1, -1, -1, + 262, 263, 264, -1, -1, 267, 268, 269, -1, 271, + -1, -1, -1, -1, -1, -1, -1, -1, 280, 281, + -1, 41, -1, -1, 44, -1, -1, 289, 290, -1, + 292, 293, 294, 295, 296, -1, -1, -1, 58, 59, + -1, -1, 304, 63, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 316, 317, 318, 319, 320, -1, + -1, 323, 324, 325, 326, -1, 328, 329, -1, -1, + -1, -1, 334, 335, -1, -1, -1, -1, 340, -1, + -1, 343, -1, -1, 346, -1, 348, -1, 350, 0, + 352, -1, 354, 355, 356, 357, -1, -1, 360, 10, + 362, -1, 364, -1, 262, 263, 264, -1, -1, 267, + 268, 269, -1, 271, 376, -1, -1, -1, -1, -1, + -1, -1, 280, 281, -1, -1, 388, -1, 390, -1, + -1, 289, 290, 44, 292, 293, 294, 295, 296, -1, + -1, -1, -1, -1, -1, -1, 304, -1, 59, -1, + 61, -1, 63, -1, -1, -1, -1, -1, -1, 317, + 318, 319, 320, 321, 322, 323, 324, 325, 326, -1, + 328, 329, -1, -1, -1, -1, 334, 335, -1, -1, + 91, -1, 340, -1, -1, 343, -1, -1, 346, -1, + 348, -1, -1, -1, 352, 0, -1, -1, 356, 357, + 358, 359, 360, -1, 362, 10, 364, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 376, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 964, -1, - -1, -1, -1, 389, -1, -1, -1, -1, -1, -1, + 388, -1, 390, -1, -1, -1, -1, -1, -1, 44, + -1, -1, 262, 263, 264, -1, -1, 267, 268, 269, + -1, 271, -1, -1, 59, -1, 61, -1, 63, -1, + 280, 281, -1, -1, -1, -1, -1, -1, -1, 289, + 290, -1, 292, 293, 294, 295, 296, -1, -1, -1, + -1, -1, -1, -1, 304, -1, 91, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 317, 318, 319, + 320, 321, 322, 323, 324, 325, 326, -1, 328, 329, + -1, -1, -1, -1, 334, 335, -1, -1, -1, -1, + 340, -1, -1, 343, -1, -1, 346, -1, 348, -1, + -1, 0, 352, -1, -1, -1, 356, 357, 358, 359, + 360, 10, 362, -1, 364, -1, -1, -1, -1, -1, + -1, 262, 263, 264, -1, -1, 376, 268, 269, -1, + 271, -1, -1, -1, -1, -1, -1, -1, 388, -1, + 390, -1, -1, -1, -1, 44, -1, -1, 289, 290, + -1, 292, 293, 294, 295, 296, -1, -1, -1, -1, + 59, -1, 61, -1, 63, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 316, 317, 318, 319, 320, + 321, 322, 323, 324, 325, 326, 327, 328, 329, -1, + -1, -1, 91, 334, 335, 336, 337, -1, -1, -1, + -1, -1, 343, -1, -1, -1, -1, -1, -1, 350, + -1, 352, 0, 354, 355, 356, 357, 358, 359, 360, + -1, 362, 10, 364, -1, -1, -1, 262, 263, 264, + -1, -1, -1, 268, 269, -1, 271, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 388, -1, 390, + -1, -1, -1, 41, 289, 290, 44, 292, 293, 294, + 295, 296, -1, -1, -1, -1, -1, -1, -1, -1, + 58, 59, -1, -1, -1, 63, -1, -1, -1, -1, + -1, 316, 317, 318, 319, 320, 321, 322, 323, 324, + 325, 326, 327, 328, 329, -1, -1, -1, -1, 334, + 335, 336, 337, -1, -1, -1, -1, -1, 343, -1, + -1, -1, -1, -1, -1, 350, 0, 352, -1, 354, + 355, 356, 357, 358, 359, 360, 10, 362, -1, 364, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 388, -1, 390, -1, 41, -1, -1, 44, -1, -1, 262, 263, 264, -1, -1, -1, 268, - 269, -1, 271, -1, -1, 59, -1, 61, -1, 63, - 279, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 290, 291, -1, 293, 294, 295, 296, 297, -1, - -1, 1017, -1, 1019, -1, 1021, -1, 91, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 317, 318, + 269, -1, 271, -1, 58, 59, -1, -1, -1, 63, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 289, 290, -1, 292, 293, 294, 295, 296, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, - 329, 330, -1, -1, -1, -1, 335, 336, 337, 338, - -1, 340, -1, -1, -1, 344, -1, -1, 1064, -1, - -1, -1, 351, 0, 353, 1071, 355, 356, 357, 358, - 359, 360, 361, 10, 363, -1, 365, 262, 263, 264, - -1, -1, -1, 268, 269, -1, 271, -1, -1, -1, - 1096, -1, -1, -1, 279, -1, -1, -1, -1, -1, - 389, -1, -1, -1, -1, 290, 291, 44, 293, 294, - 295, 296, 297, -1, 1120, -1, 1122, -1, -1, 1125, - -1, -1, 59, -1, 61, -1, 63, -1, -1, -1, - 1136, -1, 317, 318, 319, 320, 321, 322, 323, 324, - 325, 326, 327, 328, 329, 330, -1, -1, -1, -1, - 335, 336, 337, 338, 91, 340, -1, -1, -1, 344, - -1, -1, -1, -1, -1, -1, 351, 0, 353, -1, - 355, 356, 357, 358, 359, 360, 361, 10, 363, -1, - 365, -1, -1, -1, -1, -1, -1, -1, 262, 263, - 264, -1, -1, -1, 268, 269, -1, 271, -1, -1, - -1, -1, -1, -1, 389, 279, -1, -1, -1, -1, - -1, 44, -1, -1, -1, -1, 290, 291, -1, 293, - 294, 295, 296, 297, -1, -1, 59, -1, 61, -1, - 63, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 329, -1, -1, -1, -1, 334, 335, 336, 337, -1, + -1, -1, -1, -1, 343, -1, -1, -1, -1, -1, + -1, 350, -1, 352, 0, 354, 355, 356, 357, 358, + 359, 360, -1, 362, 10, 364, -1, -1, -1, -1, + -1, -1, -1, -1, 262, 263, 264, -1, -1, 267, + 268, 269, -1, 271, -1, -1, -1, -1, -1, 388, + -1, 390, 280, 281, -1, 41, -1, -1, 44, -1, + -1, 289, 290, -1, 292, 293, 294, 295, 296, -1, + -1, -1, 58, 59, -1, -1, 304, 63, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 317, + 318, 319, 320, 321, 322, 323, 324, 325, 326, -1, + 328, 329, -1, -1, -1, -1, 334, 335, -1, -1, + -1, -1, 340, -1, -1, 343, -1, -1, 346, -1, + 348, -1, -1, -1, 352, -1, -1, -1, -1, -1, + 358, 359, 360, -1, 362, -1, 364, -1, 262, 263, + 264, -1, -1, 267, 268, 269, -1, 271, 376, -1, + -1, -1, -1, -1, -1, -1, 280, 281, -1, -1, + 388, -1, 390, -1, -1, 289, 290, -1, 292, 293, + 294, 295, 296, -1, 0, -1, -1, -1, -1, -1, + 304, -1, -1, -1, 10, -1, -1, -1, -1, -1, -1, -1, -1, 317, 318, 319, 320, 321, 322, 323, - 324, 325, 326, 327, 328, 329, 330, -1, 91, -1, - -1, 335, 336, 337, 338, -1, 340, -1, -1, -1, - 344, -1, -1, -1, -1, -1, -1, 351, 0, 353, - -1, 355, 356, 357, 358, 359, 360, 361, 10, 363, - -1, 365, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 389, -1, -1, -1, -1, - -1, -1, 44, -1, -1, 262, 263, 264, -1, -1, - -1, 268, 269, -1, 271, -1, -1, 59, -1, 61, - -1, 63, 279, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 290, 291, -1, 293, 294, 295, 296, - 297, -1, -1, -1, -1, -1, -1, -1, -1, 91, + 324, 325, 326, -1, 328, 329, -1, -1, -1, -1, + 334, 335, -1, -1, -1, 41, 340, -1, 44, 343, + -1, -1, 346, -1, 348, -1, -1, -1, 352, -1, + -1, -1, 58, 59, 358, 359, 360, 63, 362, -1, + 364, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 376, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 388, -1, 390, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 262, 263, 264, -1, + -1, 267, 268, 269, -1, 271, -1, -1, -1, -1, + -1, -1, -1, -1, 280, 281, -1, -1, -1, -1, + -1, -1, -1, 289, 290, 0, 292, 293, 294, 295, + 296, -1, -1, -1, -1, 10, -1, -1, 304, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, - 327, 328, 329, 330, -1, -1, -1, -1, 335, 336, - 337, 338, -1, 340, -1, -1, -1, 344, -1, -1, - -1, -1, -1, -1, 351, 0, 353, -1, 355, 356, - 357, 358, 359, 360, 361, 10, 363, -1, 365, 262, - 263, 264, -1, -1, -1, 268, 269, -1, 271, -1, - -1, -1, -1, -1, -1, -1, 279, -1, -1, -1, - -1, -1, 389, -1, -1, -1, -1, 290, 291, 44, - 293, 294, 295, 296, 297, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 59, -1, 61, -1, 63, -1, - -1, -1, -1, -1, 317, 318, 319, 320, 321, 322, - 323, 324, 325, 326, 327, 328, 329, 330, -1, -1, - -1, -1, 335, 336, 337, 338, 91, 340, -1, -1, - -1, 344, -1, -1, -1, -1, -1, -1, 351, 0, - 353, -1, 355, 356, 357, 358, 359, 360, 361, 10, - 363, -1, 365, -1, -1, -1, -1, -1, -1, -1, - 262, 263, 264, -1, -1, -1, 268, 269, -1, 271, - -1, -1, -1, -1, -1, -1, 389, 279, -1, -1, - -1, -1, -1, 44, -1, -1, -1, -1, 290, 291, - -1, 293, 294, 295, 296, 297, -1, 58, 59, -1, - -1, -1, 63, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 317, 318, 319, 320, 321, - 322, 323, 324, 325, 326, 327, 328, 329, 330, -1, - -1, -1, -1, 335, 336, 337, 338, -1, 340, -1, - -1, -1, 344, -1, -1, -1, -1, -1, -1, 351, - 0, 353, -1, 355, 356, 357, 358, 359, 360, 361, - 10, 363, -1, 365, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 389, -1, -1, - -1, -1, -1, -1, 44, -1, -1, 262, 263, 264, - -1, -1, -1, 268, 269, -1, 271, -1, -1, 59, - -1, 61, -1, 63, 279, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 290, 291, -1, 293, 294, - 295, 296, 297, -1, -1, -1, -1, -1, -1, -1, - -1, 91, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 317, 318, 319, 320, 321, 322, 323, 324, - 325, 326, 327, 328, 329, 330, -1, -1, -1, -1, - 335, 336, 337, 338, -1, 340, -1, -1, -1, 344, - -1, -1, -1, -1, -1, -1, 351, 0, 353, -1, - 355, 356, 357, 358, 359, 360, 361, 10, 363, -1, - 365, 262, 263, 264, -1, -1, 267, 268, 269, -1, - 271, -1, -1, -1, -1, -1, -1, -1, 279, -1, - 281, 282, -1, -1, 389, -1, -1, -1, -1, 290, - 291, 44, 293, 294, 295, 296, 297, -1, -1, -1, - -1, -1, -1, -1, 305, -1, 59, -1, 61, -1, - 63, -1, -1, -1, -1, -1, 317, 318, 319, 320, - 321, -1, -1, 324, 325, 326, 327, -1, 329, 330, - -1, -1, -1, -1, 335, 336, -1, -1, 91, -1, - 341, -1, -1, 344, -1, -1, 347, -1, 349, -1, - 351, 0, 353, -1, 355, 356, 357, 358, -1, -1, - 361, 10, 363, -1, 365, -1, -1, -1, -1, -1, - -1, -1, 262, 263, 264, -1, 377, -1, 268, 269, - -1, 271, -1, -1, -1, -1, -1, -1, 389, 279, - -1, -1, -1, -1, -1, 44, -1, -1, -1, -1, - 290, 291, -1, 293, 294, 295, 296, 297, -1, 58, - 59, -1, -1, -1, 63, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 317, 318, 319, - 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, - 330, -1, -1, -1, -1, 335, 336, 337, 338, -1, - -1, -1, -1, -1, 344, -1, -1, -1, -1, -1, - -1, 351, 0, 353, -1, 355, 356, 357, 358, 359, - 360, 361, 10, 363, -1, 365, -1, -1, -1, -1, + -1, 317, 318, 319, 320, 321, 322, 323, 324, 325, + 326, -1, 328, 329, -1, -1, 41, -1, -1, 44, + -1, -1, -1, -1, 340, -1, -1, 343, -1, -1, + 346, -1, 348, 58, 59, -1, 352, -1, 63, -1, + -1, -1, 358, 359, 360, -1, 362, -1, 364, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 389, - -1, -1, -1, -1, -1, -1, 44, -1, -1, 262, - 263, 264, -1, -1, -1, 268, 269, -1, 271, -1, - 58, 59, -1, -1, -1, 63, 279, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 290, 291, -1, - 293, 294, 295, 296, 297, -1, -1, 10, -1, -1, + 376, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 388, -1, 390, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 0, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 10, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 262, 263, 264, -1, + -1, 267, 268, 269, -1, 271, -1, -1, -1, -1, + -1, -1, -1, -1, 280, 281, -1, 41, -1, -1, + 44, -1, -1, 289, 290, -1, 292, 293, 294, 295, + 296, -1, -1, -1, 58, 59, -1, -1, 304, 63, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 317, 318, 319, 320, 321, 322, - 323, 324, 325, 326, 327, 328, 329, 330, -1, -1, - -1, 44, 335, 336, 337, 338, -1, -1, -1, -1, - -1, 344, -1, -1, -1, -1, 59, -1, 351, 0, - 353, -1, 355, 356, 357, 358, 359, 360, 361, 10, - 363, -1, 365, 262, 263, 264, -1, -1, 267, 268, - 269, -1, 271, -1, -1, -1, -1, -1, 91, -1, - 279, -1, 281, 282, -1, -1, 389, -1, -1, -1, - -1, 290, 291, 44, 293, 294, 295, 296, 297, -1, - -1, -1, -1, -1, -1, -1, 305, -1, 59, -1, - 61, -1, 63, -1, -1, -1, -1, -1, -1, 318, - 319, 320, 321, 322, 323, 324, 325, 326, 327, -1, - 329, 330, -1, -1, -1, -1, 335, 336, -1, -1, - 91, -1, 341, -1, -1, 344, -1, -1, 347, -1, - 349, -1, -1, 0, 353, -1, -1, -1, 357, 358, - 359, 360, 361, 10, 363, -1, 365, -1, -1, -1, - -1, -1, -1, -1, 262, 263, 264, -1, 377, 267, - 268, 269, -1, 271, -1, -1, -1, -1, -1, -1, - 389, 279, -1, 281, 282, -1, -1, 44, -1, -1, - -1, -1, 290, 291, -1, 293, 294, 295, 296, 297, - -1, 58, 59, -1, -1, -1, 63, 305, -1, -1, + -1, 317, 318, 319, 320, 321, 322, 323, 324, 325, + 326, -1, 328, 329, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 340, -1, -1, 343, -1, 0, + 346, -1, 348, -1, -1, -1, -1, -1, -1, 10, + -1, -1, 358, 359, 360, -1, 362, -1, 364, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, - -1, 329, 330, -1, -1, -1, -1, 335, 336, -1, - -1, -1, -1, 341, -1, -1, 344, -1, -1, 347, - -1, 349, -1, -1, 0, 353, -1, 280, -1, 357, - 358, 359, 360, 361, 10, 363, -1, 365, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 377, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 389, -1, -1, -1, -1, -1, -1, 44, -1, - -1, 262, 263, 264, -1, 328, -1, 268, 269, -1, - 271, -1, 58, 59, 337, 338, -1, 63, 279, -1, - 343, -1, -1, -1, -1, -1, -1, -1, -1, 290, - 291, -1, 293, 294, 295, 296, 297, -1, 361, -1, - -1, 364, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 317, 318, 319, 320, - 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, - -1, -1, -1, -1, 335, 336, 337, 338, -1, -1, - -1, -1, -1, 344, -1, -1, -1, -1, -1, -1, - 351, 0, 353, -1, 355, 356, 357, 358, 359, 360, - 361, 10, 363, -1, 365, 262, 263, 264, -1, -1, - 267, 268, 269, -1, 271, -1, -1, -1, -1, -1, - -1, -1, 279, -1, 281, 282, -1, -1, 389, -1, - -1, -1, -1, 290, 291, 44, 293, 294, 295, 296, - 297, -1, -1, -1, -1, -1, -1, -1, 305, 58, - 59, -1, -1, -1, 63, -1, -1, -1, -1, -1, - -1, 318, 319, 320, 321, 322, 323, 324, 325, 326, - 327, -1, 329, 330, -1, -1, -1, -1, 335, 336, - -1, -1, -1, -1, 341, -1, -1, 344, -1, -1, - 347, -1, 349, -1, -1, 0, 353, -1, -1, -1, - -1, -1, 359, 360, 361, 10, 363, -1, 365, -1, - -1, -1, -1, -1, -1, -1, 262, 263, 264, -1, - 377, 267, 268, 269, -1, 271, -1, -1, -1, -1, - -1, -1, 389, 279, -1, 281, 282, -1, -1, 44, - -1, -1, -1, -1, 290, 291, -1, 293, 294, 295, - 296, 297, -1, 58, 59, -1, -1, -1, 63, 305, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 318, 319, 320, 321, 322, 323, 324, 325, - 326, 327, -1, 329, 330, -1, -1, -1, -1, 335, - 336, -1, -1, -1, -1, 341, -1, -1, 344, -1, - -1, 347, -1, 349, -1, -1, 0, 353, -1, -1, - -1, -1, -1, 359, 360, 361, 10, 363, -1, 365, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 377, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 389, -1, -1, 10, -1, -1, -1, - 44, -1, -1, 262, 263, 264, -1, -1, 267, 268, - 269, -1, 271, -1, 58, 59, -1, -1, -1, 63, - 279, -1, 281, 282, -1, -1, -1, -1, -1, -1, - 44, 290, 291, -1, 293, 294, 295, 296, 297, -1, - -1, -1, -1, -1, -1, 59, 305, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 318, - 319, 320, 321, 322, 323, 324, 325, 326, 327, -1, - 329, 330, -1, -1, -1, -1, -1, 91, -1, -1, - -1, -1, 341, -1, -1, 344, -1, -1, 347, 0, - 349, -1, -1, -1, 353, -1, -1, -1, -1, 10, - 359, 360, 361, -1, 363, -1, 365, 262, 263, 264, - -1, -1, 267, 268, 269, -1, 271, -1, 377, -1, - -1, -1, -1, -1, 279, -1, 281, 282, -1, -1, - 389, -1, -1, 44, -1, 290, 291, -1, 293, 294, - 295, 296, 297, -1, -1, -1, -1, 58, 59, -1, - 305, -1, 63, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 318, 319, 320, 321, 322, 323, 324, - 325, 326, 327, -1, 329, 330, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 341, -1, -1, 344, - -1, -1, 347, -1, 349, -1, -1, -1, -1, -1, - -1, 0, -1, -1, 359, 360, 361, -1, 363, -1, - 365, 10, -1, -1, -1, -1, -1, -1, 262, 263, - 264, -1, 377, 267, 268, 269, -1, 271, -1, -1, - -1, -1, -1, -1, 389, 279, -1, 281, 282, -1, - -1, -1, -1, -1, -1, 44, 290, 291, -1, 293, - 294, 295, 296, 297, -1, -1, -1, -1, -1, 58, - 59, 305, -1, -1, 63, -1, 280, -1, -1, -1, - -1, -1, -1, -1, 318, 319, 320, 321, 322, 323, - 324, 325, 326, 327, -1, 329, 330, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 341, -1, -1, - 344, -1, -1, 347, -1, 349, -1, -1, -1, -1, - -1, -1, -1, -1, 328, 359, 360, 361, 0, 363, - -1, 365, -1, 337, 338, -1, -1, -1, 10, 343, - -1, -1, -1, 377, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 389, -1, 361, -1, -1, + 376, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 41, -1, 388, 44, 390, -1, -1, 262, 263, 264, + -1, -1, 267, 268, 269, -1, 271, 58, 59, -1, + -1, -1, 63, -1, -1, 280, 281, -1, -1, -1, + -1, -1, -1, -1, 289, 290, -1, 292, 293, 294, + 295, 296, -1, -1, -1, -1, -1, -1, -1, 304, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 317, 318, 319, 320, 321, 322, 323, 324, + 325, 326, -1, 328, 329, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 340, -1, -1, 343, -1, + -1, 346, -1, 348, -1, -1, -1, -1, 0, -1, + -1, -1, -1, 358, 359, 360, -1, 362, 10, 364, + -1, -1, -1, -1, -1, -1, -1, -1, 262, 263, + 264, 376, -1, 267, 268, 269, -1, 271, -1, -1, + -1, -1, -1, 388, -1, 390, 280, 281, -1, 41, + -1, -1, 44, -1, -1, 289, 290, -1, 292, 293, + 294, 295, 296, -1, -1, -1, 58, 59, -1, -1, + 304, 63, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 317, 318, 319, 320, 321, 322, 323, + 324, 325, 326, -1, 328, 329, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 340, -1, -1, 343, + -1, 0, 346, -1, 348, -1, -1, -1, -1, -1, + -1, 10, -1, -1, 358, 359, -1, -1, -1, -1, 364, 262, 263, 264, -1, -1, 267, 268, 269, -1, - 271, -1, 44, -1, -1, -1, -1, -1, 279, -1, - 281, 282, -1, -1, -1, -1, 58, 59, -1, 290, - 291, 63, 293, 294, 295, 296, 297, -1, -1, -1, - -1, -1, -1, -1, 305, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 318, 319, 320, - 321, 322, 323, 324, 325, 326, 327, -1, 329, 330, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 341, -1, -1, 344, -1, -1, 347, -1, 349, -1, - -1, 0, -1, -1, -1, -1, -1, -1, 359, 360, - -1, 10, -1, -1, 365, -1, -1, -1, -1, -1, - -1, -1, -1, 262, 263, 264, 377, -1, 267, 268, - 269, -1, 271, -1, -1, -1, -1, -1, 389, -1, - 279, -1, 281, 282, -1, 44, -1, -1, -1, -1, - -1, 290, 291, -1, 293, 294, 295, 296, 297, 58, - 59, -1, -1, -1, 63, -1, 305, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 318, - 319, 320, 321, 322, 323, 324, 325, 326, 327, -1, - 329, 330, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 341, -1, -1, 344, -1, -1, 347, -1, - 349, -1, -1, -1, -1, -1, -1, -1, 0, -1, - 359, 360, -1, -1, -1, -1, 365, -1, 10, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 377, -1, + 271, -1, 376, -1, -1, -1, -1, -1, -1, 280, + 281, -1, 41, -1, 388, 44, 390, -1, 289, 290, + -1, 292, 293, 294, 295, 296, -1, -1, -1, 58, + 59, -1, -1, 304, 63, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 317, 318, 319, 320, + 321, 322, 323, 324, 325, 326, -1, 328, 329, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 340, + -1, -1, 343, -1, -1, 346, -1, 348, -1, -1, + -1, -1, 0, -1, -1, -1, -1, 358, 359, -1, + -1, -1, 10, 364, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 376, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 388, -1, 390, + -1, -1, -1, 41, -1, -1, 44, -1, -1, -1, 262, 263, 264, -1, -1, 267, 268, 269, -1, 271, - 389, -1, -1, -1, -1, -1, -1, 279, -1, 281, - 282, -1, 44, -1, -1, -1, -1, -1, 290, 291, - -1, 293, 294, 295, 296, 297, 58, 59, -1, -1, - -1, 63, -1, 305, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 324, 325, -1, -1, -1, 329, 330, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 0, 341, - -1, -1, 344, -1, -1, 347, -1, 349, 10, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 365, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 377, -1, -1, -1, -1, - -1, -1, 44, 262, 263, 264, -1, 389, 267, 268, - 269, -1, 271, -1, -1, -1, 58, 59, -1, -1, - 279, 63, 281, 282, -1, -1, -1, -1, -1, -1, - -1, 290, 291, -1, 293, 294, 295, 296, 297, -1, - -1, -1, -1, -1, -1, -1, 305, -1, -1, 0, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 10, - -1, -1, -1, -1, -1, 324, 325, -1, -1, -1, - 329, 330, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 341, -1, -1, 344, -1, -1, 347, -1, - 349, -1, -1, 44, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 365, 58, 59, -1, - -1, -1, 63, 0, -1, -1, -1, -1, 377, -1, - 262, 263, 264, 10, -1, 267, 268, 269, -1, 271, - 389, -1, -1, -1, -1, -1, -1, 279, -1, 281, - 282, -1, -1, -1, -1, -1, -1, -1, 290, 291, - -1, 293, 294, 295, 296, 297, -1, 44, -1, -1, - -1, -1, -1, 305, -1, -1, -1, -1, -1, -1, - -1, -1, 59, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 324, 325, -1, -1, -1, 329, 330, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 0, 341, - -1, -1, 344, -1, -1, 347, -1, 349, 10, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 262, 263, 264, 365, -1, 267, 268, 269, -1, 271, - -1, -1, -1, -1, -1, 377, -1, 279, -1, 281, - 282, -1, 44, -1, -1, -1, -1, 389, 290, 291, - -1, 293, 294, 295, 296, 297, 58, 59, -1, -1, - -1, 63, -1, 305, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 324, 325, -1, -1, -1, 329, 330, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 341, - -1, -1, 344, -1, -1, 347, -1, 349, -1, 0, - -1, 262, 263, 264, -1, -1, 267, 268, 269, 10, - 271, -1, -1, 365, -1, -1, -1, -1, 279, -1, - 281, 282, -1, -1, -1, 377, -1, -1, -1, 290, - 291, -1, 293, 294, 295, 296, 297, 389, -1, -1, - -1, -1, -1, 44, 305, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 58, 59, -1, - -1, -1, 63, 324, 325, 262, 263, 264, 329, 330, - -1, 268, 269, -1, 271, -1, -1, -1, -1, -1, - 341, -1, 279, 344, -1, -1, 347, -1, 349, -1, - 0, -1, -1, 290, 291, -1, 293, 294, 295, 296, - 10, -1, -1, -1, 365, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 377, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 389, -1, - -1, -1, -1, -1, 44, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 344, 58, 59, - 262, 263, 264, 63, -1, 267, 268, 269, -1, 271, - -1, -1, -1, -1, -1, -1, -1, 279, 365, 281, - 282, -1, -1, -1, -1, -1, -1, -1, 290, 291, - 0, 293, 294, 295, 296, 297, -1, -1, -1, -1, - 10, -1, 389, 305, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 324, 325, -1, -1, -1, 329, 330, -1, - -1, -1, -1, -1, 44, -1, -1, -1, -1, 341, - -1, -1, 344, -1, -1, 347, -1, 349, 58, 59, - -1, -1, -1, 63, 0, -1, -1, -1, -1, -1, - -1, -1, -1, 365, 10, -1, -1, -1, -1, -1, - -1, 262, 263, 264, -1, 377, 267, 268, 269, -1, - 271, -1, -1, -1, -1, -1, -1, 389, 279, -1, - 281, 282, -1, -1, -1, -1, -1, -1, 44, 290, - 291, -1, 293, 294, 295, 296, 297, -1, -1, -1, - -1, -1, 58, 59, 305, -1, -1, 63, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 324, 325, -1, -1, -1, 329, 330, + 58, 59, -1, -1, -1, 63, -1, -1, 280, 281, + -1, -1, -1, -1, -1, -1, -1, 289, 290, -1, + 292, 293, 294, 295, 296, -1, -1, -1, -1, -1, + -1, -1, 304, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 323, 324, -1, -1, -1, 328, 329, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 340, -1, + -1, 343, -1, 0, 346, -1, 348, -1, -1, -1, + -1, -1, -1, 10, -1, -1, -1, -1, -1, -1, + -1, -1, 364, 262, 263, 264, -1, -1, 267, 268, + 269, -1, 271, -1, 376, -1, -1, -1, -1, -1, + -1, 280, 281, -1, 41, -1, 388, 44, 390, -1, + 289, 290, -1, 292, 293, 294, 295, 296, -1, -1, + -1, 58, 59, -1, -1, 304, 63, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 323, 324, -1, -1, -1, 328, + 329, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 340, -1, -1, 343, -1, -1, 346, -1, 348, -1, -1, -1, -1, 0, -1, -1, -1, -1, -1, - 341, -1, -1, 344, 10, -1, 347, -1, 349, -1, - -1, -1, 262, 263, 264, -1, -1, 267, 268, 269, - -1, 271, -1, -1, 365, -1, -1, -1, -1, 279, - -1, 281, 282, -1, -1, -1, 377, -1, 44, -1, - 290, 291, -1, 293, 294, 295, 296, 297, 389, -1, - -1, -1, 58, 59, -1, 305, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 325, -1, -1, -1, 329, - 330, -1, 0, -1, -1, -1, -1, -1, -1, -1, - -1, 341, 10, -1, 344, -1, -1, 347, -1, 349, - -1, -1, 262, 263, 264, -1, -1, 267, 268, 269, - -1, 271, -1, -1, -1, 365, -1, -1, -1, 279, - -1, 281, 282, -1, -1, -1, 44, 377, -1, -1, - 290, 291, -1, 293, 294, 295, 296, 297, -1, 389, - 58, 59, -1, -1, -1, 305, -1, -1, -1, -1, + -1, -1, -1, -1, 10, 364, -1, -1, -1, -1, + -1, -1, -1, -1, 262, 263, 264, 376, -1, 267, + 268, 269, -1, 271, -1, -1, -1, -1, -1, 388, + -1, 390, 280, 281, -1, 41, -1, -1, 44, -1, + -1, 289, 290, -1, 292, 293, 294, 295, 296, -1, + -1, -1, 58, 59, -1, -1, 304, 63, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 262, 263, 264, -1, + -1, -1, -1, -1, -1, 323, 324, -1, -1, -1, + 328, 329, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 340, -1, -1, 343, -1, 0, 346, -1, + 348, -1, -1, -1, -1, -1, -1, 10, -1, -1, + -1, -1, -1, -1, -1, -1, 364, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 376, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 41, -1, + 388, 44, 390, -1, -1, 262, 263, 264, -1, -1, + 267, 268, 269, -1, 271, 58, 59, -1, -1, -1, + 63, -1, -1, 280, 281, -1, -1, -1, -1, -1, + -1, -1, 289, 290, -1, 292, 293, 294, 295, 296, + -1, -1, -1, -1, -1, -1, 0, 304, -1, -1, + -1, -1, -1, -1, -1, -1, 10, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 323, 324, -1, -1, + -1, 328, 329, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 340, -1, -1, 343, 41, -1, 346, + 44, 348, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 58, 59, -1, 364, -1, 63, + -1, -1, -1, -1, -1, -1, 262, 263, 264, 376, -1, 267, 268, 269, -1, 271, -1, -1, -1, -1, - -1, 341, 0, 279, 344, 281, 282, 347, -1, 349, - -1, -1, 10, -1, 290, 291, -1, 293, 294, 295, - 296, 297, -1, -1, -1, 365, -1, -1, -1, 305, - -1, -1, -1, -1, -1, -1, -1, 377, -1, -1, - -1, -1, -1, -1, -1, -1, 44, -1, -1, 389, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 58, 59, -1, -1, -1, 341, -1, -1, 344, -1, - -1, 347, -1, 349, -1, -1, 262, 263, 264, -1, - -1, 267, 268, 269, -1, 271, -1, -1, -1, 365, - 0, -1, -1, 279, -1, 281, 282, -1, -1, -1, - 10, 377, -1, -1, 290, 291, -1, 293, 294, 295, - 296, 297, -1, 389, -1, -1, -1, -1, -1, 305, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 44, -1, -1, -1, -1, -1, + -1, 388, -1, 390, 280, 281, -1, -1, -1, -1, + -1, -1, -1, 289, 290, -1, 292, 293, 294, 295, + 296, -1, 0, -1, -1, -1, -1, -1, 304, -1, + -1, -1, 10, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 323, 324, -1, + -1, -1, 328, 329, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 41, 340, -1, 44, 343, -1, -1, + 346, -1, 348, -1, -1, -1, -1, -1, -1, -1, + 58, 59, -1, -1, -1, 63, -1, -1, 364, 262, + 263, 264, -1, -1, 267, 268, 269, -1, 271, -1, + 376, -1, -1, -1, -1, -1, -1, 280, 281, -1, + -1, -1, 388, -1, 390, -1, 289, 290, -1, 292, + 293, 294, 295, 296, -1, -1, -1, -1, -1, -1, + -1, 304, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 323, 324, -1, -1, -1, 328, 329, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 340, -1, -1, + 343, -1, 0, 346, 928, 348, -1, -1, 262, 263, + 264, -1, 10, 267, 268, 269, -1, 271, -1, -1, + -1, 364, -1, -1, -1, -1, 280, 281, -1, -1, + -1, -1, -1, 376, -1, 289, 290, -1, 292, 293, + 294, 295, 296, 41, -1, 388, 44, 390, -1, -1, + 304, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 58, 59, -1, -1, -1, 63, -1, 0, -1, 323, + 324, -1, -1, -1, 328, 329, -1, 10, -1, -1, + -1, -1, -1, -1, 1008, 1009, 340, -1, 1012, 343, + -1, -1, 346, -1, 348, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, + 364, 44, -1, -1, 262, 263, 264, -1, 10, 267, + 268, 269, 376, 271, 1048, -1, 59, -1, -1, -1, + -1, -1, 280, 281, 388, -1, 390, -1, -1, -1, + -1, 289, 290, -1, 292, 293, 294, 295, 296, 41, + -1, -1, 44, -1, -1, -1, 304, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 58, 59, -1, -1, + -1, 63, -1, -1, -1, -1, 324, 1101, -1, -1, + 328, 329, 1106, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 340, -1, -1, 343, -1, 0, 346, -1, + 348, -1, 1126, 1127, 1128, 1129, -1, 10, -1, 1133, + 1134, -1, 1136, -1, -1, -1, 364, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 376, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 41, -1, + 388, 44, 390, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 58, 59, -1, 0, -1, + 63, -1, -1, -1, 262, 263, 264, -1, 10, 267, + 268, 269, -1, 271, -1, -1, -1, -1, -1, -1, + -1, -1, 280, 281, -1, -1, -1, -1, -1, -1, + -1, 289, 290, -1, 292, 293, 294, 295, 296, 41, + -1, -1, 44, -1, -1, -1, 304, -1, -1, -1, + -1, -1, -1, -1, 1238, -1, 58, 59, -1, -1, + 1244, 63, -1, -1, -1, -1, -1, 1251, -1, 262, + 263, 264, -1, -1, 267, 268, 269, -1, 271, -1, + -1, -1, 340, -1, 1268, 343, -1, -1, 346, -1, + 348, -1, -1, -1, -1, -1, -1, -1, 1282, 292, + 293, 294, 295, 296, 0, -1, 364, -1, -1, -1, + 262, 263, 264, -1, 10, 267, 268, 269, 376, 271, + -1, -1, -1, -1, -1, -1, -1, -1, 280, 281, + 388, -1, 390, -1, -1, -1, -1, 289, 290, -1, + 292, 293, 294, 295, 296, 41, -1, 340, 44, -1, + 343, -1, 304, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 58, 59, -1, -1, -1, -1, -1, -1, + -1, 364, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 340, -1, + -1, 343, -1, 0, 346, 388, 348, 390, -1, 262, + 263, 264, -1, 10, 267, 268, 269, -1, 271, -1, + -1, -1, 364, -1, -1, -1, -1, 280, 281, -1, + -1, -1, -1, -1, 376, -1, 289, 290, -1, 292, + 293, 294, 295, 296, 41, -1, 388, 44, 390, -1, + -1, 304, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 58, 59, -1, -1, -1, -1, -1, -1, -1, + 262, 263, 264, -1, -1, 267, 268, 269, -1, 271, + -1, -1, -1, -1, -1, -1, -1, 340, 280, 281, + 343, -1, -1, 346, -1, 348, -1, 289, 290, -1, + 292, 293, 294, 295, 296, -1, 0, -1, -1, -1, + -1, 364, 304, -1, -1, -1, 10, -1, -1, -1, + -1, -1, -1, 376, -1, -1, -1, -1, -1, -1, + -1, -1, 928, -1, -1, 388, -1, 390, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 41, 340, -1, + 44, 343, -1, -1, 346, -1, 348, -1, -1, -1, + -1, -1, -1, -1, 58, 59, -1, -1, -1, -1, + 0, -1, 364, -1, -1, -1, 262, 263, 264, -1, + 10, 267, 268, 269, 376, 271, -1, -1, -1, -1, + -1, -1, -1, -1, 280, 281, 388, -1, 390, -1, + -1, -1, -1, 289, 290, -1, 292, 293, 294, 295, + 296, 41, 1008, 1009, 44, -1, 1012, -1, 304, -1, -1, -1, -1, -1, -1, -1, -1, -1, 58, 59, - -1, -1, -1, -1, -1, 341, -1, -1, 344, -1, - -1, 347, -1, 349, 262, 263, 264, -1, -1, 267, - 268, 269, -1, 271, -1, -1, -1, -1, 0, 365, - -1, 279, -1, 281, 282, -1, -1, -1, 10, -1, - -1, 377, 290, 291, -1, 293, 294, 295, 296, 297, - -1, -1, -1, 389, -1, -1, -1, 305, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 44, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 59, -1, -1, - -1, -1, 0, 341, -1, -1, 344, -1, -1, 347, - -1, 349, 10, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 262, 263, 264, 365, -1, 267, - 268, 269, -1, 271, -1, -1, -1, -1, -1, 377, - -1, 279, -1, 281, 282, -1, 44, -1, -1, -1, - -1, 389, 290, 291, -1, 293, 294, 295, 296, 297, - 58, 59, -1, -1, -1, -1, 0, 305, -1, -1, - -1, -1, -1, -1, -1, -1, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 1048, -1, 340, -1, -1, 343, -1, 0, + 346, -1, 348, -1, -1, 262, 263, 264, -1, 10, + 267, 268, 269, -1, 271, -1, -1, -1, 364, -1, + -1, -1, -1, 280, 281, -1, -1, -1, -1, -1, + 376, -1, 289, 290, -1, 292, 293, 294, 295, 296, + 41, -1, 388, 44, 390, 1101, -1, 304, -1, -1, + 1106, -1, -1, -1, -1, -1, -1, 58, 59, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 341, -1, -1, 344, -1, -1, 347, - 44, 349, 262, 263, 264, -1, -1, 267, 268, 269, - -1, 271, -1, -1, -1, 59, 0, 365, -1, 279, - -1, 281, 282, -1, -1, -1, 10, -1, -1, 377, - 290, 291, -1, 293, 294, 295, 296, 297, -1, -1, - -1, 389, -1, -1, -1, 305, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 0, -1, -1, -1, - 44, -1, -1, -1, -1, -1, 10, -1, -1, -1, - -1, -1, -1, -1, -1, 59, -1, -1, -1, -1, - -1, 341, -1, -1, 344, -1, -1, 347, -1, 349, - 262, 263, 264, -1, -1, 267, 268, 269, -1, 271, - -1, -1, -1, -1, -1, 365, -1, 279, -1, 281, - 282, -1, -1, -1, -1, 59, -1, 377, 290, 291, - 0, 293, 294, 295, 296, 297, -1, -1, -1, 389, - 10, -1, -1, 305, -1, -1, -1, -1, -1, -1, + 1126, 1127, 1128, 1129, -1, -1, -1, 1133, 1134, -1, + 1136, -1, -1, 340, -1, -1, 343, -1, 0, 346, + -1, 348, -1, -1, -1, -1, -1, -1, 10, -1, + -1, -1, -1, -1, -1, -1, -1, 364, 262, 263, + 264, -1, -1, 267, 268, 269, -1, 271, -1, 376, + -1, -1, -1, -1, -1, -1, 280, 281, -1, 41, + -1, 388, 44, 390, -1, 289, 290, -1, 292, 293, + 294, 295, 296, -1, -1, -1, -1, 59, -1, -1, + 304, -1, 0, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 10, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 262, 263, 264, -1, -1, 267, 268, 269, + -1, 271, 1238, -1, -1, -1, 340, -1, 1244, 343, + 280, 281, 346, 41, 348, 1251, 44, -1, -1, 289, + 290, -1, 292, 293, 294, 295, 296, -1, -1, -1, + 364, 59, 1268, -1, 304, -1, -1, -1, -1, -1, + -1, -1, 376, -1, -1, -1, 1282, -1, -1, -1, + -1, -1, -1, -1, 388, -1, 390, -1, -1, -1, + -1, -1, 0, -1, -1, -1, -1, -1, -1, -1, + 340, -1, 10, 343, -1, -1, 346, -1, 348, -1, + -1, 262, 263, 264, -1, -1, 267, 268, 269, -1, + 271, -1, -1, -1, 364, -1, -1, -1, -1, 280, + 281, -1, -1, 41, -1, 0, 376, -1, 289, 290, + -1, 292, 293, 294, 295, 10, -1, -1, 388, -1, + 390, 59, -1, 304, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 41, -1, -1, -1, + -1, 0, -1, -1, -1, -1, -1, -1, -1, 340, + -1, 10, 343, -1, 59, 346, -1, 348, -1, -1, + 262, 263, 264, -1, -1, 267, 268, 269, -1, 271, + -1, -1, -1, 364, -1, -1, -1, -1, 280, 281, + -1, -1, 41, -1, -1, 376, -1, 289, 290, -1, + 292, 293, 294, 295, 296, -1, -1, 388, -1, 390, + 59, -1, -1, -1, -1, -1, -1, -1, 0, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 10, -1, -1, -1, -1, -1, 262, 263, 264, -1, -1, 267, - 268, 269, -1, 271, -1, -1, -1, -1, -1, 341, - -1, 279, 344, 281, 282, 347, -1, 349, -1, 59, - -1, -1, 290, 291, 0, 293, 294, 295, 296, -1, - -1, -1, -1, 365, 10, -1, -1, 305, -1, -1, - -1, -1, -1, 0, -1, 377, -1, -1, -1, -1, - -1, -1, -1, 10, -1, -1, -1, 389, 262, 263, - 264, -1, -1, 267, 268, 269, -1, 271, 44, -1, - -1, -1, -1, 341, -1, 279, 344, 281, 282, 347, - -1, 349, -1, 59, -1, -1, 290, 291, -1, 293, - 294, 295, 296, 297, -1, -1, -1, 365, 0, -1, - -1, -1, 59, -1, -1, -1, -1, -1, 10, 377, - -1, -1, -1, -1, -1, -1, -1, -1, 262, 263, - 264, 389, -1, 267, 268, 269, -1, 271, -1, -1, - -1, -1, -1, -1, -1, 279, -1, 281, 282, -1, - 344, -1, -1, 347, -1, 349, 290, 291, -1, 293, - 294, 295, 296, 297, -1, -1, 0, 59, 262, 263, - 264, 365, -1, 267, 268, 269, 10, 271, -1, -1, - -1, -1, -1, -1, -1, 279, -1, 281, -1, -1, - -1, -1, -1, -1, -1, 389, 290, 291, -1, 293, - 294, 295, 296, 297, -1, -1, -1, -1, -1, -1, - 344, -1, -1, 347, -1, 349, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 59, -1, -1, -1, -1, - -1, 365, 262, 263, 264, -1, -1, 267, 268, 269, - 10, 271, -1, -1, -1, -1, -1, -1, -1, 279, - 344, 281, -1, -1, -1, 389, -1, -1, -1, -1, - 290, 291, -1, 293, 294, 295, 296, 297, -1, -1, - -1, 365, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 389, 262, 263, 264, -1, - -1, 267, 268, 269, -1, 271, -1, -1, -1, -1, - -1, -1, -1, 279, 344, 262, 263, 264, -1, -1, - 267, 268, 269, -1, 271, -1, -1, 293, 294, 295, - 296, 297, 279, -1, 281, 365, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 293, 294, 295, 296, - 297, -1, -1, -1, -1, -1, -1, -1, -1, 389, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 262, 263, 264, 10, -1, 341, 268, 269, 344, 271, - -1, -1, -1, -1, -1, -1, -1, 279, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 344, -1, 365, - -1, 293, 294, 295, 296, 297, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 365, -1, - -1, -1, 59, 389, -1, -1, -1, -1, 262, 263, - 264, -1, -1, -1, 268, 269, -1, 271, -1, -1, - -1, -1, 389, -1, -1, 279, -1, -1, -1, -1, - -1, -1, 344, -1, 91, -1, -1, -1, -1, 293, - 294, 295, 296, 297, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 365, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 257, 258, 259, - -1, 261, -1, -1, -1, 265, 266, 389, -1, -1, - 270, -1, 272, 273, 274, 275, 276, 277, 278, 10, - 344, -1, -1, 283, 284, 285, 286, 287, 288, 289, - -1, -1, 292, -1, -1, -1, -1, -1, -1, 299, - -1, 365, 302, 303, 304, -1, 306, 307, 308, 309, - 310, 311, 312, 313, 314, 315, 316, -1, -1, -1, - -1, -1, -1, -1, -1, 389, -1, -1, 59, -1, - -1, 331, 332, -1, -1, -1, -1, -1, -1, 339, - -1, -1, 342, -1, -1, 345, 346, -1, 348, -1, - 350, -1, 352, -1, 354, -1, -1, -1, -1, -1, - 91, -1, 362, -1, -1, -1, -1, 367, 368, 369, - 370, 371, 372, -1, -1, -1, 376, -1, 378, 379, - -1, 381, 382, 383, 384, -1, 386, 387, 388, 256, - 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, - -1, -1, 269, 270, -1, 272, 273, 274, 275, 276, - 277, 278, -1, 280, -1, -1, 283, 284, 285, 286, - 287, 288, 289, -1, -1, 292, -1, -1, -1, -1, - -1, 298, 299, -1, 301, 302, 303, 304, -1, 306, - 307, 308, 309, 310, 311, -1, 313, 314, 315, 316, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 10, - -1, 328, -1, -1, 331, 332, -1, -1, -1, -1, - 337, 338, 339, -1, -1, 342, 343, -1, 345, 346, - -1, 348, -1, 350, -1, -1, -1, 354, -1, -1, - -1, -1, 359, -1, -1, 362, -1, 364, -1, -1, - 367, 368, 369, 370, 371, 372, -1, -1, 59, 376, - -1, 378, 379, -1, 381, 382, 383, 384, -1, 386, - 387, -1, -1, -1, -1, 256, 257, 258, 259, 260, - 261, 262, 263, 264, 265, 266, -1, -1, 269, 270, - 91, 272, 273, 274, 275, 276, 277, 278, -1, 280, - -1, -1, 283, 284, 285, 286, 287, 288, 289, -1, - -1, 292, -1, -1, -1, -1, -1, 298, 299, -1, - 301, 302, 303, 304, -1, 306, 307, 308, 309, 310, - 311, -1, 313, 314, 315, 316, -1, -1, -1, -1, - -1, -1, -1, 10, -1, -1, -1, 328, -1, -1, - 331, 332, -1, -1, -1, -1, 337, 338, 339, -1, - -1, 342, 343, -1, 345, 346, -1, 348, -1, 350, - -1, -1, -1, 354, -1, -1, -1, -1, 359, -1, - -1, 362, -1, 364, -1, -1, 367, 368, 369, 370, - 371, 372, 59, -1, -1, 376, -1, 378, 379, -1, - 381, 382, 383, 384, -1, 386, 387, -1, -1, -1, + 268, 269, -1, 271, -1, -1, -1, -1, -1, -1, + -1, 343, 280, 281, 346, -1, 348, -1, -1, 41, + -1, 289, 290, -1, 292, 293, 294, 295, 296, -1, + -1, -1, 364, -1, -1, -1, -1, 59, -1, -1, + -1, -1, 0, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 10, -1, -1, -1, 388, -1, 390, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 91, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 343, -1, -1, 346, -1, + 348, -1, 0, 41, 262, 263, 264, -1, -1, 267, + 268, 269, 10, 271, -1, -1, 364, -1, -1, -1, + -1, 59, 280, 281, -1, -1, -1, -1, -1, -1, + -1, 289, 290, -1, 292, 293, 294, 295, 296, -1, + 388, -1, 390, 41, -1, -1, -1, 262, 263, 264, + -1, -1, 267, 268, 269, -1, 271, -1, -1, -1, + -1, 59, -1, -1, -1, 280, 281, -1, -1, -1, + -1, -1, -1, -1, 289, 290, -1, 292, 293, 294, + 295, 296, -1, -1, -1, 343, -1, -1, 346, -1, + 348, -1, -1, 262, 263, 264, -1, -1, 267, 268, + 269, -1, 271, -1, -1, 0, 364, -1, -1, -1, + -1, 280, 281, -1, -1, 10, -1, -1, -1, -1, + 289, 290, -1, 292, 293, 294, 295, 296, 343, -1, + 388, 346, 390, 348, -1, -1, -1, -1, -1, -1, + 0, -1, -1, -1, -1, -1, 41, -1, -1, 364, + 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 262, 263, 264, -1, 59, 267, 268, 269, -1, 271, + -1, -1, -1, 388, 343, 390, -1, 346, 280, 281, + -1, 41, -1, -1, -1, -1, -1, 289, 290, -1, + 292, 293, 294, 295, 296, 364, -1, -1, -1, 59, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 0, 388, + -1, 390, -1, -1, 262, 263, 264, -1, 10, 267, + 268, 269, -1, 271, -1, -1, -1, -1, -1, 928, + -1, 343, 280, 281, 346, -1, -1, -1, -1, -1, + -1, 289, 290, -1, 292, 293, 294, 295, 296, 41, + -1, -1, 364, -1, 262, 263, 264, -1, -1, 267, + 268, 269, -1, 271, 0, -1, -1, 59, -1, -1, + -1, -1, 280, -1, 10, -1, 388, -1, 390, -1, + -1, 289, 290, -1, 292, 293, 294, 295, 296, -1, + -1, -1, -1, -1, -1, 343, -1, -1, 346, -1, + -1, -1, -1, -1, -1, 41, -1, -1, -1, 1008, + 1009, -1, -1, 1012, -1, -1, 364, 0, -1, -1, + -1, -1, -1, 59, -1, -1, -1, 10, -1, -1, + -1, -1, -1, -1, -1, 343, -1, -1, -1, -1, + 388, -1, 390, -1, -1, -1, -1, -1, -1, 1048, + -1, -1, -1, -1, -1, -1, 364, 262, 263, 264, + -1, 44, 267, 268, 269, -1, 271, -1, -1, -1, + -1, -1, -1, -1, -1, 280, 59, -1, -1, -1, + 388, -1, 390, -1, 289, 290, -1, 292, 293, 294, + 295, 296, 262, 263, 264, -1, -1, 267, 268, 269, + -1, 271, 1101, -1, -1, -1, -1, 1106, -1, -1, + 280, -1, 94, -1, -1, -1, -1, -1, -1, 289, + 290, -1, 292, 293, 294, 295, 296, 1126, 1127, 1128, + 1129, -1, -1, -1, 1133, 1134, -1, 1136, 343, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 256, 257, 258, 259, 260, - 261, 262, 263, 264, 265, 266, -1, -1, 269, 270, - -1, 272, 273, 274, 275, 276, 277, 278, -1, 280, - -1, -1, 283, 284, 285, 286, 287, 288, 289, -1, - -1, 292, -1, -1, -1, -1, -1, 298, 299, -1, - 301, 302, 303, 304, -1, 306, 307, 308, 309, 310, - 311, -1, 313, 314, 315, 316, -1, -1, -1, -1, - -1, -1, -1, 10, -1, -1, -1, 328, -1, -1, - 331, 332, -1, -1, -1, -1, 337, 338, 339, -1, - -1, 342, 343, -1, 345, 346, -1, 348, -1, 350, - -1, -1, -1, 354, -1, -1, -1, -1, 359, -1, - -1, 362, -1, 364, -1, -1, 367, 368, 369, 370, - 371, 372, 59, -1, -1, 376, -1, 378, 379, -1, - 381, 382, 383, 384, -1, 386, 387, -1, -1, 256, - 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, - -1, -1, 269, 270, 91, 272, 273, 274, 275, 276, - 277, 278, -1, -1, -1, -1, 283, 284, 285, 286, - 287, 288, 289, -1, -1, 292, -1, -1, -1, -1, - -1, 298, 299, -1, 301, 302, 303, 304, -1, 306, - 307, 308, 309, 310, 311, -1, 313, 314, 315, 316, - -1, -1, -1, -1, -1, -1, -1, 10, -1, -1, - -1, 328, -1, -1, 331, 332, -1, -1, -1, -1, - 337, 338, 339, -1, -1, 342, 343, -1, 345, 346, - -1, 348, -1, 350, -1, -1, -1, 354, -1, -1, - -1, -1, 359, -1, -1, 362, -1, -1, -1, -1, - 367, 368, 369, 370, 371, 372, 59, -1, -1, 376, - -1, 378, 379, -1, 381, 382, 383, 384, -1, 386, - 387, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 364, + -1, -1, 10, -1, -1, -1, -1, -1, -1, -1, + 262, 263, 264, 343, -1, 267, 268, 269, -1, 271, + -1, -1, -1, 388, -1, 390, -1, -1, 280, -1, + -1, -1, -1, -1, 364, -1, -1, 289, 290, -1, + 292, 293, 294, 295, 296, -1, -1, -1, -1, -1, + -1, 59, -1, -1, -1, -1, -1, -1, 388, -1, + 390, -1, -1, -1, -1, -1, 262, 263, 264, -1, + -1, 267, 268, 269, -1, 271, -1, -1, -1, 1238, + -1, -1, -1, -1, 280, 1244, -1, -1, -1, -1, + -1, 343, 1251, -1, -1, -1, 292, 293, 294, 295, + 296, -1, -1, -1, -1, -1, -1, -1, -1, 1268, + -1, -1, 364, -1, -1, -1, -1, -1, -1, 262, + 263, 264, -1, 1282, 267, 268, 269, -1, 271, -1, + -1, -1, 10, -1, -1, -1, 388, -1, 390, -1, + -1, -1, -1, 285, 286, 287, 288, 343, -1, 292, + 293, 294, 295, 296, -1, -1, -1, -1, -1, 301, + 302, 303, -1, 305, -1, -1, -1, 309, 364, -1, + 312, -1, -1, 315, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 330, 331, + -1, -1, 388, -1, 390, -1, 338, 340, -1, 341, + 343, -1, -1, 345, -1, 347, -1, 349, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 364, -1, -1, 366, 367, 368, 369, 370, 371, + -1, -1, -1, 375, -1, -1, -1, -1, 380, 381, + 382, 383, -1, 385, 386, 388, -1, 390, 256, 257, + 258, 259, 260, 261, 262, 263, 264, 265, 266, -1, + 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, + 278, 10, -1, -1, 282, 283, 284, 285, 286, 287, + 288, -1, -1, 291, -1, -1, -1, -1, -1, 297, + 298, -1, 300, 301, 302, 303, -1, 305, 306, 307, + 308, 309, 310, -1, 312, 313, 314, 315, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 59, -1, 330, 331, -1, -1, -1, -1, -1, -1, + 338, -1, -1, 341, -1, -1, 344, 345, -1, 347, + -1, 349, -1, -1, -1, 353, -1, -1, -1, -1, + -1, -1, 91, 361, -1, -1, -1, -1, 366, 367, + 368, 369, 370, 371, -1, -1, -1, 375, -1, 377, + 378, -1, 380, 381, 382, 383, -1, 385, 386, 257, + 258, 259, 390, 261, -1, -1, -1, 265, 266, -1, + -1, -1, 270, -1, 272, 273, 274, 275, 276, 277, + 278, -1, -1, -1, 282, 283, 284, 285, 286, 287, + 288, -1, -1, 291, -1, 10, -1, -1, -1, -1, + 298, -1, -1, 301, 302, 303, -1, 305, 306, 307, + 308, 309, 310, 311, 312, 313, 314, 315, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 330, 331, -1, -1, -1, -1, -1, -1, + 338, -1, -1, 341, 59, -1, 344, 345, -1, 347, + -1, 349, -1, 351, -1, 353, -1, -1, -1, -1, + -1, -1, -1, 361, -1, -1, -1, -1, 366, 367, + 368, 369, 370, 371, -1, -1, 91, 375, -1, 377, + 378, -1, 380, 381, 382, 383, -1, 385, 386, 387, + -1, -1, -1, -1, -1, -1, -1, 256, 257, 258, + 259, 260, 261, 262, 263, 264, 265, 266, -1, -1, + 269, 270, -1, 272, 273, 274, 275, 276, 277, 278, + 279, -1, -1, 282, 283, 284, 285, 286, 287, 288, + -1, -1, 291, -1, -1, -1, -1, -1, 297, 298, + -1, 300, 301, 302, 303, -1, 305, 306, 307, 308, + 309, 310, 10, 312, 313, 314, 315, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 327, -1, + -1, 330, 331, -1, -1, -1, -1, 336, 337, 338, + -1, -1, 341, 342, -1, 344, 345, -1, 347, -1, + 349, -1, -1, -1, 353, -1, -1, -1, -1, 358, + -1, 59, 361, -1, 363, -1, -1, 366, 367, 368, + 369, 370, 371, -1, -1, -1, 375, -1, 377, 378, + -1, 380, 381, 382, 383, -1, 385, 386, -1, -1, + -1, -1, -1, 91, -1, -1, -1, -1, -1, -1, + -1, 256, 257, 258, 259, 260, 261, 262, 263, 264, + 265, 266, -1, -1, 269, 270, -1, 272, 273, 274, + 275, 276, 277, 278, 279, -1, -1, 282, 283, 284, + 285, 286, 287, 288, -1, -1, 291, -1, -1, -1, + -1, -1, 297, 298, -1, 300, 301, 302, 303, -1, + 305, 306, 307, 308, 309, 310, 10, 312, 313, 314, + 315, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 327, -1, -1, 330, 331, -1, -1, -1, + -1, 336, 337, 338, -1, -1, 341, 342, -1, 344, + 345, -1, 347, -1, 349, -1, -1, -1, 353, -1, + -1, -1, -1, 358, -1, 59, 361, -1, 363, -1, + -1, 366, 367, 368, 369, 370, 371, -1, -1, -1, + 375, -1, 377, 378, -1, 380, 381, 382, 383, -1, + 385, 386, -1, -1, -1, -1, -1, 91, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 256, 257, + 258, 259, 260, 261, 262, 263, 264, 265, 266, -1, + -1, 269, 270, -1, 272, 273, 274, 275, 276, 277, + 278, 279, -1, -1, 282, 283, 284, 285, 286, 287, + 288, -1, -1, 291, -1, -1, -1, -1, -1, 297, + 298, -1, 300, 301, 302, 303, -1, 305, 306, 307, + 308, 309, 310, 10, 312, 313, 314, 315, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 327, + -1, -1, 330, 331, -1, -1, -1, -1, 336, 337, + 338, -1, -1, 341, 342, -1, 344, 345, -1, 347, + -1, 349, -1, -1, -1, 353, -1, -1, -1, -1, + 358, -1, 59, 361, -1, 363, -1, -1, 366, 367, + 368, 369, 370, 371, -1, -1, -1, 375, -1, 377, + 378, -1, 380, 381, 382, 383, -1, 385, 386, -1, + -1, -1, -1, -1, 91, -1, -1, -1, -1, -1, + -1, -1, 256, 257, 258, 259, 260, 261, 262, 263, + 264, 265, 266, -1, -1, 269, 270, -1, 272, 273, + 274, 275, 276, 277, 278, -1, -1, -1, 282, 283, + 284, 285, 286, 287, 288, -1, -1, 291, -1, -1, + -1, -1, -1, 297, 298, 10, 300, 301, 302, 303, + -1, 305, 306, 307, 308, 309, 310, -1, 312, 313, + 314, 315, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 327, -1, -1, 330, 331, -1, -1, + -1, -1, 336, 337, 338, -1, -1, 341, 342, -1, + 344, 345, -1, 347, 59, 349, -1, -1, -1, 353, + -1, -1, -1, -1, 358, -1, -1, 361, -1, -1, + -1, -1, 366, 367, 368, 369, 370, 371, -1, -1, + -1, 375, -1, 377, 378, -1, 380, 381, 382, 383, + -1, 385, 386, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, -1, -1, 269, 270, -1, 272, 273, 274, 275, 276, - 277, 278, -1, 10, -1, -1, 283, 284, 285, 286, - 287, 288, 289, -1, -1, 292, -1, -1, -1, -1, - -1, 298, 299, -1, 301, 302, 303, 304, -1, 306, - 307, 308, 309, 310, 311, -1, 313, 314, 315, 316, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 328, 59, -1, 331, 332, -1, -1, -1, -1, - 337, 338, 339, -1, -1, 342, -1, -1, 345, 346, - -1, 348, -1, 350, -1, -1, -1, 354, -1, -1, - -1, -1, 359, -1, -1, 362, -1, -1, -1, -1, - 367, 368, 369, 370, 371, 372, -1, -1, -1, 376, - -1, 378, 379, -1, 381, 382, 383, 384, -1, 386, - 387, -1, -1, 256, 257, 258, 259, 260, 261, 262, - 263, 264, 265, 266, -1, 268, 269, 270, 271, 272, - 273, 274, 275, 276, 277, 278, 279, 10, -1, -1, - 283, 284, 285, 286, 287, 288, 289, -1, -1, 292, - -1, -1, -1, -1, -1, 298, 299, -1, 301, 302, - 303, 304, -1, 306, 307, 308, 309, 310, 311, -1, - 313, 314, 315, 316, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 59, -1, 331, 332, - -1, -1, -1, -1, -1, -1, 339, -1, -1, 342, - -1, -1, 345, 346, -1, 348, -1, 350, -1, -1, - -1, 354, -1, -1, -1, -1, -1, -1, -1, 362, - -1, -1, -1, -1, 367, 368, 369, 370, 371, 372, - -1, -1, -1, 376, -1, 378, 379, -1, 381, 382, - 383, 384, -1, 386, 387, -1, -1, -1, -1, 256, - 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, - -1, -1, 269, 270, -1, 272, 273, 274, 275, 276, - 277, 278, 10, -1, -1, -1, 283, 284, 285, 286, - 287, 288, 289, -1, -1, 292, -1, -1, -1, -1, - -1, 298, 299, -1, 301, 302, 303, 304, -1, 306, - 307, 308, 309, 310, 311, -1, 313, 314, 315, 316, - -1, -1, -1, -1, -1, -1, -1, -1, 325, -1, - -1, 59, -1, -1, 331, 332, -1, -1, -1, -1, - -1, -1, 339, -1, -1, 342, -1, -1, 345, 346, - -1, 348, -1, 350, -1, -1, -1, 354, -1, -1, - -1, -1, -1, -1, 361, 362, -1, -1, -1, -1, - 367, 368, 369, 370, 371, 372, -1, -1, -1, 376, - -1, 378, 379, -1, 381, 382, 383, 384, -1, 386, - 387, -1, -1, 256, 257, 258, 259, 260, 261, 262, - 263, 264, 265, 266, -1, -1, 269, 270, -1, 272, - 273, 274, 275, 276, 277, 278, 10, -1, -1, -1, - 283, 284, 285, 286, 287, 288, 289, -1, -1, 292, - -1, -1, -1, -1, -1, 298, 299, -1, 301, 302, - 303, 304, -1, 306, 307, 308, 309, 310, 311, -1, - 313, 314, 315, 316, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 59, -1, -1, 331, 332, - -1, -1, -1, -1, -1, -1, 339, -1, -1, 342, - -1, -1, 345, 346, -1, 348, -1, 350, -1, -1, - -1, 354, -1, -1, -1, -1, -1, -1, -1, 362, - -1, 364, -1, -1, 367, 368, 369, 370, 371, 372, - -1, -1, -1, 376, -1, 378, 379, -1, 381, 382, - 383, 384, -1, 386, 387, -1, -1, -1, 256, 257, + 277, 278, 10, -1, -1, 282, 283, 284, 285, 286, + 287, 288, -1, -1, 291, -1, -1, -1, -1, -1, + 297, 298, -1, 300, 301, 302, 303, -1, 305, 306, + 307, 308, 309, 310, -1, 312, 313, 314, 315, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 327, 59, -1, 330, 331, -1, -1, -1, -1, 336, + 337, 338, -1, -1, 341, -1, -1, 344, 345, -1, + 347, -1, 349, -1, -1, -1, 353, -1, -1, -1, + -1, 358, -1, -1, 361, -1, -1, -1, -1, 366, + 367, 368, 369, 370, 371, -1, -1, -1, 375, -1, + 377, 378, -1, 380, 381, 382, 383, -1, 385, 386, + -1, 256, 257, 258, 259, 260, 261, 262, 263, 264, + 265, 266, -1, -1, 269, 270, -1, 272, 273, 274, + 275, 276, 277, 278, 10, -1, -1, 282, 283, 284, + 285, 286, 287, 288, -1, -1, 291, -1, -1, -1, + -1, -1, 297, 298, -1, 300, 301, 302, 303, -1, + 305, 306, 307, 308, 309, 310, -1, 312, 313, 314, + 315, -1, -1, -1, -1, -1, -1, -1, -1, 324, + -1, -1, -1, 59, -1, 330, 331, -1, -1, -1, + -1, -1, -1, 338, -1, -1, 341, -1, -1, 344, + 345, -1, 347, -1, 349, -1, -1, -1, 353, -1, + -1, -1, -1, -1, -1, 360, 361, -1, -1, -1, + -1, 366, 367, 368, 369, 370, 371, -1, -1, -1, + 375, -1, 377, 378, -1, 380, 381, 382, 383, -1, + 385, 386, -1, -1, -1, -1, -1, -1, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, -1, -1, 269, 270, -1, 272, 273, 274, 275, 276, 277, - 278, 10, -1, -1, -1, 283, 284, 285, 286, 287, - 288, 289, -1, -1, 292, -1, -1, -1, -1, -1, - 298, 299, -1, 301, 302, 303, 304, -1, 306, 307, - 308, 309, 310, 311, -1, 313, 314, 315, 316, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 331, 332, -1, -1, -1, -1, -1, - -1, 339, -1, -1, 342, -1, -1, 345, 346, -1, - 348, -1, 350, -1, -1, -1, 354, -1, -1, -1, - -1, -1, -1, -1, 362, -1, -1, -1, -1, 367, - 368, 369, 370, 371, 372, -1, -1, -1, 376, -1, - 378, 379, -1, 381, 382, 383, 384, -1, 386, 387, - -1, -1, 256, 257, 258, 259, 260, 261, -1, -1, - -1, 265, 266, -1, -1, -1, 270, -1, 272, 273, - 274, 275, 276, 277, 278, 10, -1, -1, -1, 283, - 284, 285, 286, 287, 288, 289, -1, -1, 292, -1, - -1, -1, -1, -1, 298, 299, -1, 301, 302, 303, - 304, -1, 306, 307, 308, 309, 310, 311, -1, 313, - 314, 315, 316, -1, -1, -1, -1, -1, -1, -1, - -1, 325, -1, -1, 59, -1, -1, 331, 332, -1, - -1, -1, -1, -1, -1, 339, -1, -1, 342, -1, - -1, 345, 346, -1, 348, -1, 350, -1, -1, -1, - 354, -1, -1, -1, -1, -1, -1, 361, 362, -1, - -1, 365, -1, 367, 368, 369, 370, 371, 372, -1, - -1, -1, 376, -1, 378, 379, -1, 381, 382, 383, - 384, -1, 386, 387, -1, -1, -1, -1, 257, 258, + 278, 10, -1, -1, 282, 283, 284, 285, 286, 287, + 288, -1, -1, 291, -1, -1, -1, -1, -1, 297, + 298, -1, 300, 301, 302, 303, -1, 305, 306, 307, + 308, 309, 310, -1, 312, 313, 314, 315, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 59, -1, 330, 331, -1, -1, -1, -1, -1, -1, + 338, -1, -1, 341, -1, -1, 344, 345, -1, 347, + -1, 349, -1, -1, -1, 353, -1, -1, -1, -1, + -1, -1, -1, 361, -1, 363, -1, -1, 366, 367, + 368, 369, 370, 371, -1, -1, -1, 375, -1, 377, + 378, -1, 380, 381, 382, 383, -1, 385, 386, -1, + 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, + 266, -1, -1, 269, 270, -1, 272, 273, 274, 275, + 276, 277, 278, 10, -1, -1, 282, 283, 284, 285, + 286, 287, 288, -1, -1, 291, -1, -1, -1, -1, + -1, 297, 298, -1, 300, 301, 302, 303, -1, 305, + 306, 307, 308, 309, 310, -1, 312, 313, 314, 315, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 330, 331, -1, -1, -1, -1, + -1, -1, 338, -1, -1, 341, -1, -1, 344, 345, + -1, 347, -1, 349, -1, -1, -1, 353, -1, -1, + -1, -1, -1, -1, -1, 361, -1, -1, -1, -1, + 366, 367, 368, 369, 370, 371, -1, -1, -1, 375, + -1, 377, 378, -1, 380, 381, 382, 383, -1, 385, + 386, -1, -1, -1, -1, -1, -1, 256, 257, 258, 259, 260, 261, -1, -1, -1, 265, 266, -1, -1, -1, 270, -1, 272, 273, 274, 275, 276, 277, 278, - 10, -1, -1, -1, 283, 284, 285, 286, 287, 288, - 289, -1, -1, 292, -1, -1, -1, -1, -1, 298, - 299, -1, 301, 302, 303, 304, -1, 306, 307, 308, - 309, 310, 311, -1, 313, 314, 315, 316, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 331, 332, -1, -1, -1, -1, -1, -1, - 339, -1, -1, 342, -1, 344, 345, 346, -1, 348, - -1, 350, -1, -1, -1, 354, -1, -1, -1, -1, - -1, -1, -1, 362, -1, -1, -1, -1, 367, 368, - 369, 370, 371, 372, -1, + 10, -1, -1, 282, 283, 284, 285, 286, 287, 288, + -1, -1, 291, -1, -1, -1, -1, -1, 297, 298, + -1, 300, 301, 302, 303, -1, 305, 306, 307, 308, + 309, 310, -1, 312, 313, 314, 315, -1, -1, -1, + -1, -1, -1, -1, -1, 324, -1, -1, -1, 59, + -1, 330, 331, -1, -1, -1, -1, -1, -1, 338, + -1, -1, 341, -1, -1, 344, 345, -1, 347, -1, + 349, -1, -1, -1, 353, -1, -1, -1, -1, -1, + -1, 360, 361, -1, -1, 364, -1, 366, 367, 368, + 369, 370, 371, -1, -1, -1, 375, -1, 377, 378, + -1, 380, 381, 382, 383, -1, 385, 386, -1, -1, + 257, 258, 259, 260, 261, -1, -1, -1, 265, 266, + -1, -1, -1, 270, -1, 272, 273, 274, 275, 276, + 277, 278, 10, -1, -1, 282, 283, 284, 285, 286, + 287, 288, -1, -1, 291, -1, -1, -1, -1, -1, + 297, 298, -1, 300, 301, 302, 303, -1, 305, 306, + 307, 308, 309, 310, -1, 312, 313, 314, 315, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 330, 331, -1, -1, -1, -1, -1, + -1, 338, -1, -1, 341, -1, 343, 344, 345, -1, + 347, -1, 349, -1, -1, -1, 353, -1, -1, -1, + -1, -1, -1, -1, 361, -1, -1, -1, -1, 366, + 367, 368, 369, 370, 371, -1, -1, -1, 375, -1, + 377, 378, -1, 380, 381, 382, 383, -1, 385, 386, + -1, -1, -1, -1, -1, -1, -1, 257, 258, 259, + -1, 261, -1, -1, -1, 265, 266, -1, -1, -1, + 270, -1, 272, 273, 274, 275, 276, 277, 278, -1, + -1, -1, 282, 283, 284, 285, 286, 287, 288, -1, + -1, 291, -1, -1, -1, -1, -1, -1, 298, -1, + -1, 301, 302, 303, -1, 305, 306, 307, 308, 309, + 310, -1, 312, 313, 314, 315, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 330, 331, -1, -1, -1, -1, -1, -1, 338, -1, + -1, 341, -1, -1, 344, 345, -1, 347, 928, -1, + -1, -1, -1, 353, -1, -1, -1, -1, -1, -1, + -1, 361, -1, -1, -1, -1, 366, 367, 368, 369, + 370, 371, -1, -1, -1, 375, -1, 377, 378, -1, + 380, 381, 382, 383, -1, 385, 386, -1, -1, 257, + 258, 259, -1, 261, -1, -1, -1, 265, 266, -1, + 928, -1, 270, -1, 272, 273, 274, 275, 276, 277, + 278, 928, -1, -1, 282, 283, 284, 285, 286, 287, + 288, -1, -1, 291, -1, -1, -1, -1, 1008, 1009, + 298, -1, 1012, 301, 302, 303, -1, 305, 306, 307, + 308, 309, 310, -1, 312, 313, 314, 315, 928, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 330, 331, -1, -1, -1, -1, 1048, -1, + 338, -1, -1, 341, -1, -1, 344, 345, -1, 347, + 1008, 1009, -1, -1, 1012, 353, -1, -1, -1, -1, + -1, 1008, 1009, 361, -1, 1012, -1, -1, 366, 367, + 368, 369, 370, 371, -1, -1, -1, 375, -1, 377, + 378, -1, 380, 381, 382, 383, -1, 385, 386, -1, + 1048, 1101, -1, -1, -1, -1, 1106, -1, 1008, 1009, + -1, 1048, 1012, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 1126, 1127, 1128, 1129, + -1, -1, -1, 1133, 1134, -1, 1136, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 1048, -1, + -1, -1, -1, 1101, -1, -1, -1, -1, 1106, 928, + -1, -1, -1, -1, 1101, -1, -1, -1, -1, 1106, + -1, -1, -1, -1, -1, 928, -1, -1, 1126, 1127, + 1128, 1129, -1, 44, -1, 1133, 1134, -1, 1136, 1126, + 1127, 1128, 1129, -1, -1, -1, 1133, 1134, -1, 1136, + -1, 1101, -1, -1, -1, -1, 1106, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 1126, 1127, 1128, 1129, + -1, -1, -1, 1133, 1134, -1, 1136, -1, 1238, 1008, + 1009, -1, -1, 1012, 1244, -1, -1, -1, }; } private static final short[] yyCheck4() { return new short[] { - -1, -1, 376, -1, 378, 379, -1, 381, 382, 383, - 384, -1, 386, 387, -1, -1, -1, 257, 258, 259, - -1, 261, -1, -1, -1, 265, 266, -1, -1, -1, - 270, -1, 272, 273, 274, 275, 276, 277, 278, -1, - -1, -1, -1, 283, 284, 285, 286, 287, 288, 289, - -1, -1, 292, -1, -1, -1, -1, -1, -1, 299, - -1, -1, 302, 303, 304, -1, 306, 307, 308, 309, - 310, 311, 44, 313, 314, 315, 316, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 331, 332, -1, -1, -1, -1, -1, -1, 339, - -1, -1, 342, -1, -1, 345, 346, -1, 348, -1, - -1, -1, -1, -1, 354, -1, -1, -1, -1, -1, - -1, -1, 362, -1, -1, -1, -1, 367, 368, 369, - 370, 371, 372, -1, -1, -1, 376, -1, 378, 379, - -1, 381, 382, 383, 384, -1, 386, 387, -1, -1, - -1, -1, 257, 258, 259, -1, 261, -1, -1, -1, - 265, 266, -1, -1, -1, 270, -1, 272, 273, 274, - 275, 276, 277, 278, -1, -1, -1, -1, 283, 284, - 285, 286, 287, 288, 289, -1, -1, 292, -1, -1, - -1, -1, -1, -1, 299, -1, -1, 302, 303, 304, - -1, 306, 307, 308, 309, 310, 311, 44, 313, 314, - 315, 316, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 331, 332, -1, -1, - -1, -1, -1, -1, 339, -1, -1, 342, -1, -1, - 345, 346, -1, 348, -1, -1, -1, -1, -1, 354, - -1, -1, -1, -1, -1, -1, -1, 362, -1, -1, - -1, -1, 367, 368, 369, 370, 371, 372, -1, -1, - -1, 376, -1, 378, 379, -1, 381, 382, 383, 384, - -1, 386, 387, -1, -1, 257, 258, 259, -1, 261, - -1, -1, -1, 265, 266, -1, -1, -1, 270, -1, - 272, 273, 274, 275, 276, 277, 278, -1, -1, -1, - -1, 283, 284, 285, 286, 287, 288, 289, -1, -1, - 292, -1, -1, -1, -1, -1, -1, 299, -1, -1, - 302, 303, 304, -1, 306, 307, 308, 309, 310, 311, - -1, 313, -1, -1, 316, -1, -1, -1, -1, -1, - -1, -1, -1, 59, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 339, -1, -1, - 342, -1, -1, 345, 346, -1, 348, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 367, 368, 369, 370, 371, - 372, -1, -1, -1, 376, -1, 378, 379, -1, 381, - 382, 383, 384, -1, 386, 387, -1, -1, -1, -1, - 257, 258, 259, -1, 261, -1, -1, -1, 265, 266, - -1, -1, -1, 270, -1, 272, 273, 274, 275, 276, - 277, 278, -1, -1, -1, -1, 283, 284, 285, 286, - 287, 288, 289, -1, -1, 292, -1, -1, -1, -1, - -1, -1, 299, -1, -1, 302, 303, 304, -1, 306, - 307, 308, 309, 310, 311, -1, 313, -1, -1, 316, - -1, -1, -1, -1, 59, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 339, -1, -1, 342, -1, -1, 345, 346, - -1, 348, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 367, 368, 369, 370, 371, 372, -1, -1, -1, 376, - -1, 378, 379, -1, 381, 382, 383, 384, -1, 386, - 387, 257, 258, 259, 260, 261, -1, -1, -1, 265, - 266, -1, -1, -1, 270, -1, 272, 273, 274, 275, - 276, 277, 278, -1, -1, -1, -1, 283, 284, 285, - 286, 287, 288, 289, -1, -1, 292, -1, -1, -1, - -1, -1, 298, 299, 300, 301, 302, 303, 304, -1, - 306, 307, 308, 309, 310, 311, -1, 313, 314, 315, - 316, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 331, 332, -1, -1, -1, - -1, -1, -1, 339, -1, -1, 342, -1, -1, 345, - 346, -1, 348, -1, 350, -1, -1, -1, 354, -1, - -1, -1, -1, -1, -1, -1, 362, -1, -1, -1, - -1, 367, 368, 369, 370, 371, 372, -1, -1, -1, - 376, -1, 378, 379, -1, 381, 382, 383, 384, -1, - 386, 387, 257, 258, 259, 260, 261, -1, -1, -1, - 265, 266, -1, -1, -1, 270, -1, 272, 273, 274, - 275, 276, 277, 278, -1, -1, -1, -1, 283, 284, - 285, 286, 287, 288, 289, -1, -1, 292, -1, -1, - -1, -1, -1, 298, 299, -1, 301, 302, 303, 304, - -1, 306, 307, 308, 309, 310, 311, -1, 313, 314, - 315, 316, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 331, 332, -1, -1, - -1, -1, -1, -1, 339, -1, -1, 342, -1, -1, - 345, 346, -1, 348, -1, 350, -1, -1, -1, 354, - -1, -1, -1, -1, -1, -1, -1, 362, -1, -1, - -1, -1, 367, 368, 369, 370, 371, 372, -1, -1, - -1, 376, -1, 378, 379, -1, 381, 382, 383, 384, - -1, 386, 387, 257, 258, 259, 260, 261, 262, 263, - 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, - 274, 275, 276, 277, 278, 279, 280, -1, -1, 283, - 284, 285, 286, 287, 288, 289, 290, 291, 292, -1, - -1, -1, -1, 297, 298, 299, 300, 301, 302, 303, - 304, -1, 306, 307, 308, 309, 310, 311, -1, -1, - 314, 315, -1, 317, 318, 319, 320, 321, 322, 323, - -1, -1, 326, 327, -1, -1, -1, -1, -1, 333, - 334, 335, 336, -1, -1, -1, -1, -1, -1, 343, - -1, -1, -1, -1, -1, -1, 350, 351, -1, 353, - 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, - -1, -1, 366, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 1251, -1, -1, -1, 1008, 1009, -1, + -1, 1012, -1, -1, -1, -1, -1, -1, -1, -1, + 1268, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 1048, -1, -1, 1282, -1, -1, -1, -1, -1, + -1, -1, 1238, -1, -1, -1, -1, 1048, 1244, -1, + -1, -1, -1, 1238, -1, 1251, -1, -1, -1, 1244, + -1, -1, -1, -1, -1, 44, 1251, -1, -1, -1, + -1, -1, 1268, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 1268, 1101, -1, 1282, -1, -1, 1106, + 1238, -1, -1, -1, -1, -1, 1244, 1282, -1, -1, + 1101, -1, -1, 1251, -1, 1106, -1, -1, -1, 1126, + 1127, 1128, 1129, -1, -1, -1, 1133, 1134, -1, 1136, + 1268, -1, -1, -1, -1, 1126, 1127, 1128, 1129, -1, + -1, -1, 1133, 1134, 1282, 1136, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 257, 258, + 259, -1, 261, -1, -1, -1, 265, 266, -1, -1, + -1, 270, -1, 272, 273, 274, 275, 276, 277, 278, + -1, -1, -1, 282, 283, 284, 285, 286, 287, 288, + -1, -1, 291, -1, -1, -1, -1, -1, -1, 298, + -1, -1, 301, 302, 303, -1, 305, 306, 307, 308, + 309, 310, -1, 312, -1, -1, 315, -1, -1, -1, + 59, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 1238, -1, -1, -1, -1, -1, 1244, -1, 338, + -1, -1, 341, -1, 1251, 344, 345, 1238, 347, -1, + -1, -1, -1, 1244, -1, -1, -1, -1, -1, -1, + 1251, 1268, -1, -1, -1, -1, -1, 366, 367, 368, + 369, 370, 371, -1, -1, 1282, 375, 1268, 377, 378, + -1, 380, 381, 382, 383, -1, 385, 386, 257, 258, + 259, 1282, 261, -1, -1, -1, 265, 266, -1, -1, + -1, 270, -1, 272, 273, 274, 275, 276, 277, 278, + -1, -1, -1, 282, 283, 284, 285, 286, 287, 288, + -1, -1, 291, -1, -1, -1, -1, -1, -1, 298, + -1, -1, 301, 302, 303, -1, 305, 306, 307, 308, + 309, 310, -1, 312, -1, -1, 315, -1, -1, -1, + 59, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 338, + -1, -1, 341, -1, -1, 344, 345, -1, 347, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 388, 257, 258, 259, 260, 261, - 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, - 272, 273, 274, 275, 276, 277, 278, 279, 280, -1, - -1, 283, 284, 285, 286, 287, 288, 289, 290, 291, - 292, -1, -1, -1, -1, 297, 298, 299, 300, 301, - 302, 303, 304, -1, 306, 307, 308, 309, 310, 311, - -1, -1, 314, 315, -1, 317, 318, 319, 320, 321, - 322, 323, -1, -1, 326, 327, -1, -1, -1, -1, - -1, 333, 334, 335, 336, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 350, 351, - -1, 353, 354, 355, 356, 357, 358, 359, 360, 361, - 362, 363, -1, -1, 366, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 388, 257, 258, 259, - 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, - 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, - 280, -1, -1, 283, 284, 285, 286, 287, 288, 289, - 290, 291, 292, -1, -1, -1, -1, 297, 298, 299, - 300, 301, 302, 303, 304, -1, 306, 307, 308, -1, - 310, -1, -1, -1, 314, 315, -1, 317, 318, 319, - 320, 321, 322, 323, -1, -1, 326, 327, -1, -1, - -1, -1, -1, 333, 334, 335, 336, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 366, 367, 368, + 369, 370, 371, -1, -1, -1, 375, -1, 377, 378, + -1, 380, 381, 382, 383, -1, 385, 386, 257, 258, + 259, 260, 261, -1, -1, -1, 265, 266, -1, -1, + -1, 270, -1, 272, 273, 274, 275, 276, 277, 278, + -1, -1, -1, 282, 283, 284, 285, 286, 287, 288, + -1, -1, 291, -1, -1, -1, -1, -1, 297, 298, + 299, 300, 301, 302, 303, -1, 305, 306, 307, 308, + 309, 310, -1, 312, 313, 314, 315, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 94, -1, -1, + -1, 330, 331, -1, -1, -1, -1, -1, -1, 338, + -1, -1, 341, -1, -1, 344, 345, -1, 347, -1, + 349, -1, -1, -1, 353, -1, -1, -1, -1, -1, + -1, -1, 361, -1, -1, -1, -1, 366, 367, 368, + 369, 370, 371, -1, -1, -1, 375, -1, 377, 378, + -1, 380, 381, 382, 383, -1, 385, 386, 257, 258, + 259, 260, 261, -1, -1, -1, 265, 266, -1, -1, + -1, 270, -1, 272, 273, 274, 275, 276, 277, 278, + -1, -1, -1, 282, 283, 284, 285, 286, 287, 288, + -1, -1, 291, -1, -1, -1, -1, -1, 297, 298, + 94, 300, 301, 302, 303, -1, 305, 306, 307, 308, + 309, 310, -1, 312, 313, 314, 315, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 330, 331, -1, -1, -1, -1, -1, -1, 338, + -1, -1, 341, -1, -1, 344, 345, -1, 347, -1, + 349, -1, -1, -1, 353, -1, -1, -1, -1, -1, + -1, -1, 361, -1, -1, -1, -1, 366, 367, 368, + 369, 370, 371, -1, -1, -1, 375, -1, 377, 378, + -1, 380, 381, 382, 383, -1, 385, 386, 285, 286, + 287, 288, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 94, 301, 302, 303, -1, 305, -1, + -1, -1, 309, -1, 311, 312, -1, -1, 315, 316, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 330, 331, -1, -1, -1, -1, -1, + -1, 338, -1, -1, 341, -1, -1, -1, 345, 346, + 347, -1, 349, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 366, + 367, 368, 369, 370, 371, -1, -1, -1, 375, -1, + -1, -1, -1, 380, 381, 382, 383, -1, 385, 386, + 387, 285, 286, 287, 288, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 94, 301, 302, 303, + -1, 305, -1, -1, -1, 309, -1, 311, 312, -1, + -1, 315, 316, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 330, 331, -1, -1, + -1, -1, -1, -1, 338, -1, -1, 341, -1, 343, + -1, 345, -1, 347, -1, 349, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 366, 367, 368, 369, 370, 371, -1, -1, + -1, 375, -1, -1, -1, -1, 380, 381, 382, 383, + -1, 385, 386, 387, 285, 286, 287, 288, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 94, -1, + 301, 302, 303, -1, 305, -1, -1, -1, 309, -1, + 311, 312, -1, -1, 315, 316, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 330, + 331, -1, -1, -1, -1, -1, -1, 338, -1, -1, + 341, -1, -1, -1, 345, -1, 347, -1, 349, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 366, 367, 368, 369, 370, + 371, -1, -1, -1, 375, -1, -1, -1, -1, 380, + 381, 382, 383, -1, 385, 386, 387, 285, 286, 287, + 288, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 301, 302, 303, -1, 305, -1, -1, + -1, 309, -1, -1, 312, -1, -1, 315, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 350, 351, -1, 353, 354, 355, 356, 357, 358, 359, - 360, 361, 362, 363, -1, -1, 366, 367, -1, -1, + -1, -1, 330, 331, -1, -1, -1, -1, -1, -1, + 338, -1, -1, 341, -1, -1, -1, 345, -1, 347, + -1, 349, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 366, 367, + 368, 369, 370, 371, -1, -1, -1, 375, -1, -1, + -1, -1, 380, 381, 382, 383, -1, 385, 386, 285, + 286, 287, 288, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 301, 302, 303, -1, 305, + -1, -1, -1, 309, -1, -1, 312, -1, -1, 315, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 388, 257, + -1, -1, -1, -1, 330, 331, -1, -1, -1, -1, + -1, -1, 338, -1, -1, 341, -1, -1, -1, 345, + -1, 347, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 366, 367, 368, 369, 370, 371, -1, -1, -1, 375, + -1, -1, -1, -1, 380, 381, 382, 383, -1, 385, + 386, 257, 258, 259, 260, 261, 262, 263, 264, 265, + 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, + 276, 277, 278, 279, -1, -1, 282, 283, 284, 285, + 286, 287, 288, 289, 290, 291, -1, -1, -1, -1, + 296, 297, 298, 299, 300, 301, 302, 303, -1, 305, + 306, 307, 308, 309, 310, -1, -1, 313, 314, -1, + 316, 317, 318, 319, 320, 321, 322, -1, -1, 325, + 326, -1, -1, -1, -1, -1, 332, 333, 334, 335, + -1, -1, -1, -1, -1, -1, 342, -1, -1, -1, + -1, -1, -1, 349, 350, -1, 352, 353, 354, 355, + 356, 357, 358, 359, 360, 361, 362, -1, -1, 365, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 387, -1, -1, 390, 257, 258, 259, 260, 261, + 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, + 272, 273, 274, 275, 276, 277, 278, 279, -1, -1, + 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, + -1, -1, -1, -1, 296, 297, 298, 299, 300, 301, + 302, 303, -1, 305, 306, 307, 308, 309, 310, -1, + -1, 313, 314, -1, 316, 317, 318, 319, 320, 321, + 322, -1, -1, 325, 326, -1, -1, -1, -1, -1, + 332, 333, 334, 335, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 349, 350, -1, + 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, + 362, -1, -1, 365, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 387, -1, -1, 390, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, - 278, 279, 280, -1, -1, 283, 284, 285, 286, 287, - 288, 289, 290, 291, 292, -1, -1, -1, -1, 297, - 298, 299, 300, 301, 302, 303, 304, -1, 306, 307, - -1, -1, 310, -1, -1, -1, 314, 315, -1, 317, - 318, 319, 320, 321, 322, 323, -1, -1, 326, 327, - -1, -1, -1, -1, -1, 333, 334, 335, 336, -1, + 278, 279, -1, -1, 282, 283, 284, 285, 286, 287, + 288, 289, 290, 291, -1, -1, -1, -1, 296, 297, + 298, 299, 300, 301, 302, 303, -1, 305, 306, 307, + -1, 309, -1, -1, -1, 313, 314, -1, 316, 317, + 318, 319, 320, 321, 322, -1, -1, 325, 326, -1, + -1, -1, -1, -1, 332, 333, 334, 335, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 350, 351, -1, 353, 354, 355, 356, 357, - 358, 359, 360, 361, 362, 363, -1, -1, 366, 367, + -1, 349, 350, -1, 352, 353, 354, 355, 356, 357, + 358, 359, 360, 361, 362, -1, -1, 365, 366, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 387, + -1, -1, 390, 257, 258, 259, 260, 261, 262, 263, + 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, + 274, 275, 276, 277, 278, 279, -1, -1, 282, 283, + 284, 285, 286, 287, 288, 289, 290, 291, -1, -1, + -1, -1, 296, 297, 298, 299, 300, 301, 302, 303, + -1, 305, 306, -1, -1, 309, -1, -1, -1, 313, + 314, -1, 316, 317, 318, 319, 320, 321, 322, -1, + -1, 325, 326, -1, -1, -1, -1, -1, 332, 333, + 334, 335, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 349, 350, -1, 352, 353, + 354, 355, 356, 357, 358, 359, 360, 361, 362, -1, + -1, 365, 366, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 388, 257, 258, 259, 260, 261, 262, 263, 264, 265, - 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, - 276, 277, 278, 279, 280, -1, -1, 283, 284, 285, - 286, 287, 288, 289, 290, 291, 292, -1, -1, -1, - -1, 297, 298, 299, 300, 301, 302, 303, 304, -1, - 306, 307, -1, -1, 310, -1, -1, -1, 314, 315, - -1, 317, 318, 319, 320, 321, 322, 323, -1, -1, - 326, 327, -1, -1, -1, -1, -1, 333, 334, 335, - 336, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 350, 351, -1, 353, 354, 355, - 356, 357, 358, 359, 360, 361, 362, 363, -1, -1, - 366, -1, -1, -1, -1, -1, -1, 256, 257, 258, - 259, 260, 261, -1, -1, -1, 265, 266, -1, -1, - -1, 270, 388, 272, 273, 274, 275, 276, 277, 278, - -1, -1, -1, -1, 283, 284, 285, 286, 287, 288, - 289, -1, -1, 292, -1, -1, -1, -1, -1, 298, - 299, 300, 301, 302, 303, 304, -1, 306, 307, 308, - 309, 310, 311, -1, 313, 314, 315, 316, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 331, 332, -1, -1, -1, -1, -1, -1, - 339, -1, -1, 342, -1, -1, 345, 346, -1, 348, - -1, 350, -1, -1, -1, 354, -1, -1, -1, -1, - -1, -1, -1, 362, -1, -1, -1, -1, 367, 368, - 369, 370, 371, 372, -1, -1, -1, 376, -1, 378, - 379, -1, 381, 382, 383, 384, -1, 386, 387, 256, - 257, 258, 259, 260, 261, -1, -1, -1, 265, 266, - -1, -1, -1, 270, -1, 272, 273, 274, 275, 276, - 277, 278, -1, -1, -1, -1, 283, 284, 285, 286, - 287, 288, 289, -1, -1, 292, -1, -1, -1, -1, - -1, 298, 299, -1, 301, 302, 303, 304, -1, 306, - 307, 308, 309, 310, 311, -1, 313, 314, 315, 316, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 331, 332, -1, -1, -1, -1, - -1, -1, 339, -1, -1, 342, -1, -1, 345, 346, - -1, 348, -1, 350, -1, -1, -1, 354, -1, -1, - -1, -1, -1, -1, -1, 362, -1, -1, -1, -1, - 367, 368, 369, 370, 371, 372, -1, -1, -1, 376, - -1, 378, 379, -1, 381, 382, 383, 384, -1, 386, - 387, 256, 257, 258, 259, 260, 261, -1, -1, -1, - 265, 266, -1, -1, -1, 270, -1, 272, 273, 274, - 275, 276, 277, 278, -1, -1, -1, -1, 283, 284, - 285, 286, 287, 288, 289, -1, -1, 292, -1, -1, - -1, -1, -1, 298, 299, -1, 301, 302, 303, 304, - -1, 306, 307, 308, 309, 310, 311, -1, 313, 314, - 315, 316, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 331, 332, -1, -1, - -1, -1, -1, -1, 339, -1, -1, 342, -1, -1, - 345, 346, -1, 348, -1, 350, -1, -1, -1, 354, - -1, -1, -1, -1, -1, -1, -1, 362, -1, -1, - -1, -1, 367, 368, 369, 370, 371, 372, -1, -1, - -1, 376, -1, 378, 379, -1, 381, 382, 383, 384, - -1, 386, 387, 257, 258, 259, -1, 261, -1, -1, - -1, 265, 266, -1, -1, -1, 270, -1, 272, 273, - 274, 275, 276, 277, 278, -1, -1, -1, -1, 283, - 284, 285, 286, 287, 288, 289, -1, -1, 292, -1, - -1, -1, -1, -1, -1, 299, -1, -1, 302, 303, - 304, -1, 306, 307, 308, 309, 310, 311, 312, 313, - 314, 315, 316, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 331, 332, -1, - -1, -1, -1, -1, -1, 339, -1, -1, 342, -1, - -1, 345, 346, -1, 348, -1, 350, -1, 352, -1, - 354, -1, -1, -1, -1, -1, -1, -1, 362, -1, - -1, -1, -1, 367, 368, 369, 370, 371, 372, -1, - -1, -1, 376, -1, 378, 379, -1, 381, 382, 383, - 384, -1, 386, 387, 388, 257, 258, 259, -1, 261, - -1, -1, -1, 265, 266, -1, -1, -1, 270, -1, - 272, 273, 274, 275, 276, 277, 278, -1, -1, -1, - -1, 283, 284, 285, 286, 287, 288, 289, -1, -1, - 292, -1, -1, -1, -1, -1, -1, 299, -1, -1, - 302, 303, 304, -1, 306, 307, 308, 309, 310, 311, - 312, 313, 314, 315, 316, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 331, - 332, -1, -1, -1, -1, -1, -1, 339, -1, -1, - 342, -1, -1, 345, 346, -1, 348, -1, 350, -1, - 352, -1, 354, -1, -1, -1, -1, -1, -1, -1, - 362, -1, -1, -1, -1, 367, 368, 369, 370, 371, - 372, -1, -1, -1, 376, -1, 378, 379, -1, 381, - 382, 383, 384, -1, 386, 387, 388, 257, 258, 259, - -1, 261, -1, -1, -1, 265, 266, -1, -1, -1, - 270, -1, 272, 273, 274, 275, 276, 277, 278, -1, - -1, -1, -1, 283, 284, 285, 286, 287, 288, 289, - -1, -1, 292, -1, -1, -1, -1, -1, -1, 299, - -1, -1, 302, 303, 304, -1, 306, 307, 308, 309, - 310, 311, 312, 313, 314, 315, 316, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 331, 332, -1, -1, -1, -1, -1, -1, 339, - -1, -1, 342, -1, -1, 345, 346, -1, 348, -1, - 350, -1, 352, -1, 354, -1, -1, -1, -1, -1, - -1, -1, 362, -1, -1, -1, -1, 367, 368, 369, - 370, 371, 372, -1, -1, -1, 376, -1, 378, 379, - -1, 381, 382, 383, 384, -1, 386, 387, 388, 257, - 258, 259, -1, 261, -1, -1, -1, 265, 266, -1, - -1, -1, 270, -1, 272, 273, 274, 275, 276, 277, - 278, -1, -1, -1, -1, 283, 284, 285, 286, 287, - 288, 289, -1, -1, 292, -1, -1, -1, -1, -1, - -1, 299, -1, -1, 302, 303, 304, -1, 306, 307, - 308, 309, 310, 311, 312, 313, 314, 315, 316, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 331, 332, -1, -1, -1, -1, -1, - -1, 339, -1, -1, 342, -1, -1, 345, 346, -1, - 348, -1, 350, -1, 352, -1, 354, -1, -1, -1, - -1, -1, -1, -1, 362, -1, -1, -1, -1, 367, - 368, 369, 370, 371, 372, -1, -1, -1, 376, -1, - 378, 379, -1, 381, 382, 383, 384, -1, 386, 387, - 388, 257, 258, 259, -1, 261, -1, -1, -1, 265, - 266, -1, -1, -1, 270, -1, 272, 273, 274, 275, - 276, 277, 278, -1, -1, -1, -1, 283, 284, 285, - 286, 287, 288, 289, -1, -1, 292, -1, -1, -1, - -1, -1, -1, 299, -1, -1, 302, 303, 304, -1, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 331, 332, -1, -1, -1, - -1, -1, -1, 339, -1, -1, 342, -1, -1, 345, - 346, -1, 348, -1, 350, -1, 352, -1, 354, -1, - -1, -1, -1, -1, -1, -1, 362, -1, -1, -1, - -1, 367, 368, 369, 370, 371, 372, -1, -1, -1, - 376, -1, 378, 379, -1, 381, 382, 383, 384, -1, - 386, 387, 388, 257, 258, 259, -1, 261, -1, -1, - -1, 265, 266, -1, -1, -1, 270, -1, 272, 273, - 274, 275, 276, 277, 278, -1, -1, -1, -1, 283, - 284, 285, 286, 287, 288, 289, -1, -1, 292, -1, - -1, -1, -1, -1, -1, 299, -1, -1, 302, 303, - 304, -1, 306, 307, 308, 309, 310, 311, 312, 313, - 314, 315, 316, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 331, 332, -1, - -1, -1, -1, -1, -1, 339, -1, -1, 342, -1, - -1, 345, 346, -1, 348, -1, 350, -1, -1, -1, - 354, -1, -1, -1, -1, -1, -1, -1, 362, -1, - -1, -1, -1, 367, 368, 369, 370, 371, 372, -1, - -1, -1, 376, -1, 378, 379, -1, 381, 382, 383, - 384, -1, 386, 387, 388, 257, 258, 259, -1, 261, - -1, -1, -1, 265, 266, -1, -1, -1, 270, -1, - 272, 273, 274, 275, 276, 277, 278, -1, -1, -1, - -1, 283, 284, 285, 286, 287, 288, 289, -1, -1, - 292, -1, -1, -1, -1, -1, -1, 299, -1, -1, - 302, 303, 304, -1, 306, 307, 308, 309, 310, 311, - 312, 313, 314, 315, 316, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 331, - 332, -1, -1, -1, -1, -1, -1, 339, -1, -1, - 342, -1, -1, 345, 346, -1, 348, -1, -1, -1, - 352, -1, 354, -1, -1, -1, -1, -1, -1, -1, - 362, -1, -1, -1, -1, 367, 368, 369, 370, 371, - 372, -1, -1, -1, 376, -1, 378, 379, -1, 381, - 382, 383, 384, -1, 386, 387, 388, 257, 258, 259, - -1, 261, -1, -1, -1, 265, 266, -1, -1, -1, - 270, -1, 272, 273, 274, 275, 276, 277, 278, -1, - -1, -1, -1, 283, 284, 285, 286, 287, 288, 289, - -1, -1, 292, -1, -1, -1, -1, -1, -1, 299, - -1, -1, 302, 303, 304, -1, 306, 307, 308, 309, - 310, 311, 312, 313, 314, 315, 316, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 331, 332, -1, -1, -1, -1, -1, -1, 339, - -1, -1, 342, -1, -1, 345, 346, -1, 348, -1, - 350, -1, -1, -1, 354, -1, -1, -1, -1, -1, - -1, -1, 362, -1, -1, -1, -1, 367, 368, 369, - 370, 371, 372, -1, -1, -1, 376, -1, 378, 379, - -1, 381, 382, 383, 384, -1, 386, 387, 388, 257, - 258, 259, -1, 261, -1, -1, -1, 265, 266, -1, - -1, -1, 270, -1, 272, 273, 274, 275, 276, 277, - 278, -1, -1, -1, -1, 283, 284, 285, 286, 287, - 288, 289, -1, -1, 292, -1, -1, -1, -1, -1, - -1, 299, -1, -1, 302, 303, 304, -1, 306, 307, - 308, 309, 310, 311, 312, 313, 314, 315, 316, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 331, 332, -1, -1, -1, -1, -1, - -1, 339, -1, -1, 342, -1, -1, 345, 346, -1, - 348, -1, -1, -1, -1, -1, 354, -1, -1, -1, - -1, -1, -1, -1, 362, -1, -1, -1, -1, 367, - 368, 369, 370, 371, 372, -1, -1, -1, 376, -1, - 378, 379, -1, 381, 382, 383, 384, -1, 386, 387, - 388, 257, 258, 259, 260, 261, -1, -1, -1, 265, - 266, -1, -1, -1, 270, -1, 272, 273, 274, 275, - 276, 277, 278, -1, -1, -1, -1, 283, 284, 285, - 286, 287, 288, 289, -1, -1, 292, -1, -1, -1, - -1, -1, 298, 299, 300, 301, 302, 303, 304, -1, - 306, 307, 308, 309, 310, 311, -1, 313, 314, 315, - 316, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 331, 332, -1, -1, -1, - -1, -1, -1, 339, -1, -1, 342, -1, -1, 345, - 346, -1, 348, -1, 350, -1, -1, -1, 354, -1, - -1, -1, -1, -1, -1, -1, 362, -1, -1, -1, - -1, 367, 368, 369, 370, 371, 372, -1, -1, -1, - 376, -1, 378, 379, -1, 381, 382, 383, 384, -1, - 386, 387, 257, 258, 259, 260, 261, -1, -1, -1, - 265, 266, -1, -1, -1, 270, -1, 272, 273, 274, - 275, 276, 277, 278, -1, -1, -1, -1, 283, 284, - 285, 286, 287, 288, 289, -1, -1, 292, -1, -1, - -1, -1, -1, 298, 299, -1, 301, 302, 303, 304, - -1, 306, 307, 308, 309, 310, 311, -1, 313, 314, - 315, 316, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 331, 332, -1, -1, - -1, -1, -1, -1, 339, -1, -1, 342, -1, -1, - 345, 346, -1, 348, -1, 350, -1, -1, -1, 354, - -1, -1, -1, -1, -1, -1, -1, 362, -1, -1, - -1, -1, 367, 368, 369, 370, 371, 372, -1, -1, - -1, 376, -1, 378, 379, -1, 381, 382, 383, 384, - -1, 386, 387, 257, 258, 259, -1, 261, -1, -1, - -1, 265, 266, -1, -1, -1, 270, -1, 272, 273, - 274, 275, 276, 277, 278, -1, -1, -1, -1, 283, - 284, 285, 286, 287, 288, 289, -1, -1, 292, -1, - -1, -1, -1, -1, -1, 299, -1, -1, 302, 303, - 304, -1, 306, 307, 308, 309, 310, 311, -1, 313, - 314, 315, 316, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 331, 332, -1, - -1, -1, -1, -1, -1, 339, -1, -1, 342, 343, - -1, 345, 346, -1, 348, -1, -1, -1, -1, -1, - 354, -1, -1, -1, -1, -1, -1, -1, 362, -1, - -1, -1, -1, 367, 368, 369, 370, 371, 372, -1, - -1, -1, 376, -1, 378, 379, -1, 381, 382, 383, - 384, -1, 386, 387, 257, 258, 259, -1, 261, -1, - -1, -1, 265, 266, -1, -1, -1, 270, -1, 272, - 273, 274, 275, 276, 277, 278, -1, -1, -1, -1, - 283, 284, 285, 286, 287, 288, 289, -1, -1, 292, - -1, -1, -1, -1, -1, -1, 299, -1, -1, 302, - 303, 304, -1, 306, 307, 308, 309, 310, 311, -1, - 313, 314, 315, 316, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 331, 332, - -1, -1, -1, -1, -1, -1, 339, -1, -1, 342, - -1, -1, 345, 346, -1, 348, -1, 350, -1, -1, - -1, 354, -1, -1, -1, -1, -1, -1, -1, 362, - -1, -1, -1, -1, 367, 368, 369, 370, 371, 372, - -1, -1, -1, 376, -1, 378, 379, -1, 381, 382, - 383, 384, -1, 386, 387, 257, 258, 259, -1, 261, - -1, -1, -1, 265, 266, -1, -1, -1, 270, -1, - 272, 273, 274, 275, 276, 277, 278, -1, -1, -1, - -1, 283, 284, 285, 286, 287, 288, 289, -1, -1, - 292, -1, -1, -1, -1, -1, -1, 299, -1, -1, - 302, 303, 304, -1, 306, 307, 308, 309, 310, 311, - -1, 313, 314, 315, 316, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 331, - 332, -1, -1, -1, -1, -1, -1, 339, -1, -1, - 342, -1, -1, 345, 346, -1, 348, -1, 350, -1, - -1, -1, 354, -1, -1, -1, -1, -1, -1, -1, - 362, -1, -1, -1, -1, 367, 368, 369, 370, 371, - 372, -1, -1, -1, 376, -1, 378, 379, -1, 381, - 382, 383, 384, -1, 386, 387, 257, 258, 259, -1, - 261, -1, -1, -1, 265, 266, -1, -1, -1, 270, - -1, 272, 273, 274, 275, 276, 277, 278, -1, -1, - -1, -1, 283, 284, 285, 286, 287, 288, 289, -1, - -1, 292, -1, -1, -1, -1, -1, -1, 299, -1, - -1, 302, 303, 304, -1, 306, 307, 308, 309, 310, - 311, -1, 313, 314, 315, 316, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 331, 332, -1, -1, -1, -1, -1, -1, 339, -1, - -1, 342, -1, -1, 345, 346, -1, 348, -1, 350, - -1, -1, -1, 354, -1, -1, -1, -1, -1, -1, - -1, 362, -1, -1, -1, -1, 367, 368, 369, 370, - 371, 372, -1, -1, -1, 376, -1, 378, 379, -1, - 381, 382, 383, 384, -1, 386, 387, 257, 258, 259, - -1, 261, -1, -1, -1, 265, 266, -1, -1, -1, + -1, -1, -1, 387, -1, -1, 390, 257, 258, 259, + 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, + 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, + -1, -1, 282, 283, 284, 285, 286, 287, 288, 289, + 290, 291, -1, -1, -1, -1, 296, 297, 298, 299, + 300, 301, 302, 303, -1, 305, 306, -1, -1, 309, + -1, -1, -1, 313, 314, -1, 316, 317, 318, 319, + 320, 321, 322, -1, -1, 325, 326, -1, -1, -1, + -1, -1, 332, 333, 334, 335, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 349, + 350, -1, 352, 353, 354, 355, 356, 357, 358, 359, + 360, 361, 362, -1, -1, 365, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 256, 257, 258, 259, 260, + 261, -1, -1, -1, 265, 266, -1, 387, -1, 270, + 390, 272, 273, 274, 275, 276, 277, 278, -1, -1, + -1, 282, 283, 284, 285, 286, 287, 288, -1, -1, + 291, -1, -1, -1, -1, -1, 297, 298, 299, 300, + 301, 302, 303, -1, 305, 306, 307, 308, 309, 310, + -1, 312, 313, 314, 315, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 330, + 331, -1, -1, -1, -1, -1, -1, 338, -1, -1, + 341, -1, -1, 344, 345, -1, 347, -1, 349, -1, + -1, -1, 353, -1, -1, -1, -1, -1, -1, -1, + 361, -1, -1, -1, -1, 366, 367, 368, 369, 370, + 371, -1, -1, -1, 375, -1, 377, 378, -1, 380, + 381, 382, 383, -1, 385, 386, 256, 257, 258, 259, + 260, 261, -1, -1, -1, 265, 266, -1, -1, -1, 270, -1, 272, 273, 274, 275, 276, 277, 278, -1, - -1, -1, -1, 283, 284, 285, 286, 287, 288, 289, - -1, -1, 292, -1, -1, -1, -1, -1, -1, 299, - -1, -1, 302, 303, 304, -1, 306, 307, 308, 309, - 310, 311, -1, 313, 314, 315, 316, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 331, 332, -1, -1, -1, -1, -1, -1, 339, - -1, -1, 342, -1, -1, 345, 346, -1, 348, -1, - 350, -1, -1, -1, 354, -1, -1, -1, -1, -1, - -1, -1, 362, -1, -1, -1, -1, 367, 368, 369, - 370, 371, 372, -1, -1, -1, 376, -1, 378, 379, - -1, 381, 382, 383, 384, -1, 386, 387, 257, 258, + -1, -1, 282, 283, 284, 285, 286, 287, 288, -1, + -1, 291, -1, -1, -1, -1, -1, 297, 298, -1, + 300, 301, 302, 303, -1, 305, 306, 307, 308, 309, + 310, -1, 312, 313, 314, 315, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 330, 331, -1, -1, -1, -1, -1, -1, 338, -1, + -1, 341, -1, -1, 344, 345, -1, 347, -1, 349, + -1, -1, -1, 353, -1, -1, -1, -1, -1, -1, + -1, 361, -1, -1, -1, -1, 366, 367, 368, 369, + 370, 371, -1, -1, -1, 375, -1, 377, 378, -1, + 380, 381, 382, 383, -1, 385, 386, 256, 257, 258, + 259, 260, 261, -1, -1, -1, 265, 266, -1, -1, + -1, 270, -1, 272, 273, 274, 275, 276, 277, 278, + -1, -1, -1, 282, 283, 284, 285, 286, 287, 288, + -1, -1, 291, -1, -1, -1, -1, -1, 297, 298, + -1, 300, 301, 302, 303, -1, 305, 306, 307, 308, + 309, 310, -1, 312, 313, 314, 315, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 330, 331, -1, -1, -1, -1, -1, -1, 338, + -1, -1, 341, -1, -1, 344, 345, -1, 347, -1, + 349, -1, -1, -1, 353, -1, -1, -1, -1, -1, + -1, -1, 361, -1, -1, -1, -1, 366, 367, 368, + 369, 370, 371, -1, -1, -1, 375, -1, 377, 378, + -1, 380, 381, 382, 383, -1, 385, 386, 257, 258, 259, -1, 261, -1, -1, -1, 265, 266, -1, -1, -1, 270, -1, 272, 273, 274, 275, 276, 277, 278, - -1, -1, -1, -1, 283, 284, 285, 286, 287, 288, - 289, -1, -1, 292, -1, -1, -1, -1, -1, -1, - 299, -1, -1, 302, 303, 304, -1, 306, 307, 308, - 309, 310, 311, -1, 313, 314, 315, 316, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 331, 332, -1, -1, -1, -1, -1, -1, - 339, -1, -1, 342, -1, -1, 345, 346, -1, 348, - -1, 350, -1, -1, -1, 354, -1, -1, -1, -1, - -1, -1, -1, 362, -1, -1, -1, -1, 367, 368, - 369, 370, 371, 372, -1, -1, -1, 376, -1, 378, - 379, -1, 381, 382, 383, 384, -1, 386, 387, 257, + -1, -1, -1, 282, 283, 284, 285, 286, 287, 288, + -1, -1, 291, -1, -1, -1, -1, -1, -1, 298, + -1, -1, 301, 302, 303, -1, 305, 306, 307, 308, + 309, 310, 311, 312, 313, 314, 315, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 330, 331, -1, -1, -1, -1, -1, -1, 338, + -1, -1, 341, -1, -1, 344, 345, -1, 347, -1, + 349, -1, 351, -1, 353, -1, -1, -1, -1, -1, + -1, -1, 361, -1, -1, -1, -1, 366, 367, 368, + 369, 370, 371, -1, -1, -1, 375, -1, 377, 378, + -1, 380, 381, 382, 383, -1, 385, 386, 387, 257, 258, 259, -1, 261, -1, -1, -1, 265, 266, -1, -1, -1, 270, -1, 272, 273, 274, 275, 276, 277, - 278, -1, -1, -1, -1, 283, 284, 285, 286, 287, - 288, 289, -1, -1, 292, -1, -1, -1, -1, -1, - -1, 299, -1, -1, 302, 303, 304, -1, 306, 307, - 308, 309, 310, 311, -1, 313, 314, 315, 316, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 331, 332, -1, -1, -1, -1, -1, - -1, 339, -1, -1, 342, 343, -1, 345, 346, -1, - 348, -1, -1, -1, -1, -1, 354, -1, -1, -1, - -1, -1, -1, -1, 362, -1, -1, -1, -1, 367, - 368, 369, 370, 371, 372, -1, -1, -1, 376, -1, - 378, 379, -1, 381, 382, 383, 384, -1, 386, 387, + 278, -1, -1, -1, 282, 283, 284, 285, 286, 287, + 288, -1, -1, 291, -1, -1, -1, -1, -1, -1, + 298, -1, -1, 301, 302, 303, -1, 305, 306, 307, + 308, 309, 310, 311, 312, 313, 314, 315, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 330, 331, -1, -1, -1, -1, -1, -1, + 338, -1, -1, 341, -1, -1, 344, 345, -1, 347, + -1, 349, -1, 351, -1, 353, -1, -1, -1, -1, + -1, -1, -1, 361, -1, -1, -1, -1, 366, 367, + 368, 369, 370, 371, -1, -1, -1, 375, -1, 377, + 378, -1, 380, 381, 382, 383, -1, 385, 386, 387, 257, 258, 259, -1, 261, -1, -1, -1, 265, 266, -1, -1, -1, 270, -1, 272, 273, 274, 275, 276, - 277, 278, -1, -1, -1, -1, 283, 284, 285, 286, - 287, 288, 289, -1, -1, 292, -1, -1, -1, -1, - -1, -1, 299, -1, -1, 302, 303, 304, -1, 306, - 307, 308, 309, 310, 311, -1, 313, 314, 315, 316, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 331, 332, -1, -1, -1, -1, - -1, -1, 339, -1, -1, 342, -1, -1, 345, 346, - -1, 348, -1, -1, -1, -1, -1, 354, -1, -1, - -1, -1, -1, -1, -1, 362, -1, -1, -1, -1, - 367, 368, 369, 370, 371, 372, -1, -1, -1, 376, - -1, 378, 379, -1, 381, 382, 383, 384, -1, 386, + 277, 278, -1, -1, -1, 282, 283, 284, 285, 286, + 287, 288, -1, -1, 291, -1, -1, -1, -1, -1, + -1, 298, -1, -1, 301, 302, 303, -1, 305, 306, + 307, 308, 309, 310, 311, 312, 313, 314, 315, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 330, 331, -1, -1, -1, -1, -1, + -1, 338, -1, -1, 341, -1, -1, 344, 345, -1, + 347, -1, 349, -1, 351, -1, 353, -1, -1, -1, + -1, -1, -1, -1, 361, -1, -1, -1, -1, 366, + 367, 368, 369, 370, 371, -1, -1, -1, 375, -1, + 377, 378, -1, 380, 381, 382, 383, -1, 385, 386, 387, 257, 258, 259, -1, 261, -1, -1, -1, 265, 266, -1, -1, -1, 270, -1, 272, 273, 274, 275, - 276, 277, 278, -1, -1, -1, -1, 283, 284, 285, - 286, 287, 288, 289, -1, -1, 292, -1, -1, -1, - -1, -1, -1, 299, -1, -1, 302, 303, 304, -1, - 306, 307, 308, 309, 310, 311, -1, 313, 314, 315, - 316, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 331, 332, -1, -1, -1, - -1, -1, -1, 339, -1, -1, 342, -1, -1, 345, - 346, -1, 348, -1, -1, -1, -1, -1, 354, -1, - -1, -1, -1, -1, -1, -1, 362, -1, -1, -1, - -1, 367, 368, 369, 370, 371, 372, -1, -1, -1, - 376, -1, 378, 379, -1, 381, 382, 383, 384, -1, + 276, 277, 278, -1, -1, -1, 282, 283, 284, 285, + 286, 287, 288, -1, -1, 291, -1, -1, -1, -1, + -1, -1, 298, -1, -1, 301, 302, 303, -1, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 330, 331, -1, -1, -1, -1, + -1, -1, 338, -1, -1, 341, -1, -1, 344, 345, + -1, 347, -1, 349, -1, 351, -1, 353, -1, -1, + -1, -1, -1, -1, -1, 361, -1, -1, -1, -1, + 366, 367, 368, 369, 370, 371, -1, -1, -1, 375, + -1, 377, 378, -1, 380, 381, 382, 383, -1, 385, 386, 387, 257, 258, 259, -1, 261, -1, -1, -1, 265, 266, -1, -1, -1, 270, -1, 272, 273, 274, - 275, 276, 277, 278, -1, -1, -1, -1, 283, 284, - 285, 286, 287, 288, 289, -1, -1, 292, -1, -1, - -1, -1, -1, -1, 299, -1, -1, 302, 303, 304, - -1, 306, 307, 308, 309, 310, 311, -1, 313, 314, - 315, 316, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 331, 332, -1, -1, - -1, -1, -1, -1, 339, -1, -1, 342, -1, -1, - 345, 346, -1, 348, -1, -1, -1, -1, -1, 354, - -1, -1, -1, -1, -1, -1, -1, 362, -1, -1, - -1, -1, 367, 368, 369, 370, 371, 372, -1, -1, - -1, 376, -1, 378, 379, -1, 381, 382, 383, 384, - -1, 386, 387, 257, 258, 259, -1, 261, -1, -1, + 275, 276, 277, 278, -1, -1, -1, 282, 283, 284, + 285, 286, 287, 288, -1, -1, 291, -1, -1, -1, + -1, -1, -1, 298, -1, -1, 301, 302, 303, -1, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 330, 331, -1, -1, -1, + -1, -1, -1, 338, -1, -1, 341, -1, -1, 344, + 345, -1, 347, -1, 349, -1, 351, -1, 353, -1, + -1, -1, -1, -1, -1, -1, 361, -1, -1, -1, + -1, 366, 367, 368, 369, 370, 371, -1, -1, -1, + 375, -1, 377, 378, -1, 380, 381, 382, 383, -1, + 385, 386, 387, 257, 258, 259, -1, 261, -1, -1, -1, 265, 266, -1, -1, -1, 270, -1, 272, 273, - 274, 275, 276, 277, 278, -1, -1, -1, -1, 283, - 284, 285, 286, 287, 288, 289, -1, -1, 292, -1, - -1, -1, -1, -1, -1, 299, -1, -1, 302, 303, - 304, -1, 306, 307, 308, 309, 310, 311, -1, 313, - 314, 315, 316, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 331, 332, -1, - -1, -1, -1, -1, -1, 339, -1, -1, 342, -1, - -1, 345, 346, -1, 348, -1, -1, -1, -1, -1, - 354, -1, -1, -1, -1, -1, -1, -1, 362, -1, - -1, -1, -1, 367, 368, 369, 370, 371, 372, -1, - -1, -1, 376, -1, 378, 379, -1, 381, 382, 383, - 384, -1, 386, 387, 257, 258, 259, -1, 261, -1, + 274, 275, 276, 277, 278, -1, -1, -1, 282, 283, + 284, 285, 286, 287, 288, -1, -1, 291, -1, -1, + -1, -1, -1, -1, 298, -1, -1, 301, 302, 303, + -1, 305, 306, 307, 308, 309, 310, 311, 312, 313, + 314, 315, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 330, 331, -1, -1, + -1, -1, -1, -1, 338, -1, -1, 341, -1, -1, + 344, 345, -1, 347, -1, 349, -1, -1, -1, 353, + -1, -1, -1, -1, -1, -1, -1, 361, -1, -1, + -1, -1, 366, 367, 368, 369, 370, 371, -1, -1, + -1, 375, -1, 377, 378, -1, 380, 381, 382, 383, + -1, 385, 386, 387, 257, 258, 259, -1, 261, -1, -1, -1, 265, 266, -1, -1, -1, 270, -1, 272, - 273, 274, 275, 276, 277, 278, -1, -1, -1, -1, - 283, 284, 285, 286, 287, 288, 289, -1, -1, 292, - -1, -1, -1, -1, -1, -1, 299, -1, -1, 302, - 303, 304, -1, 306, 307, 308, 309, 310, 311, -1, - 313, -1, -1, 316, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 339, -1, -1, 342, - -1, -1, 345, 346, -1, 348, -1, 350, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 367, 368, 369, 370, 371, 372, - -1, -1, -1, 376, -1, 378, 379, -1, 381, 382, - 383, 384, -1, 386, 387, 257, 258, 259, -1, 261, + 273, 274, 275, 276, 277, 278, -1, -1, -1, 282, + 283, 284, 285, 286, 287, 288, -1, -1, 291, -1, + -1, -1, -1, -1, -1, 298, -1, -1, 301, 302, + 303, -1, 305, 306, 307, 308, 309, 310, 311, 312, + 313, 314, 315, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 330, 331, -1, + -1, -1, -1, -1, -1, 338, -1, -1, 341, -1, + -1, 344, 345, -1, 347, -1, -1, -1, 351, -1, + 353, -1, -1, -1, -1, -1, -1, -1, 361, -1, + -1, -1, -1, 366, 367, 368, 369, 370, 371, -1, + -1, -1, 375, -1, 377, 378, -1, 380, 381, 382, + 383, -1, 385, 386, 387, 257, 258, 259, -1, 261, -1, -1, -1, 265, 266, -1, -1, -1, 270, -1, 272, 273, 274, 275, 276, 277, 278, -1, -1, -1, - -1, 283, 284, 285, 286, 287, 288, 289, -1, -1, - 292, -1, -1, -1, -1, -1, -1, 299, -1, -1, - 302, 303, 304, -1, 306, 307, 308, 309, 310, 311, - -1, 313, -1, -1, 316, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 339, -1, -1, - 342, -1, -1, 345, 346, -1, 348, -1, 350, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 367, 368, 369, 370, 371, - 372, -1, -1, -1, 376, -1, 378, 379, -1, 381, - 382, 383, 384, -1, 386, 387, 257, 258, 259, -1, + 282, 283, 284, 285, 286, 287, 288, -1, -1, 291, + -1, -1, -1, -1, -1, -1, 298, -1, -1, 301, + 302, 303, -1, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, 315, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 330, 331, + -1, -1, -1, -1, -1, -1, 338, -1, -1, 341, + -1, -1, 344, 345, -1, 347, -1, 349, -1, -1, + -1, 353, -1, -1, -1, -1, -1, -1, -1, 361, + -1, -1, -1, -1, 366, 367, 368, 369, 370, 371, + -1, -1, -1, 375, -1, 377, 378, -1, 380, 381, + 382, 383, -1, 385, 386, 387, 257, 258, 259, -1, 261, -1, -1, -1, 265, 266, -1, -1, -1, 270, -1, 272, 273, 274, 275, 276, 277, 278, -1, -1, - -1, -1, 283, 284, 285, 286, 287, 288, 289, -1, - -1, 292, -1, -1, -1, -1, -1, -1, 299, -1, - -1, 302, 303, 304, -1, 306, 307, 308, 309, 310, - 311, -1, 313, -1, -1, 316, -1, -1, -1, -1, + -1, 282, 283, 284, 285, 286, 287, 288, -1, -1, + 291, -1, -1, -1, -1, -1, -1, 298, -1, -1, + 301, 302, 303, -1, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, 315, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 330, + 331, -1, -1, -1, -1, -1, -1, 338, -1, -1, + 341, -1, -1, 344, 345, -1, 347, -1, -1, -1, + -1, -1, 353, -1, -1, -1, -1, -1, -1, -1, + 361, -1, -1, -1, -1, 366, 367, 368, 369, 370, + 371, -1, -1, -1, 375, -1, 377, 378, -1, 380, + 381, 382, 383, -1, 385, 386, 387, 257, 258, 259, + 260, 261, -1, -1, -1, 265, 266, -1, -1, -1, + 270, -1, 272, 273, 274, 275, 276, 277, 278, -1, + -1, -1, 282, 283, 284, 285, 286, 287, 288, -1, + -1, 291, -1, -1, -1, -1, -1, 297, 298, 299, + 300, 301, 302, 303, -1, 305, 306, 307, 308, 309, + 310, -1, 312, 313, 314, 315, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 335, -1, -1, -1, 339, -1, - -1, 342, -1, -1, 345, 346, -1, 348, -1, -1, + 330, 331, -1, -1, -1, -1, -1, -1, 338, -1, + -1, 341, -1, -1, 344, 345, -1, 347, -1, 349, + -1, -1, -1, 353, -1, -1, -1, -1, -1, -1, + -1, 361, -1, -1, -1, -1, 366, 367, 368, 369, + 370, 371, -1, -1, -1, 375, -1, 377, 378, -1, + 380, 381, 382, 383, -1, 385, 386, 257, 258, 259, + 260, 261, -1, -1, -1, 265, 266, -1, -1, -1, + 270, -1, 272, 273, 274, 275, 276, 277, 278, -1, + -1, -1, 282, 283, 284, 285, 286, 287, 288, -1, + -1, 291, -1, -1, -1, -1, -1, 297, 298, -1, + 300, 301, 302, 303, -1, 305, 306, 307, 308, 309, + 310, -1, 312, 313, 314, 315, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 367, 368, 369, 370, - 371, 372, -1, -1, -1, 376, -1, 378, 379, -1, - 381, 382, 383, 384, -1, 386, 387, 257, 258, 259, + 330, 331, -1, -1, -1, -1, -1, -1, 338, -1, + -1, 341, -1, -1, 344, 345, -1, 347, -1, 349, + -1, -1, -1, 353, -1, -1, -1, -1, -1, -1, + -1, 361, -1, -1, -1, -1, 366, 367, 368, 369, + 370, 371, -1, -1, -1, 375, -1, 377, 378, -1, + 380, 381, 382, 383, -1, 385, 386, 257, 258, 259, -1, 261, -1, -1, -1, 265, 266, -1, -1, -1, 270, -1, 272, 273, 274, 275, 276, 277, 278, -1, - -1, -1, -1, 283, 284, 285, 286, 287, 288, 289, - -1, -1, 292, -1, -1, -1, -1, -1, -1, 299, - -1, -1, 302, 303, 304, -1, 306, 307, 308, 309, - 310, 311, -1, 313, -1, -1, 316, -1, -1, -1, + -1, -1, 282, 283, 284, 285, 286, 287, 288, -1, + -1, 291, -1, -1, -1, -1, -1, -1, 298, -1, + -1, 301, 302, 303, -1, 305, 306, 307, 308, 309, + 310, -1, 312, 313, 314, 315, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 339, - -1, -1, 342, -1, -1, 345, 346, -1, 348, -1, + 330, 331, -1, -1, -1, -1, -1, -1, 338, -1, + -1, 341, 342, -1, 344, 345, -1, 347, -1, -1, + -1, -1, -1, 353, -1, -1, -1, -1, -1, -1, + -1, 361, -1, -1, -1, -1, 366, 367, 368, 369, + 370, 371, -1, -1, -1, 375, -1, 377, 378, -1, + 380, 381, 382, 383, -1, 385, 386, 257, 258, 259, + -1, 261, -1, -1, -1, 265, 266, -1, -1, -1, + 270, -1, 272, 273, 274, 275, 276, 277, 278, -1, + -1, -1, 282, 283, 284, 285, 286, 287, 288, -1, + -1, 291, -1, -1, -1, -1, -1, -1, 298, -1, + -1, 301, 302, 303, -1, 305, 306, 307, 308, 309, + 310, -1, 312, 313, 314, 315, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 367, 368, 369, - 370, 371, 372, -1, -1, -1, 376, -1, 378, 379, - -1, 381, 382, 383, 384, -1, 386, 387, 257, 258, - 259, -1, 261, -1, -1, -1, 265, 266, -1, -1, - -1, 270, -1, 272, 273, 274, 275, 276, 277, 278, - -1, -1, -1, -1, 283, 284, 285, 286, 287, 288, - 289, -1, -1, 292, -1, -1, -1, -1, -1, -1, - 299, -1, -1, 302, 303, 304, -1, 306, 307, 308, - 309, 310, 311, -1, 313, -1, -1, 316, -1, -1, + 330, 331, -1, -1, -1, -1, -1, -1, 338, -1, + -1, 341, -1, -1, 344, 345, -1, 347, -1, 349, + -1, -1, -1, 353, -1, -1, -1, -1, -1, -1, + -1, 361, -1, -1, -1, -1, 366, 367, 368, 369, + 370, 371, -1, -1, -1, 375, -1, 377, 378, -1, + 380, 381, 382, 383, -1, 385, 386, 257, 258, 259, + -1, 261, -1, -1, -1, 265, 266, -1, -1, -1, + 270, -1, 272, 273, 274, 275, 276, 277, 278, -1, + -1, -1, 282, 283, 284, 285, 286, 287, 288, -1, + -1, 291, -1, -1, -1, -1, -1, -1, 298, -1, + -1, 301, 302, 303, -1, 305, 306, 307, 308, 309, + 310, -1, 312, 313, 314, 315, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 330, 331, -1, -1, -1, -1, -1, -1, 338, -1, + -1, 341, -1, -1, 344, 345, -1, 347, -1, 349, + -1, -1, -1, 353, -1, -1, -1, -1, -1, -1, + -1, 361, -1, -1, -1, -1, 366, 367, 368, 369, + 370, 371, -1, -1, -1, 375, -1, 377, 378, -1, + 380, 381, 382, 383, -1, 385, 386, 257, 258, 259, + -1, 261, -1, -1, -1, 265, 266, -1, -1, -1, + 270, -1, 272, 273, 274, 275, 276, 277, 278, -1, + -1, -1, 282, 283, 284, 285, 286, 287, 288, -1, + -1, 291, -1, -1, -1, -1, -1, -1, 298, -1, + -1, 301, 302, 303, -1, 305, 306, 307, 308, 309, + 310, -1, 312, 313, 314, 315, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 330, 331, -1, -1, -1, -1, -1, -1, 338, -1, + -1, 341, -1, -1, 344, 345, -1, 347, -1, 349, + -1, -1, -1, 353, -1, -1, -1, -1, -1, -1, + -1, 361, -1, -1, -1, -1, 366, 367, 368, 369, + 370, 371, -1, -1, -1, 375, -1, 377, 378, -1, + 380, 381, 382, 383, -1, 385, 386, 257, 258, 259, + -1, 261, -1, -1, -1, 265, 266, -1, -1, -1, + 270, -1, 272, 273, 274, 275, 276, 277, 278, -1, + -1, -1, 282, 283, 284, 285, 286, 287, 288, -1, + -1, 291, -1, -1, -1, -1, -1, -1, 298, -1, + -1, 301, 302, 303, -1, 305, 306, 307, 308, 309, + 310, -1, 312, 313, 314, 315, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 339, -1, -1, 342, -1, -1, 345, 346, -1, 348, + 330, 331, -1, -1, -1, -1, -1, -1, 338, -1, + -1, 341, -1, -1, 344, 345, -1, 347, -1, 349, + -1, -1, -1, 353, -1, -1, -1, -1, -1, -1, + -1, 361, -1, -1, -1, -1, 366, 367, 368, 369, + 370, 371, -1, -1, -1, 375, -1, 377, 378, -1, + 380, 381, 382, 383, -1, 385, 386, 257, 258, 259, + -1, 261, -1, -1, -1, 265, 266, -1, -1, -1, + 270, -1, 272, 273, 274, 275, 276, 277, 278, -1, + -1, -1, 282, 283, 284, 285, 286, 287, 288, -1, + -1, 291, -1, -1, -1, -1, -1, -1, 298, -1, + -1, 301, 302, 303, -1, 305, 306, 307, 308, 309, + 310, -1, 312, 313, 314, 315, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 367, 368, - 369, 370, 371, 372, -1, -1, -1, 376, -1, 378, - 379, -1, 381, 382, 383, 384, -1, 386, 387, 257, - 258, 259, -1, 261, -1, -1, -1, 265, 266, -1, - -1, -1, 270, -1, 272, 273, 274, 275, 276, 277, - 278, -1, -1, -1, -1, 283, 284, 285, 286, 287, - 288, 289, -1, -1, 292, -1, -1, -1, -1, -1, - -1, 299, -1, -1, 302, 303, 304, -1, 306, 307, - 308, 309, 310, 311, -1, 313, -1, -1, 316, -1, + 330, 331, -1, -1, -1, -1, -1, -1, 338, -1, + -1, 341, -1, -1, 344, 345, -1, 347, -1, 349, + -1, -1, -1, 353, -1, -1, -1, -1, -1, -1, + -1, 361, -1, -1, -1, -1, 366, 367, 368, 369, + 370, 371, -1, -1, -1, 375, -1, 377, 378, -1, + 380, 381, 382, 383, -1, 385, 386, 257, 258, 259, + -1, 261, -1, -1, -1, 265, 266, -1, -1, -1, + 270, -1, 272, 273, 274, 275, 276, 277, 278, -1, + -1, -1, 282, 283, 284, 285, 286, 287, 288, -1, + -1, 291, -1, -1, -1, -1, -1, -1, 298, -1, + -1, 301, 302, 303, -1, 305, 306, 307, 308, 309, + 310, -1, 312, 313, 314, 315, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 330, 331, -1, -1, -1, -1, -1, -1, 338, -1, + -1, 341, 342, -1, 344, 345, -1, 347, -1, -1, + -1, -1, -1, 353, -1, -1, -1, -1, -1, -1, + -1, 361, -1, -1, -1, -1, 366, 367, 368, 369, + 370, 371, -1, -1, -1, 375, -1, 377, 378, -1, + 380, 381, 382, 383, -1, 385, 386, 257, 258, 259, + -1, 261, -1, -1, -1, 265, 266, -1, -1, -1, + 270, -1, 272, 273, 274, 275, 276, 277, 278, -1, + -1, -1, 282, 283, 284, 285, 286, 287, 288, -1, + -1, 291, -1, -1, -1, -1, -1, -1, 298, -1, + -1, 301, 302, 303, -1, 305, 306, 307, 308, 309, + 310, -1, 312, 313, 314, 315, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 339, -1, -1, 342, -1, -1, 345, 346, -1, - 348, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 367, - 368, 369, 370, 371, 372, -1, -1, -1, 376, -1, - 378, 379, -1, 381, 382, 383, 384, -1, 386, 387, - 257, 258, 259, -1, 261, -1, -1, -1, 265, 266, - -1, -1, -1, 270, -1, 272, 273, 274, 275, 276, - 277, 278, -1, -1, -1, -1, 283, 284, 285, 286, - 287, 288, 289, -1, -1, 292, -1, -1, -1, -1, - -1, -1, 299, -1, -1, 302, 303, 304, -1, 306, - 307, 308, 309, 310, 311, -1, 313, -1, -1, 316, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 339, -1, -1, 342, -1, -1, 345, 346, - -1, 348, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 367, 368, 369, 370, 371, 372, -1, -1, -1, 376, - -1, 378, 379, -1, 381, 382, 383, 384, -1, 386, - 387, 306, 307, -1, -1, 310, -1, -1, -1, 314, - 315, -1, 317, 318, 319, 320, 321, 322, 323, -1, - -1, 326, 327, -1, -1, -1, -1, -1, 333, 334, - 335, 336, -1, -1, -1, -1, -1, -1, 343, -1, - -1, -1, -1, -1, -1, 350, 351, -1, 353, 354, - 355, 356, 357, 358, 359, 360, 361, 362, 363, 306, - 307, 366, -1, 310, -1, -1, -1, 314, 315, -1, - 317, 318, 319, 320, 321, 322, 323, -1, -1, 326, - 327, -1, -1, 388, -1, -1, 333, 334, 335, 336, - -1, -1, -1, -1, -1, -1, 343, -1, -1, -1, - -1, -1, -1, 350, 351, -1, 353, 354, 355, 356, - 357, 358, 359, 360, 361, 362, 363, 306, 307, 366, - -1, 310, -1, -1, -1, 314, 315, -1, 317, 318, - 319, 320, 321, 322, 323, -1, -1, 326, 327, -1, - -1, 388, -1, -1, 333, 334, 335, 336, -1, -1, - -1, -1, -1, -1, 343, -1, -1, -1, -1, -1, - -1, 350, 351, -1, 353, 354, 355, 356, 357, 358, - 359, 360, 361, 362, 363, 306, 307, 366, -1, 310, - -1, -1, -1, 314, 315, -1, 317, 318, 319, 320, - 321, 322, 323, -1, -1, 326, 327, -1, -1, 388, - -1, -1, 333, 334, 335, 336, -1, -1, -1, -1, - -1, -1, 343, -1, -1, -1, -1, -1, -1, 350, - 351, -1, 353, 354, 355, 356, 357, 358, 359, 360, - 361, 362, 363, 306, 307, 366, -1, 310, -1, -1, - -1, 314, 315, -1, 317, 318, 319, 320, 321, 322, - 323, -1, -1, 326, 327, -1, -1, 388, -1, -1, - 333, 334, 335, 336, -1, -1, -1, -1, -1, -1, - 343, -1, -1, -1, -1, -1, -1, 350, 351, -1, - 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, - 363, 306, 307, 366, -1, 310, -1, -1, -1, 314, - 315, -1, 317, 318, 319, 320, 321, 322, 323, -1, - -1, 326, 327, -1, -1, 388, -1, -1, 333, 334, - 335, 336, -1, -1, -1, -1, -1, -1, 343, -1, - -1, -1, -1, -1, -1, 350, 351, -1, 353, 354, - 355, 356, 357, 358, 359, 360, 361, 362, 363, 306, - 307, 366, -1, 310, -1, -1, -1, 314, 315, -1, - 317, 318, 319, 320, 321, 322, 323, -1, -1, 326, - 327, -1, -1, 388, -1, -1, 333, 334, 335, 336, - -1, -1, -1, -1, -1, -1, 343, -1, -1, -1, - -1, -1, -1, 350, 351, -1, 353, 354, 355, 356, - 357, 358, 359, 360, 361, 362, 363, 306, 307, 366, - -1, 310, -1, -1, -1, 314, 315, -1, 317, 318, - 319, 320, 321, 322, 323, -1, -1, 326, 327, -1, - -1, 388, -1, -1, 333, 334, 335, 336, -1, -1, - -1, -1, -1, -1, 343, -1, -1, -1, -1, -1, - -1, 350, 351, -1, 353, 354, 355, 356, 357, 358, - 359, 360, 361, 362, 363, 306, 307, 366, -1, 310, - -1, -1, -1, 314, 315, -1, 317, 318, 319, 320, - 321, 322, 323, -1, -1, 326, 327, -1, -1, 388, - -1, -1, 333, 334, 335, 336, -1, -1, -1, -1, - -1, -1, 343, -1, -1, -1, -1, -1, -1, 350, - 351, -1, 353, 354, 355, 356, 357, 358, 359, 360, - 361, 362, 363, 306, 307, 366, -1, 310, -1, -1, - -1, 314, 315, -1, 317, 318, 319, 320, 321, 322, - 323, -1, -1, 326, 327, -1, -1, 388, -1, -1, - 333, 334, 335, 336, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 350, 351, -1, - 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, - 363, -1, -1, 366, -1, -1, -1, -1, -1, -1, + 330, 331, -1, -1, -1, -1, -1, -1, 338, -1, + -1, 341, -1, -1, 344, 345, -1, 347, -1, -1, + -1, -1, -1, 353, -1, -1, -1, -1, -1, -1, + -1, 361, -1, -1, -1, -1, 366, 367, 368, 369, + 370, 371, -1, -1, -1, 375, -1, 377, 378, -1, + 380, 381, 382, 383, -1, 385, 386, 257, 258, 259, + -1, 261, -1, -1, -1, 265, 266, -1, -1, -1, + 270, -1, 272, 273, 274, 275, 276, 277, 278, -1, + -1, -1, 282, 283, 284, 285, 286, 287, 288, -1, + -1, 291, -1, -1, -1, -1, -1, -1, 298, -1, + -1, 301, 302, 303, -1, 305, 306, 307, 308, 309, + 310, -1, 312, 313, 314, 315, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 330, 331, -1, -1, -1, -1, -1, -1, 338, -1, + -1, 341, -1, -1, 344, 345, -1, 347, -1, -1, + -1, -1, -1, 353, -1, -1, -1, -1, -1, -1, + -1, 361, -1, -1, -1, -1, 366, 367, 368, 369, + 370, 371, -1, -1, -1, 375, -1, 377, 378, -1, + 380, 381, 382, 383, -1, 385, 386, 257, 258, 259, + -1, 261, -1, -1, -1, 265, 266, -1, -1, -1, + 270, -1, 272, 273, 274, 275, 276, 277, 278, -1, + -1, -1, 282, 283, 284, 285, 286, 287, 288, -1, + -1, 291, -1, -1, -1, -1, -1, -1, 298, -1, + -1, 301, 302, 303, -1, 305, 306, 307, 308, 309, + 310, -1, 312, 313, 314, 315, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 330, 331, -1, -1, -1, -1, -1, -1, 338, -1, + -1, 341, -1, -1, 344, 345, -1, 347, -1, -1, + -1, -1, -1, 353, -1, -1, -1, -1, -1, -1, + -1, 361, -1, -1, -1, -1, 366, 367, 368, 369, + 370, 371, -1, -1, -1, 375, -1, 377, 378, -1, + 380, 381, 382, 383, -1, 385, 386, 257, 258, 259, + -1, 261, -1, -1, -1, 265, 266, -1, -1, -1, + 270, -1, 272, 273, 274, 275, 276, 277, 278, -1, + -1, -1, 282, 283, 284, 285, 286, 287, 288, -1, + -1, 291, -1, -1, -1, -1, -1, -1, 298, -1, + -1, 301, 302, 303, -1, 305, 306, 307, 308, 309, + 310, -1, 312, 313, 314, 315, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 330, 331, -1, -1, -1, -1, -1, -1, 338, -1, + -1, 341, -1, -1, 344, 345, -1, 347, -1, -1, + -1, -1, -1, 353, -1, -1, -1, -1, -1, -1, + -1, 361, -1, -1, -1, -1, 366, 367, 368, 369, + 370, 371, -1, -1, -1, 375, -1, 377, 378, -1, + 380, 381, 382, 383, -1, 385, 386, 257, 258, 259, + -1, 261, -1, -1, -1, 265, 266, -1, -1, -1, + 270, -1, 272, 273, 274, 275, 276, 277, 278, -1, + -1, -1, 282, 283, 284, 285, 286, 287, 288, -1, + -1, 291, -1, -1, -1, -1, -1, -1, 298, -1, + -1, 301, 302, 303, -1, 305, 306, 307, 308, 309, + 310, -1, 312, -1, -1, 315, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 338, -1, + -1, 341, -1, -1, 344, 345, -1, 347, -1, 349, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 366, 367, 368, 369, + 370, 371, -1, -1, -1, 375, -1, 377, 378, -1, + 380, 381, 382, 383, -1, 385, 386, 257, 258, 259, + -1, 261, -1, -1, -1, 265, 266, -1, -1, -1, + 270, -1, 272, 273, 274, 275, 276, 277, 278, -1, + -1, -1, 282, 283, 284, 285, 286, 287, 288, -1, + -1, 291, -1, -1, -1, -1, -1, -1, 298, -1, + -1, 301, 302, 303, -1, 305, 306, 307, 308, 309, + 310, -1, 312, -1, -1, 315, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 338, -1, + -1, 341, -1, -1, 344, 345, -1, 347, -1, 349, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 366, 367, 368, 369, + 370, 371, -1, -1, -1, 375, -1, 377, 378, -1, + 380, 381, 382, 383, -1, 385, 386, 257, 258, 259, + -1, 261, -1, -1, -1, 265, 266, -1, -1, -1, + 270, -1, 272, 273, 274, 275, 276, 277, 278, -1, + -1, -1, 282, 283, 284, 285, 286, 287, 288, -1, + -1, 291, -1, -1, -1, -1, -1, -1, 298, -1, + -1, 301, 302, 303, -1, 305, 306, 307, 308, 309, + 310, -1, 312, -1, -1, 315, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 334, -1, -1, -1, 338, -1, + -1, 341, -1, -1, 344, 345, -1, 347, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 366, 367, 368, 369, + 370, 371, -1, -1, -1, 375, -1, 377, 378, -1, + 380, 381, 382, 383, -1, 385, 386, 257, 258, 259, + -1, 261, -1, -1, -1, 265, 266, -1, -1, -1, + 270, -1, 272, 273, 274, 275, 276, 277, 278, -1, + -1, -1, 282, 283, 284, 285, 286, 287, 288, -1, + -1, 291, -1, -1, -1, -1, -1, -1, 298, -1, + -1, 301, 302, 303, -1, 305, 306, 307, 308, 309, + 310, -1, 312, -1, -1, 315, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 338, -1, + -1, 341, -1, -1, 344, 345, -1, 347, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 366, 367, 368, 369, + 370, 371, -1, -1, -1, 375, -1, 377, 378, -1, + 380, 381, 382, 383, -1, 385, 386, 257, 258, 259, + -1, 261, -1, -1, -1, 265, 266, -1, -1, -1, + 270, -1, 272, 273, 274, 275, 276, 277, 278, -1, + -1, -1, 282, 283, 284, 285, 286, 287, 288, -1, + -1, 291, -1, -1, -1, -1, -1, -1, 298, -1, + -1, 301, 302, 303, -1, 305, 306, 307, 308, 309, + 310, -1, 312, -1, -1, 315, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 338, -1, + -1, 341, -1, -1, 344, 345, -1, 347, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 366, 367, 368, 369, + 370, 371, -1, -1, -1, 375, -1, 377, 378, -1, + 380, 381, 382, 383, -1, 385, 386, 257, 258, 259, + -1, 261, -1, -1, -1, 265, 266, -1, -1, -1, + 270, -1, 272, 273, 274, 275, 276, 277, 278, -1, + -1, -1, 282, 283, 284, 285, 286, 287, 288, -1, + -1, 291, -1, -1, -1, -1, -1, -1, 298, -1, + -1, 301, 302, 303, -1, 305, 306, 307, 308, 309, + 310, -1, 312, -1, -1, 315, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 338, -1, + -1, 341, -1, -1, 344, 345, -1, 347, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 366, 367, 368, 369, + 370, 371, -1, -1, -1, 375, -1, 377, 378, -1, + 380, 381, 382, 383, -1, 385, 386, 257, 258, 259, + -1, 261, -1, -1, -1, 265, 266, -1, -1, -1, + 270, -1, 272, 273, 274, 275, 276, 277, 278, -1, + -1, -1, 282, 283, 284, 285, 286, 287, 288, -1, + -1, 291, -1, -1, -1, -1, -1, -1, 298, -1, + -1, 301, 302, 303, -1, 305, 306, 307, 308, 309, + 310, -1, 312, -1, -1, 315, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 338, -1, + -1, 341, -1, -1, 344, 345, -1, 347, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 366, 367, 368, 369, + 370, 371, -1, -1, -1, 375, -1, 377, 378, -1, + 380, 381, 382, 383, -1, 385, 386, 305, 306, -1, + -1, 309, -1, -1, -1, 313, 314, -1, 316, 317, + 318, 319, 320, 321, 322, -1, -1, 325, 326, -1, + -1, -1, -1, -1, 332, 333, 334, 335, -1, -1, + -1, -1, -1, -1, 342, -1, -1, -1, -1, -1, + -1, 349, 350, -1, 352, 353, 354, 355, 356, 357, + 358, 359, 360, 361, 362, 305, 306, 365, -1, 309, + -1, -1, -1, 313, 314, -1, 316, 317, 318, 319, + 320, 321, 322, -1, -1, 325, 326, -1, -1, 387, + -1, -1, 332, 333, 334, 335, -1, -1, -1, -1, + -1, -1, 342, -1, -1, -1, -1, -1, -1, 349, + 350, -1, 352, 353, 354, 355, 356, 357, 358, 359, + 360, 361, 362, 305, 306, 365, -1, 309, -1, -1, + -1, 313, 314, -1, 316, 317, 318, 319, 320, 321, + 322, -1, -1, 325, 326, -1, -1, 387, -1, -1, + 332, 333, 334, 335, -1, -1, -1, -1, -1, -1, + 342, -1, -1, -1, -1, -1, -1, 349, 350, -1, + 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, + 362, 305, 306, 365, -1, 309, -1, -1, -1, 313, + 314, -1, 316, 317, 318, 319, 320, 321, 322, -1, + -1, 325, 326, -1, -1, 387, -1, -1, 332, 333, + 334, 335, -1, -1, -1, -1, -1, -1, 342, -1, + -1, -1, -1, -1, -1, 349, 350, -1, 352, 353, + 354, 355, 356, 357, 358, 359, 360, 361, 362, 305, + 306, 365, -1, 309, -1, -1, -1, 313, 314, -1, + 316, 317, 318, 319, 320, 321, 322, -1, -1, 325, + 326, -1, -1, 387, -1, -1, 332, 333, 334, 335, + -1, -1, -1, -1, -1, -1, 342, -1, -1, -1, + -1, -1, -1, 349, 350, -1, 352, 353, 354, 355, + 356, 357, 358, 359, 360, 361, 362, 305, 306, 365, + -1, 309, -1, -1, -1, 313, 314, -1, 316, 317, + 318, 319, 320, 321, 322, -1, -1, 325, 326, -1, + -1, 387, -1, -1, 332, 333, 334, 335, -1, -1, + -1, -1, -1, -1, 342, -1, -1, -1, -1, -1, + -1, 349, 350, -1, 352, 353, 354, 355, 356, 357, + 358, 359, 360, 361, 362, 305, 306, 365, -1, 309, + -1, -1, -1, 313, 314, -1, 316, 317, 318, 319, + 320, 321, 322, -1, -1, 325, 326, -1, -1, 387, + -1, -1, 332, 333, 334, 335, -1, -1, -1, -1, + -1, -1, 342, -1, -1, -1, -1, -1, -1, 349, + 350, -1, 352, 353, 354, 355, 356, 357, 358, 359, + 360, 361, 362, 305, 306, 365, -1, 309, -1, -1, + -1, 313, 314, -1, 316, 317, 318, 319, 320, 321, + 322, -1, -1, 325, 326, -1, -1, 387, -1, -1, + 332, 333, 334, 335, -1, -1, -1, -1, -1, -1, + 342, -1, -1, -1, -1, -1, -1, 349, 350, -1, + 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, + 362, 305, 306, 365, -1, 309, -1, -1, -1, 313, + 314, -1, 316, 317, 318, 319, 320, 321, 322, -1, + -1, 325, 326, -1, -1, 387, -1, -1, 332, 333, + 334, 335, -1, -1, -1, -1, -1, -1, 342, -1, + -1, -1, -1, -1, -1, 349, 350, -1, 352, 353, + 354, 355, 356, 357, 358, 359, 360, 361, 362, 305, + 306, 365, -1, 309, -1, -1, -1, 313, 314, -1, + 316, 317, 318, 319, 320, 321, 322, -1, -1, 325, + 326, -1, -1, 387, -1, -1, 332, 333, 334, 335, + -1, -1, -1, -1, -1, -1, 342, -1, -1, -1, + -1, -1, -1, 349, 350, -1, 352, 353, 354, 355, + 356, 357, 358, 359, 360, 361, 362, 305, 306, 365, + -1, 309, -1, -1, -1, 313, 314, -1, 316, 317, + 318, 319, 320, 321, 322, -1, -1, 325, 326, -1, + -1, 387, -1, -1, 332, 333, 334, 335, -1, -1, + -1, -1, -1, -1, 342, -1, -1, -1, -1, -1, + -1, 349, 350, -1, 352, 353, 354, 355, 356, 357, + 358, 359, 360, 361, 362, 305, 306, 365, -1, 309, + -1, -1, -1, 313, 314, -1, 316, 317, 318, 319, + 320, 321, 322, -1, -1, 325, 326, -1, -1, 387, + -1, -1, 332, 333, 334, 335, -1, -1, -1, -1, + -1, -1, 342, -1, -1, -1, -1, -1, -1, 349, + 350, -1, 352, 353, 354, 355, 356, 357, 358, 359, + 360, 361, 362, -1, -1, 365, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 388, + -1, -1, -1, -1, -1, -1, -1, 387, }; } diff --git a/src/main/java/org/truffleruby/parser/parser/skeleton.parser b/src/main/java/org/truffleruby/parser/parser/skeleton.parser index f3754f00623a..79f5c005f596 100644 --- a/src/main/java/org/truffleruby/parser/parser/skeleton.parser +++ b/src/main/java/org/truffleruby/parser/parser/skeleton.parser @@ -55,7 +55,7 @@ t protected static final String [] yyRule = { yyRule-strings t }; t -t // protected org.truffleruby.parser.parser.YYDebug yydebug; +t protected org.truffleruby.parser.parser.YYDebug yydebug; t t /** index-checked interface to {@link #yyNames}. t @param token single character or %token value. diff --git a/src/main/java/org/truffleruby/yarp/YARPTranslator.java b/src/main/java/org/truffleruby/yarp/YARPTranslator.java index edb1ebf3166d..0bbe50bc8016 100644 --- a/src/main/java/org/truffleruby/yarp/YARPTranslator.java +++ b/src/main/java/org/truffleruby/yarp/YARPTranslator.java @@ -81,7 +81,7 @@ public RubyNode visitCallNode(Nodes.CallNode node) { boolean ignoreVisibility = node.receiver == null; return new RubyCallNode(new RubyCallNodeParameters(receiver, methodName, null, - EmptyArgumentsDescriptor.INSTANCE, translatedArguments, false, ignoreVisibility)); + EmptyArgumentsDescriptor.INSTANCE, translatedArguments, ignoreVisibility)); } @Override diff --git a/src/main/ruby/truffleruby/core/truffle/internal.rb b/src/main/ruby/truffleruby/core/truffle/internal.rb index 98cf13baf9f6..33ccce0f6fa0 100644 --- a/src/main/ruby/truffleruby/core/truffle/internal.rb +++ b/src/main/ruby/truffleruby/core/truffle/internal.rb @@ -57,11 +57,16 @@ def self.when_splat(cases, expression) end end - def self.array_pattern_matches?(pattern, expression) - return false unless pattern.length == expression.length - - pattern.zip(expression).all? do |a, b| - a === b + def self.deconstruct_checked(pattern) + if pattern.respond_to? :deconstruct + deconstructed = pattern.deconstruct + if Primitive.object_kind_of?(deconstructed, Array) + deconstructed + else + raise TypeError,'deconstruct must return Array' + end + else + nil end end diff --git a/tool/patch_parser.rb b/tool/patch_parser.rb index 481f8916a98f..638e78076839 100644 --- a/tool/patch_parser.rb +++ b/tool/patch_parser.rb @@ -27,10 +27,10 @@ '"tLPAREN2"'=> '"\'( arg\'"', '"tRPAREN"' => '"\')\'"', '"tLPAREN_ARG"' => '"\'[\'"', - '"tLBRACK"' => '"\'{\'"', - '"tRBRACK"' => '"\'{ arg\'"', - '"tLBRACE"' => '"\'[\'"', - '"tLBRACE_ARG"' => '"\'[ args\'"', + '"tLBRACK"' => '"\'[\'"', + '"tRBRACK"' => '"\'[ arg\'"', + '"tLBRACE"' => '"\'{\'"', + '"tLBRACE_ARG"' => '"\'{ args\'"', '"tSTAR"' => '"\'*\'"', '"tSTAR2"' => '"\'*\'"', '"tAMPER"' => '"\'&\'"',