diff -r 9a0caf6e7a16 Grammar/Grammar --- a/Grammar/Grammar Tue Apr 07 01:30:33 2015 -0400 +++ b/Grammar/Grammar Tue Apr 07 06:17:38 2015 -0400 @@ -111,17 +111,26 @@ sliceop: ':' [test] exprlist: (expr|star_expr) (',' (expr|star_expr))* [','] testlist: test (',' test)* [','] -dictorsetmaker: ( (test ':' test (comp_for | (',' test ':' test)* [','])) | - (test (comp_for | (',' test)* [','])) ) +dictorsetmaker: ( ((test ':' test | '**' expr) + (comp_for | (',' (test ':' test | '**' expr))* [','])) | + ((test | star_expr) + (comp_for | (',' (test | star_expr))* [','])) ) classdef: 'class' NAME ['(' [arglist] ')'] ':' suite -arglist: (argument ',')* (argument [','] - |'*' test (',' argument)* [',' '**' test] - |'**' test) +arglist: argument (',' argument)* [','] + # The reason that keywords are test nodes instead of NAME is that using NAME # results in an ambiguity. ast.c makes sure it's a NAME. -argument: test [comp_for] | test '=' test # Really [keyword '='] test +# "test '=' test" is really "keyword '=' test", but we have no such token. +# These need to be in a single rule to avoid grammar that is ambiguous +# to our LL(1) parser. Even though 'test' includes '*expr' in star_expr, +# we explicitly match '*' here, too, to give it proper precedence. +argument: ( test [comp_for] | + test '=' test | + '**' expr | + star_expr ) + comp_iter: comp_for | comp_if comp_for: 'for' exprlist 'in' or_test [comp_iter] comp_if: 'if' test_nocond [comp_iter] diff -r 9a0caf6e7a16 Include/Python-ast.h --- a/Include/Python-ast.h Tue Apr 07 01:30:33 2015 -0400 +++ b/Include/Python-ast.h Tue Apr 07 06:17:38 2015 -0400 @@ -84,8 +84,6 @@ identifier name; asdl_seq *bases; asdl_seq *keywords; - expr_ty starargs; - expr_ty kwargs; asdl_seq *body; asdl_seq *decorator_list; } ClassDef; @@ -263,8 +261,6 @@ expr_ty func; asdl_seq *args; asdl_seq *keywords; - expr_ty starargs; - expr_ty kwargs; } Call; struct { @@ -406,11 +402,10 @@ stmt_ty _Py_FunctionDef(identifier name, arguments_ty args, asdl_seq * body, asdl_seq * decorator_list, expr_ty returns, int lineno, int col_offset, PyArena *arena); -#define ClassDef(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) _Py_ClassDef(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) +#define ClassDef(a0, a1, a2, a3, a4, a5, a6, a7) _Py_ClassDef(a0, a1, a2, a3, a4, a5, a6, a7) stmt_ty _Py_ClassDef(identifier name, asdl_seq * bases, asdl_seq * keywords, - expr_ty starargs, expr_ty kwargs, asdl_seq * body, - asdl_seq * decorator_list, int lineno, int col_offset, - PyArena *arena); + asdl_seq * body, asdl_seq * decorator_list, int lineno, + int col_offset, PyArena *arena); #define Return(a0, a1, a2, a3) _Py_Return(a0, a1, a2, a3) stmt_ty _Py_Return(expr_ty value, int lineno, int col_offset, PyArena *arena); #define Delete(a0, a1, a2, a3) _Py_Delete(a0, a1, a2, a3) @@ -504,10 +499,9 @@ #define Compare(a0, a1, a2, a3, a4, a5) _Py_Compare(a0, a1, a2, a3, a4, a5) expr_ty _Py_Compare(expr_ty left, asdl_int_seq * ops, asdl_seq * comparators, int lineno, int col_offset, PyArena *arena); -#define Call(a0, a1, a2, a3, a4, a5, a6, a7) _Py_Call(a0, a1, a2, a3, a4, a5, a6, a7) -expr_ty _Py_Call(expr_ty func, asdl_seq * args, asdl_seq * keywords, expr_ty - starargs, expr_ty kwargs, int lineno, int col_offset, PyArena - *arena); +#define Call(a0, a1, a2, a3, a4, a5) _Py_Call(a0, a1, a2, a3, a4, a5) +expr_ty _Py_Call(expr_ty func, asdl_seq * args, asdl_seq * keywords, int + lineno, int col_offset, PyArena *arena); #define Num(a0, a1, a2, a3) _Py_Num(a0, a1, a2, a3) expr_ty _Py_Num(object n, int lineno, int col_offset, PyArena *arena); #define Str(a0, a1, a2, a3) _Py_Str(a0, a1, a2, a3) diff -r 9a0caf6e7a16 Include/dictobject.h --- a/Include/dictobject.h Tue Apr 07 01:30:33 2015 -0400 +++ b/Include/dictobject.h Tue Apr 07 06:17:38 2015 -0400 @@ -105,6 +105,10 @@ PyObject *other, int override); +#ifndef Py_LIMITED_API +PyAPI_FUNC(PyObject *) _PyDictView_Intersect(PyObject* self, PyObject *other); +#endif + /* PyDict_MergeFromSeq2 updates/merges from an iterable object producing iterable objects of length 2. If override is true, the last occurrence of a key wins, else the first. The Python dict constructor dict(seq2) diff -r 9a0caf6e7a16 Include/opcode.h --- a/Include/opcode.h Tue Apr 07 01:30:33 2015 -0400 +++ b/Include/opcode.h Tue Apr 07 06:17:38 2015 -0400 @@ -111,6 +111,11 @@ #define SET_ADD 146 #define MAP_ADD 147 #define LOAD_CLASSDEREF 148 +#define BUILD_LIST_UNPACK 149 +#define BUILD_MAP_UNPACK 150 +#define BUILD_MAP_UNPACK_WITH_CALL 151 +#define BUILD_TUPLE_UNPACK 152 +#define BUILD_SET_UNPACK 153 /* EXCEPT_HANDLER is a special, implicit block type which is created when entering an except handler. It is not an opcode but we define it here diff -r 9a0caf6e7a16 Lib/importlib/_bootstrap.py --- a/Lib/importlib/_bootstrap.py Tue Apr 07 01:30:33 2015 -0400 +++ b/Lib/importlib/_bootstrap.py Tue Apr 07 06:17:38 2015 -0400 @@ -330,13 +330,8 @@ # a .pyc file in text mode the magic number will be wrong; also, the # Apple MPW compiler swaps their values, botching string constants. # -# The magic numbers must be spaced apart at least 2 values, as the -# -U interpeter flag will cause MAGIC+1 being used. They have been -# odd numbers for some time now. -# # There were a variety of old schemes for setting the magic number. -# The current working scheme is to increment the previous value by -# 10. +# The current scheme is to increment the previous value by 10. # # Starting with the adoption of PEP 3147 in Python 3.2, every bump in magic # number also includes a new "magic tag", i.e. a human readable string used @@ -420,12 +415,13 @@ # Python 3.4a4 3300 (more changes to __qualname__ computation) # Python 3.4rc2 3310 (alter __qualname__ computation) # Python 3.5a0 3320 (matrix multiplication operator) +# Python 3.5a2 3330 (PEP 448: Additional Unpacking Generalizations) # # MAGIC must change whenever the bytecode emitted by the compiler may no # longer be understood by older implementations of the eval loop (usually # due to the addition of new opcodes). -MAGIC_NUMBER = (3320).to_bytes(2, 'little') + b'\r\n' +MAGIC_NUMBER = (3330).to_bytes(2, 'little') + b'\r\n' _RAW_MAGIC_NUMBER = int.from_bytes(MAGIC_NUMBER, 'little') # For import.c _PYCACHE = '__pycache__' diff -r 9a0caf6e7a16 Lib/opcode.py --- a/Lib/opcode.py Tue Apr 07 01:30:33 2015 -0400 +++ b/Lib/opcode.py Tue Apr 07 06:17:38 2015 -0400 @@ -200,4 +200,10 @@ def_op('EXTENDED_ARG', 144) EXTENDED_ARG = 144 +def_op('BUILD_LIST_UNPACK', 149) +def_op('BUILD_MAP_UNPACK', 150) +def_op('BUILD_MAP_UNPACK_WITH_CALL', 151) +def_op('BUILD_TUPLE_UNPACK', 152) +def_op('BUILD_SET_UNPACK', 153) + del def_op, name_op, jrel_op, jabs_op diff -r 9a0caf6e7a16 Lib/test/test_ast.py --- a/Lib/test/test_ast.py Tue Apr 07 01:30:33 2015 -0400 +++ b/Lib/test/test_ast.py Tue Apr 07 06:17:38 2015 -0400 @@ -427,17 +427,17 @@ self.assertEqual(ast.dump(node), "Module(body=[Expr(value=Call(func=Name(id='spam', ctx=Load()), " "args=[Name(id='eggs', ctx=Load()), Str(s='and cheese')], " - "keywords=[], starargs=None, kwargs=None))])" + "keywords=[]))])" ) self.assertEqual(ast.dump(node, annotate_fields=False), "Module([Expr(Call(Name('spam', Load()), [Name('eggs', Load()), " - "Str('and cheese')], [], None, None))])" + "Str('and cheese')], []))])" ) self.assertEqual(ast.dump(node, include_attributes=True), "Module(body=[Expr(value=Call(func=Name(id='spam', ctx=Load(), " "lineno=1, col_offset=0), args=[Name(id='eggs', ctx=Load(), " "lineno=1, col_offset=5), Str(s='and cheese', lineno=1, " - "col_offset=11)], keywords=[], starargs=None, kwargs=None, " + "col_offset=11)], keywords=[], " "lineno=1, col_offset=0), lineno=1, col_offset=0)])" ) @@ -453,16 +453,16 @@ def test_fix_missing_locations(self): src = ast.parse('write("spam")') src.body.append(ast.Expr(ast.Call(ast.Name('spam', ast.Load()), - [ast.Str('eggs')], [], None, None))) + [ast.Str('eggs')], []))) self.assertEqual(src, ast.fix_missing_locations(src)) self.assertEqual(ast.dump(src, include_attributes=True), "Module(body=[Expr(value=Call(func=Name(id='write', ctx=Load(), " "lineno=1, col_offset=0), args=[Str(s='spam', lineno=1, " - "col_offset=6)], keywords=[], starargs=None, kwargs=None, " + "col_offset=6)], keywords=[], " "lineno=1, col_offset=0), lineno=1, col_offset=0), " "Expr(value=Call(func=Name(id='spam', ctx=Load(), lineno=1, " "col_offset=0), args=[Str(s='eggs', lineno=1, col_offset=0)], " - "keywords=[], starargs=None, kwargs=None, lineno=1, " + "keywords=[], lineno=1, " "col_offset=0), lineno=1, col_offset=0)])" ) @@ -487,8 +487,7 @@ node = ast.parse('foo()', mode='eval') d = dict(ast.iter_fields(node.body)) self.assertEqual(d.pop('func').id, 'foo') - self.assertEqual(d, {'keywords': [], 'kwargs': None, - 'args': [], 'starargs': None}) + self.assertEqual(d, {'keywords': [], 'args': []}) def test_iter_child_nodes(self): node = ast.parse("spam(23, 42, eggs='leek')", mode='eval') @@ -604,8 +603,7 @@ self._check_arguments(fac, self.stmt) def test_classdef(self): - def cls(bases=None, keywords=None, starargs=None, kwargs=None, - body=None, decorator_list=None): + def cls(bases=None, keywords=None, body=None, decorator_list=None): if bases is None: bases = [] if keywords is None: @@ -614,16 +612,12 @@ body = [ast.Pass()] if decorator_list is None: decorator_list = [] - return ast.ClassDef("myclass", bases, keywords, starargs, - kwargs, body, decorator_list) + return ast.ClassDef("myclass", bases, keywords, + body, decorator_list) self.stmt(cls(bases=[ast.Name("x", ast.Store())]), "must have Load context") self.stmt(cls(keywords=[ast.keyword("x", ast.Name("x", ast.Store()))]), "must have Load context") - self.stmt(cls(starargs=ast.Name("x", ast.Store())), - "must have Load context") - self.stmt(cls(kwargs=ast.Name("x", ast.Store())), - "must have Load context") self.stmt(cls(body=[]), "empty body on ClassDef") self.stmt(cls(body=[None]), "None disallowed") self.stmt(cls(decorator_list=[ast.Name("x", ast.Store())]), @@ -854,20 +848,12 @@ func = ast.Name("x", ast.Load()) args = [ast.Name("y", ast.Load())] keywords = [ast.keyword("w", ast.Name("z", ast.Load()))] - stararg = ast.Name("p", ast.Load()) - kwarg = ast.Name("q", ast.Load()) - call = ast.Call(ast.Name("x", ast.Store()), args, keywords, stararg, - kwarg) + call = ast.Call(ast.Name("x", ast.Store()), args, keywords) self.expr(call, "must have Load context") - call = ast.Call(func, [None], keywords, stararg, kwarg) + call = ast.Call(func, [None], keywords) self.expr(call, "None disallowed") bad_keywords = [ast.keyword("w", ast.Name("z", ast.Store()))] - call = ast.Call(func, args, bad_keywords, stararg, kwarg) - self.expr(call, "must have Load context") - call = ast.Call(func, args, keywords, ast.Name("z", ast.Store()), kwarg) - self.expr(call, "must have Load context") - call = ast.Call(func, args, keywords, stararg, - ast.Name("w", ast.Store())) + call = ast.Call(func, args, bad_keywords) self.expr(call, "must have Load context") def test_num(self): @@ -957,8 +943,8 @@ ('Module', [('FunctionDef', (1, 0), 'f', ('arguments', [], ('arg', (1, 7), 'args', None), [], [], None, []), [('Pass', (1, 14))], [], None)]), ('Module', [('FunctionDef', (1, 0), 'f', ('arguments', [], None, [], [], ('arg', (1, 8), 'kwargs', None), []), [('Pass', (1, 17))], [], None)]), ('Module', [('FunctionDef', (1, 0), 'f', ('arguments', [('arg', (1, 6), 'a', None), ('arg', (1, 9), 'b', None), ('arg', (1, 14), 'c', None), ('arg', (1, 22), 'd', None), ('arg', (1, 28), 'e', None)], ('arg', (1, 35), 'args', None), [('arg', (1, 41), 'f', None)], [('Num', (1, 43), 42)], ('arg', (1, 49), 'kwargs', None), [('Num', (1, 11), 1), ('NameConstant', (1, 16), None), ('List', (1, 24), [], ('Load',)), ('Dict', (1, 30), [], [])]), [('Pass', (1, 58))], [], None)]), -('Module', [('ClassDef', (1, 0), 'C', [], [], None, None, [('Pass', (1, 8))], [])]), -('Module', [('ClassDef', (1, 0), 'C', [('Name', (1, 8), 'object', ('Load',))], [], None, None, [('Pass', (1, 17))], [])]), +('Module', [('ClassDef', (1, 0), 'C', [], [], [('Pass', (1, 8))], [])]), +('Module', [('ClassDef', (1, 0), 'C', [('Name', (1, 8), 'object', ('Load',))], [], [('Pass', (1, 17))], [])]), ('Module', [('FunctionDef', (1, 0), 'f', ('arguments', [], None, [], [], None, []), [('Return', (1, 8), ('Num', (1, 15), 1))], [], None)]), ('Module', [('Delete', (1, 0), [('Name', (1, 4), 'v', ('Del',))])]), ('Module', [('Assign', (1, 0), [('Name', (1, 0), 'v', ('Store',))], ('Num', (1, 4), 1))]), @@ -968,7 +954,7 @@ ('Module', [('If', (1, 0), ('Name', (1, 3), 'v', ('Load',)), [('Pass', (1, 5))], [])]), ('Module', [('With', (1, 0), [('withitem', ('Name', (1, 5), 'x', ('Load',)), ('Name', (1, 10), 'y', ('Store',)))], [('Pass', (1, 13))])]), ('Module', [('With', (1, 0), [('withitem', ('Name', (1, 5), 'x', ('Load',)), ('Name', (1, 10), 'y', ('Store',))), ('withitem', ('Name', (1, 13), 'z', ('Load',)), ('Name', (1, 18), 'q', ('Store',)))], [('Pass', (1, 21))])]), -('Module', [('Raise', (1, 0), ('Call', (1, 6), ('Name', (1, 6), 'Exception', ('Load',)), [('Str', (1, 16), 'string')], [], None, None), None)]), +('Module', [('Raise', (1, 0), ('Call', (1, 6), ('Name', (1, 6), 'Exception', ('Load',)), [('Str', (1, 16), 'string')], []), None)]), ('Module', [('Try', (1, 0), [('Pass', (2, 2))], [('ExceptHandler', (3, 0), ('Name', (3, 7), 'Exception', ('Load',)), None, [('Pass', (4, 2))])], [], [])]), ('Module', [('Try', (1, 0), [('Pass', (2, 2))], [], [], [('Pass', (4, 2))])]), ('Module', [('Assert', (1, 0), ('Name', (1, 7), 'v', ('Load',)), None)]), @@ -998,14 +984,14 @@ ('Expression', ('BinOp', (1, 0), ('Name', (1, 0), 'a', ('Load',)), ('Add',), ('Name', (1, 4), 'b', ('Load',)))), ('Expression', ('UnaryOp', (1, 0), ('Not',), ('Name', (1, 4), 'v', ('Load',)))), ('Expression', ('Lambda', (1, 0), ('arguments', [], None, [], [], None, []), ('NameConstant', (1, 7), None))), -('Expression', ('Dict', (1, 0), [('Num', (1, 2), 1)], [('Num', (1, 4), 2)])), +('Expression', ('Dict', (1, 2), [('Num', (1, 2), 1)], [('Num', (1, 4), 2)])), ('Expression', ('Dict', (1, 0), [], [])), -('Expression', ('Set', (1, 0), [('NameConstant', (1, 1), None)])), -('Expression', ('Dict', (1, 0), [('Num', (2, 6), 1)], [('Num', (4, 10), 2)])), +('Expression', ('Set', (1, 1), [('NameConstant', (1, 1), None)])), +('Expression', ('Dict', (2, 6), [('Num', (2, 6), 1)], [('Num', (4, 10), 2)])), ('Expression', ('ListComp', (1, 1), ('Name', (1, 1), 'a', ('Load',)), [('comprehension', ('Name', (1, 7), 'b', ('Store',)), ('Name', (1, 12), 'c', ('Load',)), [('Name', (1, 17), 'd', ('Load',))])])), ('Expression', ('GeneratorExp', (1, 1), ('Name', (1, 1), 'a', ('Load',)), [('comprehension', ('Name', (1, 7), 'b', ('Store',)), ('Name', (1, 12), 'c', ('Load',)), [('Name', (1, 17), 'd', ('Load',))])])), ('Expression', ('Compare', (1, 0), ('Num', (1, 0), 1), [('Lt',), ('Lt',)], [('Num', (1, 4), 2), ('Num', (1, 8), 3)])), -('Expression', ('Call', (1, 0), ('Name', (1, 0), 'f', ('Load',)), [('Num', (1, 2), 1), ('Num', (1, 4), 2)], [('keyword', 'c', ('Num', (1, 8), 3))], ('Name', (1, 11), 'd', ('Load',)), ('Name', (1, 15), 'e', ('Load',)))), +('Expression', ('Call', (1, 0), ('Name', (1, 0), 'f', ('Load',)), [('Num', (1, 2), 1), ('Num', (1, 4), 2), ('Starred', (1, 10), ('Name', (1, 11), 'd', ('Load',)), ('Load',))], [('keyword', 'c', ('Num', (1, 8), 3)), ('keyword', None, ('Name', (1, 15), 'e', ('Load',)))])), ('Expression', ('Num', (1, 0), 10)), ('Expression', ('Str', (1, 0), 'string')), ('Expression', ('Attribute', (1, 0), ('Name', (1, 0), 'a', ('Load',)), 'b', ('Load',))), @@ -1016,6 +1002,6 @@ ('Expression', ('Tuple', (1, 0), [('Num', (1, 0), 1), ('Num', (1, 2), 2), ('Num', (1, 4), 3)], ('Load',))), ('Expression', ('Tuple', (1, 1), [('Num', (1, 1), 1), ('Num', (1, 3), 2), ('Num', (1, 5), 3)], ('Load',))), ('Expression', ('Tuple', (1, 0), [], ('Load',))), -('Expression', ('Call', (1, 0), ('Attribute', (1, 0), ('Attribute', (1, 0), ('Attribute', (1, 0), ('Name', (1, 0), 'a', ('Load',)), 'b', ('Load',)), 'c', ('Load',)), 'd', ('Load',)), [('Subscript', (1, 8), ('Attribute', (1, 8), ('Name', (1, 8), 'a', ('Load',)), 'b', ('Load',)), ('Slice', ('Num', (1, 12), 1), ('Num', (1, 14), 2), None), ('Load',))], [], None, None)), +('Expression', ('Call', (1, 0), ('Attribute', (1, 0), ('Attribute', (1, 0), ('Attribute', (1, 0), ('Name', (1, 0), 'a', ('Load',)), 'b', ('Load',)), 'c', ('Load',)), 'd', ('Load',)), [('Subscript', (1, 8), ('Attribute', (1, 8), ('Name', (1, 8), 'a', ('Load',)), 'b', ('Load',)), ('Slice', ('Num', (1, 12), 1), ('Num', (1, 14), 2), None), ('Load',))], [])), ] main() diff -r 9a0caf6e7a16 Lib/test/test_extcall.py --- a/Lib/test/test_extcall.py Tue Apr 07 01:30:33 2015 -0400 +++ b/Lib/test/test_extcall.py Tue Apr 07 06:17:38 2015 -0400 @@ -34,17 +34,37 @@ (1, 2, 3, 4, 5) {} >>> f(1, 2, 3, *[4, 5]) (1, 2, 3, 4, 5) {} + >>> f(*[1, 2, 3], 4, 5) + (1, 2, 3, 4, 5) {} >>> f(1, 2, 3, *UserList([4, 5])) (1, 2, 3, 4, 5) {} + >>> f(1, 2, 3, *[4, 5], *[6, 7]) + (1, 2, 3, 4, 5, 6, 7) {} + >>> f(1, *[2, 3], 4, *[5, 6], 7) + (1, 2, 3, 4, 5, 6, 7) {} + >>> f(*UserList([1, 2]), *UserList([3, 4]), 5, *UserList([6, 7])) + (1, 2, 3, 4, 5, 6, 7) {} Here we add keyword arguments >>> f(1, 2, 3, **{'a':4, 'b':5}) (1, 2, 3) {'a': 4, 'b': 5} + >>> f(1, 2, **{'a': -1, 'b': 5}, **{'a': 4, 'c': 6}) + Traceback (most recent call last): + ... + TypeError: f() got multiple values for keyword argument 'a' + >>> f(1, 2, **{'a': -1, 'b': 5}, a=4, c=6) + Traceback (most recent call last): + ... + TypeError: f() got multiple values for keyword argument 'a' >>> f(1, 2, 3, *[4, 5], **{'a':6, 'b':7}) (1, 2, 3, 4, 5) {'a': 6, 'b': 7} >>> f(1, 2, 3, x=4, y=5, *(6, 7), **{'a':8, 'b': 9}) (1, 2, 3, 6, 7) {'a': 8, 'b': 9, 'x': 4, 'y': 5} + >>> f(1, 2, 3, *[4, 5], **{'c': 8}, **{'a':6, 'b':7}) + (1, 2, 3, 4, 5) {'a': 6, 'b': 7, 'c': 8} + >>> f(1, 2, 3, *(4, 5), x=6, y=7, **{'a':8, 'b': 9}) + (1, 2, 3, 4, 5) {'a': 8, 'b': 9, 'x': 6, 'y': 7} >>> f(1, 2, 3, **UserDict(a=4, b=5)) (1, 2, 3) {'a': 4, 'b': 5} @@ -52,6 +72,8 @@ (1, 2, 3, 4, 5) {'a': 6, 'b': 7} >>> f(1, 2, 3, x=4, y=5, *(6, 7), **UserDict(a=8, b=9)) (1, 2, 3, 6, 7) {'a': 8, 'b': 9, 'x': 4, 'y': 5} + >>> f(1, 2, 3, *(4, 5), x=6, y=7, **UserDict(a=8, b=9)) + (1, 2, 3, 4, 5) {'a': 8, 'b': 9, 'x': 6, 'y': 7} Examples with invalid arguments (TypeErrors). We're also testing the function names in the exception messages. diff -r 9a0caf6e7a16 Lib/test/test_grammar.py --- a/Lib/test/test_grammar.py Tue Apr 07 01:30:33 2015 -0400 +++ b/Lib/test/test_grammar.py Tue Apr 07 06:17:38 2015 -0400 @@ -296,8 +296,12 @@ return args, kwargs self.assertEqual(f(1, x=2, *[3, 4], y=5), ((1, 3, 4), {'x':2, 'y':5})) - self.assertRaises(SyntaxError, eval, "f(1, *(2,3), 4)") + self.assertEqual(f(1, *(2,3), 4), ((1, 2, 3, 4), {})) self.assertRaises(SyntaxError, eval, "f(1, x=2, *(3,4), x=5)") + self.assertEqual(f(**{'eggs':'scrambled', 'spam':'fried'}), + ((), {'eggs':'scrambled', 'spam':'fried'})) + self.assertEqual(f(spam='fried', **{'eggs':'scrambled'}), + ((), {'eggs':'scrambled', 'spam':'fried'})) # argument annotation tests def f(x) -> list: pass diff -r 9a0caf6e7a16 Lib/test/test_parser.py --- a/Lib/test/test_parser.py Tue Apr 07 01:30:33 2015 -0400 +++ b/Lib/test/test_parser.py Tue Apr 07 06:17:38 2015 -0400 @@ -313,7 +313,12 @@ "except Exception as e:\n" " raise ValueError from e\n") + def test_list_displays(self): + self.check_expr('[]') + self.check_expr('[*{2}, 3, *[4]]') + def test_set_displays(self): + self.check_expr('{*{2}, 3, *[4]}') self.check_expr('{2}') self.check_expr('{2,}') self.check_expr('{2, 3}') @@ -325,6 +330,13 @@ self.check_expr('{a:b,}') self.check_expr('{a:b, c:d}') self.check_expr('{a:b, c:d,}') + self.check_expr('{**{}}') + self.check_expr('{**{}, 3:4, **{5:6, 7:8}}') + + def test_argument_unpacking(self): + self.check_expr('f(a, *b, *c, *d)') + self.check_expr('f(**a, **b)') + self.check_expr('f(2, *a, *b, **b, **c, **d)') def test_set_comprehensions(self): self.check_expr('{x for x in seq}') diff -r 9a0caf6e7a16 Lib/test/test_syntax.py --- a/Lib/test/test_syntax.py Tue Apr 07 01:30:33 2015 -0400 +++ b/Lib/test/test_syntax.py Tue Apr 07 06:17:38 2015 -0400 @@ -582,7 +582,18 @@ subclass=IndentationError) def test_kwargs_last(self): - self._check_error("int(base=10, '2')", "non-keyword arg") + self._check_error("int(base=10, '2')", + "positional argument follows keyword argument") + + def test_kwargs_last2(self): + self._check_error("int(**{base: 10}, '2')", + "positional argument follows " + "keyword argument unpacking") + + def test_kwargs_last3(self): + self._check_error("int(**{base: 10}, *['2'])", + "iterable argument unpacking follows " + "keyword argument unpacking") def test_main(): support.run_unittest(SyntaxTestCase) diff -r 9a0caf6e7a16 Lib/test/test_unpack_ex.py --- a/Lib/test/test_unpack_ex.py Tue Apr 07 01:30:33 2015 -0400 +++ b/Lib/test/test_unpack_ex.py Tue Apr 07 06:17:38 2015 -0400 @@ -71,8 +71,185 @@ >>> a == 0 and b == [1, 2, 3] and c == 4 and d == [0, 1, 2, 3] and e == 4 True +Assignment unpacking + + >>> a, b, *c = range(5) + >>> a, b, c + (0, 1, [2, 3, 4]) + >>> *a, b, c = a, b, *c + >>> a, b, c + ([0, 1, 2], 3, 4) + +Set display element unpacking + + >>> a = [1, 2, 3] + >>> sorted({1, *a, 0, 4}) + [0, 1, 2, 3, 4] + + >>> {1, *1, 0, 4} + Traceback (most recent call last): + ... + TypeError: 'int' object is not iterable + +Dict display element unpacking + + >>> kwds = {'z': 0, 'w': 12} + >>> sorted({'x': 1, 'y': 2, **kwds}.items()) + [('w', 12), ('x', 1), ('y', 2), ('z', 0)] + + >>> sorted({**{'x': 1}, 'y': 2, **{'z': 3}}.items()) + [('x', 1), ('y', 2), ('z', 3)] + + >>> sorted({**{'x': 1}, 'y': 2, **{'x': 3}}.items()) + [('x', 3), ('y', 2)] + + >>> sorted({**{'x': 1}, **{'x': 3}, 'x': 4}.items()) + [('x', 4)] + + >>> {**{}} + {} + + >>> a = {} + >>> {**a}[0] = 1 + >>> a + {} + + >>> {**1} + Traceback (most recent call last): + ... + TypeError: 'int' object is not a mapping + + >>> {**[]} + Traceback (most recent call last): + ... + TypeError: 'list' object is not a mapping + + >>> len(eval("{" + ", ".join("**{{{}: {}}}".format(i, i) + ... for i in range(1000)) + "}")) + 1000 + +List comprehension element unpacking + + >>> a, b, c = [0, 1, 2], 3, 4 + >>> [*a, b, c] + [0, 1, 2, 3, 4] + + >>> l = [a, (3, 4), {5}, {6: None}, (i for i in range(7, 10))] + >>> [*item for item in l] + Traceback (most recent call last): + ... + SyntaxError: iterable unpacking cannot be used in comprehension + + >>> [*[0, 1] for i in range(10)] + Traceback (most recent call last): + ... + SyntaxError: iterable unpacking cannot be used in comprehension + + >>> [*'a' for i in range(10)] + Traceback (most recent call last): + ... + SyntaxError: iterable unpacking cannot be used in comprehension + + >>> [*[] for i in range(10)] + Traceback (most recent call last): + ... + SyntaxError: iterable unpacking cannot be used in comprehension + +Generator expression in function arguments + + >>> list(*x for x in (range(5) for i in range(3))) + Traceback (most recent call last): + ... + list(*x for x in (range(5) for i in range(3))) + ^ + SyntaxError: invalid syntax + + >>> dict(**x for x in [{1:2}]) + Traceback (most recent call last): + ... + dict(**x for x in [{1:2}]) + ^ + SyntaxError: invalid syntax + +Iterable argument unpacking + + >>> print(*[1], *[2], 3) + 1 2 3 + +Make sure that they don't corrupt the passed-in dicts. + + >>> def f(x, y): + ... print(x, y) + ... + >>> original_dict = {'x': 1} + >>> f(**original_dict, y=2) + 1 2 + >>> original_dict + {'x': 1} + Now for some failures +Make sure the raised errors are right for keyword argument unpackings + + >>> from collections.abc import MutableMapping + >>> class CrazyDict(MutableMapping): + ... def __init__(self): + ... self.d = {} + ... + ... def __iter__(self): + ... for x in self.d.__iter__(): + ... if x == 'c': + ... self.d['z'] = 10 + ... yield x + ... + ... def __getitem__(self, k): + ... return self.d[k] + ... + ... def __len__(self): + ... return len(self.d) + ... + ... def __setitem__(self, k, v): + ... self.d[k] = v + ... + ... def __delitem__(self, k): + ... del self.d[k] + ... + >>> d = CrazyDict() + >>> d.d = {chr(ord('a') + x): x for x in range(5)} + >>> e = {**d} + Traceback (most recent call last): + ... + RuntimeError: dictionary changed size during iteration + + >>> d.d = {chr(ord('a') + x): x for x in range(5)} + >>> def f(**kwargs): print(kwargs) + >>> f(**d) + Traceback (most recent call last): + ... + RuntimeError: dictionary changed size during iteration + +Overridden parameters + + >>> f(x=5, **{'x': 3}, y=2) + Traceback (most recent call last): + ... + TypeError: f() got multiple values for keyword argument 'x' + + >>> f(**{'x': 3}, x=5, y=2) + Traceback (most recent call last): + ... + TypeError: f() got multiple values for keyword argument 'x' + + >>> f(**{'x': 3}, **{'x': 5}, y=2) + Traceback (most recent call last): + ... + TypeError: f() got multiple values for keyword argument 'x' + + >>> f(**{1: 3}, **{1: 5}) + Traceback (most recent call last): + ... + TypeError: f() keywords must be strings + Unpacking non-sequence >>> a, *b = 7 @@ -131,17 +308,17 @@ >>> *a # doctest:+ELLIPSIS Traceback (most recent call last): ... - SyntaxError: can use starred expression only as assignment target + SyntaxError: can't use starred expression here >>> *1 # doctest:+ELLIPSIS Traceback (most recent call last): ... - SyntaxError: can use starred expression only as assignment target + SyntaxError: can't use starred expression here >>> x = *a # doctest:+ELLIPSIS Traceback (most recent call last): ... - SyntaxError: can use starred expression only as assignment target + SyntaxError: can't use starred expression here Some size constraints (all fail.) diff -r 9a0caf6e7a16 Modules/parsermodule.c --- a/Modules/parsermodule.c Tue Apr 07 01:30:33 2015 -0400 +++ b/Modules/parsermodule.c Tue Apr 07 06:17:38 2015 -0400 @@ -23,6 +23,11 @@ * that lint detects are gone, but there are still warnings with * Py_[X]DECREF() and Py_[X]INCREF() macros. The lint annotations * look like "NOTE(...)". + * + * To debug parser errors like + * "parser.ParserError: Expected node type 12, got 333." + * decode symbol numbers using the automatically-generated files + * Lib/symbol.h and Include/token.h. */ #include "Python.h" /* general Python API */ @@ -1087,30 +1092,56 @@ return (res); } - -/* X (',' X) [','] - */ +/* X (',' X) [','] */ static int -validate_repeating_list(node *tree, int ntype, int (*vfunc)(node *), - const char *const name) +validate_repeating_list_variable(node *tree, + int list_node_type, + int (*validate_child_func_inc)(node *, int *), + int *pos, + const char *const list_node_type_name) { int nch = NCH(tree); - int res = (nch && validate_ntype(tree, ntype) - && vfunc(CHILD(tree, 0))); - - if (!res && !PyErr_Occurred()) - (void) validate_numnodes(tree, 1, name); + int res = (nch && validate_ntype(tree, list_node_type)); + + if (!res && !PyErr_Occurred()) { + /* Unconditionally raise. */ + (void) validate_numnodes(tree, 1, list_node_type_name); + } else { - if (is_even(nch)) - res = validate_comma(CHILD(tree, --nch)); - if (res && nch > 1) { - int pos = 1; - for ( ; res && pos < nch; pos += 2) - res = (validate_comma(CHILD(tree, pos)) - && vfunc(CHILD(tree, pos + 1))); + for ( ; res && *pos < nch; ) { + res = validate_child_func_inc(tree, pos); + if (!res || *pos >= nch) + break; + res = validate_comma(CHILD(tree, (*pos)++)); } } - return (res); + return res; +} + +/* X (',' X) [','] */ +static int +validate_repeating_list(node *tree, + int list_node_type, + int (*validate_child_func)(node *), + const char *const list_node_type_name) +{ + int nch = NCH(tree); + int res = (nch && validate_ntype(tree, list_node_type)); + int pos = 0; + + if (!res && !PyErr_Occurred()) { + /* Unconditionally raise. */ + (void) validate_numnodes(tree, 1, list_node_type_name); + } + else { + for ( ; res && pos < nch; ) { + res = validate_child_func(CHILD(tree, pos++)); + if (!res || pos >= nch) + break; + res = validate_comma(CHILD(tree, pos++)); + } + } + return res; } @@ -2451,9 +2482,9 @@ if (res && (nch == 3)) { if (TYPE(CHILD(tree, 1))==yield_expr) - res = validate_yield_expr(CHILD(tree, 1)); + res = validate_yield_expr(CHILD(tree, 1)); else - res = validate_testlist_comp(CHILD(tree, 1)); + res = validate_testlist_comp(CHILD(tree, 1)); } break; case LSQB: @@ -2493,39 +2524,28 @@ /* testlist_comp: - * test ( comp_for | (',' test)* [','] ) + * (test|star_expr) ( comp_for | (',' (test|star_expr))* [','] ) */ static int validate_testlist_comp(node *tree) { int nch = NCH(tree); - int ok = nch; - - if (nch == 0) + int ok; + + if (nch == 0) { err_string("missing child nodes of testlist_comp"); + return 0; + } + + if (nch == 2 && TYPE(CHILD(tree, 1)) == comp_for) { + ok = (validate_test(CHILD(tree, 0)) + && validate_comp_for(CHILD(tree, 1))); + } else { - ok = validate_test_or_star_expr(CHILD(tree, 0)); - } - - /* - * comp_for | (',' test)* [','] - */ - if (nch == 2 && TYPE(CHILD(tree, 1)) == comp_for) - ok = validate_comp_for(CHILD(tree, 1)); - else { - /* (',' test)* [','] */ - int i = 1; - while (ok && nch - i >= 2) { - ok = (validate_comma(CHILD(tree, i)) - && validate_test_or_star_expr(CHILD(tree, i+1))); - i += 2; - } - if (ok && i == nch-1) - ok = validate_comma(CHILD(tree, i)); - else if (i != nch) { - ok = 0; - err_string("illegal trailing nodes for testlist_comp"); - } + ok = validate_repeating_list(tree, + testlist_comp, + validate_test_or_star_expr, + "testlist_comp"); } return ok; } @@ -2732,9 +2752,6 @@ } ok = 1; if (nch-i > 0) { - /* - * argument | '*' test [',' '**' test] | '**' test - */ int sym = TYPE(CHILD(tree, i)); if (sym == argument) { @@ -2745,30 +2762,7 @@ ok = 0; } } - else if (sym == STAR) { - ok = validate_star(CHILD(tree, i)); - if (ok && (nch-i == 2)) - ok = validate_test(CHILD(tree, i+1)); - else if (ok && (nch-i == 5)) - ok = (validate_test(CHILD(tree, i+1)) - && validate_comma(CHILD(tree, i+2)) - && validate_doublestar(CHILD(tree, i+3)) - && validate_test(CHILD(tree, i+4))); - else { - err_string("illegal use of '*' in arglist"); - ok = 0; - } - } - else if (sym == DOUBLESTAR) { - if (nch-i == 2) - ok = (validate_doublestar(CHILD(tree, i)) - && validate_test(CHILD(tree, i+1))); - else { - err_string("illegal use of '**' in arglist"); - ok = 0; - } - } - else { + else { err_string("illegal arglist specification"); ok = 0; } @@ -2778,9 +2772,10 @@ -/* argument: - * - * [test '='] test [comp_for] +/* argument: ( test [comp_for] | + * test '=' test | + * '**' expr | + * star_expr ) */ static int validate_argument(node *tree) @@ -2788,14 +2783,24 @@ int nch = NCH(tree); int res = (validate_ntype(tree, argument) && ((nch == 1) || (nch == 2) || (nch == 3))); - if (res) - res = validate_test(CHILD(tree, 0)); - if (res && (nch == 2)) - res = validate_comp_for(CHILD(tree, 1)); - else if (res && (nch == 3)) - res = (validate_equal(CHILD(tree, 1)) - && validate_test(CHILD(tree, 2))); - + + if (res) { + if (TYPE(CHILD(tree, 0)) == DOUBLESTAR) { + res = validate_expr(CHILD(tree, 1)); + } + else if (nch == 1) { + res = validate_test_or_star_expr(CHILD(tree, 0)); + } + else if (nch == 2) { + res = (validate_test(CHILD(tree, 0)) + && validate_comp_for(CHILD(tree, 1))); + } + else if (res && (nch == 3)) { + res = (validate_test(CHILD(tree, 0)) + && validate_equal(CHILD(tree, 1)) + && validate_test(CHILD(tree, 2))); + } + } return (res); } @@ -2948,11 +2953,44 @@ validate_expr_or_star_expr, "exprlist")); } +/* Incrementing validate functions returns nonzero iff success (like other + * validate functions, and advance *i by the length of the matched pattern. */ + +/* test ':' test */ +static int +validate_test_colon_test_inc(node *tree, int *i) +{ + return (validate_test(CHILD(tree, (*i)++)) + && validate_colon(CHILD(tree, (*i)++)) + && validate_test(CHILD(tree, (*i)++))); +} + +/* test ':' test | '**' expr */ +static int +validate_dict_element_inc(node *tree, int *i) +{ + int nch = NCH(tree); + int res = 0; + if (nch - *i >= 2) { + if (TYPE(CHILD(tree, *i+1)) == COLON) { + /* test ':' test */ + res = validate_test_colon_test_inc(tree, i); + } else { + /* '**' expr */ + res = (validate_doublestar(CHILD(tree, (*i)++)) + && validate_expr(CHILD(tree, (*i)++))); + } + } + return res; +} + /* * dictorsetmaker: * - * (test ':' test (comp_for | (',' test ':' test)* [','])) | - * (test (comp_for | (',' test)* [','])) + * ( ((test ':' test | '**' expr) + * (comp_for | (',' (test ':' test | '**' expr))* [','])) | + * ((test | '*' test) + * (comp_for | (',' (test | '*' test))* [','])) ) */ static int validate_dictorsetmaker(node *tree) @@ -2966,65 +3004,44 @@ return 0; if (nch - i < 1) { + /* Unconditionally raise. */ (void) validate_numnodes(tree, 1, "dictorsetmaker"); return 0; } - res = validate_test(CHILD(tree, i++)); - if (!res) - return 0; - - if (nch - i >= 2 && TYPE(CHILD(tree, i)) == COLON) { + if (nch - i >= 2 + && ((TYPE(CHILD(tree, i+1)) == COLON) || + (TYPE(CHILD(tree, i)) == DOUBLESTAR))) { /* Dictionary display or dictionary comprehension. */ - res = (validate_colon(CHILD(tree, i++)) - && validate_test(CHILD(tree, i++))); - if (!res) - return 0; - - if (nch - i >= 1 && TYPE(CHILD(tree, i)) == comp_for) { + if (nch - i >= 4 && TYPE(CHILD(tree, i+3)) == comp_for) { /* Dictionary comprehension. */ - res = validate_comp_for(CHILD(tree, i++)); + res = (validate_test_colon_test_inc(tree, &i) + && validate_comp_for(CHILD(tree, i++))); if (!res) return 0; + } else { + /* Dictionary display. */ + return validate_repeating_list_variable( + tree, + dictorsetmaker, + validate_dict_element_inc, + &i, + "dictorsetmaker"); } - else { - /* Dictionary display. */ - while (nch - i >= 4) { - res = (validate_comma(CHILD(tree, i++)) - && validate_test(CHILD(tree, i++)) - && validate_colon(CHILD(tree, i++)) - && validate_test(CHILD(tree, i++))); - if (!res) - return 0; - } - if (nch - i == 1) { - res = validate_comma(CHILD(tree, i++)); - if (!res) - return 0; - } - } - } - else { + } else { /* Set display or set comprehension. */ - if (nch - i >= 1 && TYPE(CHILD(tree, i)) == comp_for) { + if (nch - i >= 2 && TYPE(CHILD(tree, i + 1)) == comp_for) { /* Set comprehension. */ - res = validate_comp_for(CHILD(tree, i++)); + res = (validate_test(CHILD(tree, i++)) + && validate_comp_for(CHILD(tree, i++))); if (!res) return 0; - } - else { + } else { /* Set display. */ - while (nch - i >= 2) { - res = (validate_comma(CHILD(tree, i++)) - && validate_test(CHILD(tree, i++))); - if (!res) - return 0; - } - if (nch - i == 1) { - res = validate_comma(CHILD(tree, i++)); - if (!res) - return 0; - } + return validate_repeating_list(tree, + dictorsetmaker, + validate_test_or_star_expr, + "dictorsetmaker"); } } diff -r 9a0caf6e7a16 Objects/clinic/dictobject.c.h --- a/Objects/clinic/dictobject.c.h Tue Apr 07 01:30:33 2015 -0400 +++ b/Objects/clinic/dictobject.c.h Tue Apr 07 06:17:38 2015 -0400 @@ -1,5 +1,1760 @@ + +/* Dictionary object implementation using a hash table */ + +/* The distribution includes a separate file, Objects/dictnotes.txt, + describing explorations into dictionary design and optimization. + It covers typical dictionary use patterns, the parameters for + tuning dictionaries, and several ideas for possible optimizations. +*/ + + +/* +There are four kinds of slots in the table: + +1. Unused. me_key == me_value == NULL + Does not hold an active (key, value) pair now and never did. Unused can + transition to Active upon key insertion. This is the only case in which + me_key is NULL, and is each slot's initial state. + +2. Active. me_key != NULL and me_key != dummy and me_value != NULL + Holds an active (key, value) pair. Active can transition to Dummy or + Pending upon key deletion (for combined and split tables respectively). + This is the only case in which me_value != NULL. + +3. Dummy. me_key == dummy and me_value == NULL + Previously held an active (key, value) pair, but that was deleted and an + active pair has not yet overwritten the slot. Dummy can transition to + Active upon key insertion. Dummy slots cannot be made Unused again + (cannot have me_key set to NULL), else the probe sequence in case of + collision would have no way to know they were once active. + +4. Pending. Not yet inserted or deleted from a split-table. + key != NULL, key != dummy and value == NULL + +The DictObject can be in one of two forms. +Either: + A combined table: + ma_values == NULL, dk_refcnt == 1. + Values are stored in the me_value field of the PyDictKeysObject. + Slot kind 4 is not allowed i.e. + key != NULL, key != dummy and value == NULL is illegal. +Or: + A split table: + ma_values != NULL, dk_refcnt >= 1 + Values are stored in the ma_values array. + Only string (unicode) keys are allowed, no keys are present. + +Note: .popitem() abuses the me_hash field of an Unused or Dummy slot to +hold a search finger. The me_hash field of Unused or Dummy slots has no +meaning otherwise. As a consequence of this popitem always converts the dict +to the combined-table form. +*/ + +/* PyDict_MINSIZE_SPLIT is the minimum size of a split dictionary. + * It must be a power of 2, and at least 4. + * Resizing of split dictionaries is very rare, so the saving memory is more + * important than the cost of resizing. + */ +#define PyDict_MINSIZE_SPLIT 4 + +/* PyDict_MINSIZE_COMBINED is the starting size for any new, non-split dict. + * 8 allows dicts with no more than 5 active entries; experiments suggested + * this suffices for the majority of dicts (consisting mostly of usually-small + * dicts created to pass keyword arguments). + * Making this 8, rather than 4 reduces the number of resizes for most + * dictionaries, without any significant extra memory use. + */ +#define PyDict_MINSIZE_COMBINED 8 + +#include "Python.h" +#include "stringlib/eq.h" + /*[clinic input] -preserve +class dict "PyDictObject *" "&PyDict_Type" +[clinic start generated code]*/ +/*[clinic end generated code: output=da39a3ee5e6b4b0d input=f157a5a0ce9589d6]*/ + +typedef struct { + /* Cached hash code of me_key. */ + Py_hash_t me_hash; + PyObject *me_key; + PyObject *me_value; /* This field is only meaningful for combined tables */ +} PyDictKeyEntry; + +typedef PyDictKeyEntry *(*dict_lookup_func) +(PyDictObject *mp, PyObject *key, Py_hash_t hash, PyObject ***value_addr); + +struct _dictkeysobject { + Py_ssize_t dk_refcnt; + Py_ssize_t dk_size; + dict_lookup_func dk_lookup; + Py_ssize_t dk_usable; + PyDictKeyEntry dk_entries[1]; +}; + + +/* +To ensure the lookup algorithm terminates, there must be at least one Unused +slot (NULL key) in the table. +To avoid slowing down lookups on a near-full table, we resize the table when +it's USABLE_FRACTION (currently two-thirds) full. +*/ + +#define PERTURB_SHIFT 5 + +/* +Major subtleties ahead: Most hash schemes depend on having a "good" hash +function, in the sense of simulating randomness. Python doesn't: its most +important hash functions (for strings and ints) are very regular in common +cases: + + >>> map(hash, (0, 1, 2, 3)) + [0, 1, 2, 3] + >>> map(hash, ("namea", "nameb", "namec", "named")) + [-1658398457, -1658398460, -1658398459, -1658398462] + >>> + +This isn't necessarily bad! To the contrary, in a table of size 2**i, taking +the low-order i bits as the initial table index is extremely fast, and there +are no collisions at all for dicts indexed by a contiguous range of ints. +The same is approximately true when keys are "consecutive" strings. So this +gives better-than-random behavior in common cases, and that's very desirable. + +OTOH, when collisions occur, the tendency to fill contiguous slices of the +hash table makes a good collision resolution strategy crucial. Taking only +the last i bits of the hash code is also vulnerable: for example, consider +the list [i << 16 for i in range(20000)] as a set of keys. Since ints are +their own hash codes, and this fits in a dict of size 2**15, the last 15 bits + of every hash code are all 0: they *all* map to the same table index. + +But catering to unusual cases should not slow the usual ones, so we just take +the last i bits anyway. It's up to collision resolution to do the rest. If +we *usually* find the key we're looking for on the first try (and, it turns +out, we usually do -- the table load factor is kept under 2/3, so the odds +are solidly in our favor), then it makes best sense to keep the initial index +computation dirt cheap. + +The first half of collision resolution is to visit table indices via this +recurrence: + + j = ((5*j) + 1) mod 2**i + +For any initial j in range(2**i), repeating that 2**i times generates each +int in range(2**i) exactly once (see any text on random-number generation for +proof). By itself, this doesn't help much: like linear probing (setting +j += 1, or j -= 1, on each loop trip), it scans the table entries in a fixed +order. This would be bad, except that's not the only thing we do, and it's +actually *good* in the common cases where hash keys are consecutive. In an +example that's really too small to make this entirely clear, for a table of +size 2**3 the order of indices is: + + 0 -> 1 -> 6 -> 7 -> 4 -> 5 -> 2 -> 3 -> 0 [and here it's repeating] + +If two things come in at index 5, the first place we look after is index 2, +not 6, so if another comes in at index 6 the collision at 5 didn't hurt it. +Linear probing is deadly in this case because there the fixed probe order +is the *same* as the order consecutive keys are likely to arrive. But it's +extremely unlikely hash codes will follow a 5*j+1 recurrence by accident, +and certain that consecutive hash codes do not. + +The other half of the strategy is to get the other bits of the hash code +into play. This is done by initializing a (unsigned) vrbl "perturb" to the +full hash code, and changing the recurrence to: + + j = (5*j) + 1 + perturb; + perturb >>= PERTURB_SHIFT; + use j % 2**i as the next table index; + +Now the probe sequence depends (eventually) on every bit in the hash code, +and the pseudo-scrambling property of recurring on 5*j+1 is more valuable, +because it quickly magnifies small differences in the bits that didn't affect +the initial index. Note that because perturb is unsigned, if the recurrence +is executed often enough perturb eventually becomes and remains 0. At that +point (very rarely reached) the recurrence is on (just) 5*j+1 again, and +that's certain to find an empty slot eventually (since it generates every int +in range(2**i), and we make sure there's always at least one empty slot). + +Selecting a good value for PERTURB_SHIFT is a balancing act. You want it +small so that the high bits of the hash code continue to affect the probe +sequence across iterations; but you want it large so that in really bad cases +the high-order hash bits have an effect on early iterations. 5 was "the +best" in minimizing total collisions across experiments Tim Peters ran (on +both normal and pathological cases), but 4 and 6 weren't significantly worse. + +Historical: Reimer Behrends contributed the idea of using a polynomial-based +approach, using repeated multiplication by x in GF(2**n) where an irreducible +polynomial for each table size was chosen such that x was a primitive root. +Christian Tismer later extended that to use division by x instead, as an +efficient way to get the high bits of the hash code into play. This scheme +also gave excellent collision statistics, but was more expensive: two +if-tests were required inside the loop; computing "the next" index took about +the same number of operations but without as much potential parallelism +(e.g., computing 5*j can go on at the same time as computing 1+perturb in the +above, and then shifting perturb can be done while the table index is being +masked); and the PyDictObject struct required a member to hold the table's +polynomial. In Tim's experiments the current scheme ran faster, produced +equally good collision statistics, needed less code & used less memory. + +*/ + +/* Object used as dummy key to fill deleted entries + * This could be any unique object, + * use a custom type in order to minimise coupling. +*/ +static PyObject _dummy_struct; + +#define dummy (&_dummy_struct) + +#ifdef Py_REF_DEBUG +PyObject * +_PyDict_Dummy(void) +{ + return dummy; +} +#endif + +/* forward declarations */ +static PyDictKeyEntry *lookdict(PyDictObject *mp, PyObject *key, + Py_hash_t hash, PyObject ***value_addr); +static PyDictKeyEntry *lookdict_unicode(PyDictObject *mp, PyObject *key, + Py_hash_t hash, PyObject ***value_addr); +static PyDictKeyEntry * +lookdict_unicode_nodummy(PyDictObject *mp, PyObject *key, + Py_hash_t hash, PyObject ***value_addr); +static PyDictKeyEntry *lookdict_split(PyDictObject *mp, PyObject *key, + Py_hash_t hash, PyObject ***value_addr); + +static int dictresize(PyDictObject *mp, Py_ssize_t minused); + +/* Dictionary reuse scheme to save calls to malloc, free, and memset */ +#ifndef PyDict_MAXFREELIST +#define PyDict_MAXFREELIST 80 +#endif +static PyDictObject *free_list[PyDict_MAXFREELIST]; +static int numfree = 0; + +int +PyDict_ClearFreeList(void) +{ + PyDictObject *op; + int ret = numfree; + while (numfree) { + op = free_list[--numfree]; + assert(PyDict_CheckExact(op)); + PyObject_GC_Del(op); + } + return ret; +} + +/* Print summary info about the state of the optimized allocator */ +void +_PyDict_DebugMallocStats(FILE *out) +{ + _PyDebugAllocatorStats(out, + "free PyDictObject", numfree, sizeof(PyDictObject)); +} + + +void +PyDict_Fini(void) +{ + PyDict_ClearFreeList(); +} + +#define DK_DEBUG_INCREF _Py_INC_REFTOTAL _Py_REF_DEBUG_COMMA +#define DK_DEBUG_DECREF _Py_DEC_REFTOTAL _Py_REF_DEBUG_COMMA + +#define DK_INCREF(dk) (DK_DEBUG_INCREF ++(dk)->dk_refcnt) +#define DK_DECREF(dk) if (DK_DEBUG_DECREF (--(dk)->dk_refcnt) == 0) free_keys_object(dk) +#define DK_SIZE(dk) ((dk)->dk_size) +#define DK_MASK(dk) (((dk)->dk_size)-1) +#define IS_POWER_OF_2(x) (((x) & (x-1)) == 0) + +/* USABLE_FRACTION is the maximum dictionary load. + * Currently set to (2n+1)/3. Increasing this ratio makes dictionaries more + * dense resulting in more collisions. Decreasing it improves sparseness + * at the expense of spreading entries over more cache lines and at the + * cost of total memory consumed. + * + * USABLE_FRACTION must obey the following: + * (0 < USABLE_FRACTION(n) < n) for all n >= 2 + * + * USABLE_FRACTION should be very quick to calculate. + * Fractions around 5/8 to 2/3 seem to work well in practice. + */ + +/* Use (2n+1)/3 rather than 2n+3 because: it makes no difference for + * combined tables (the two fractions round to the same number n < ), + * but 2*4/3 is 2 whereas (2*4+1)/3 is 3 which potentially saves quite + * a lot of space for small, split tables */ +#define USABLE_FRACTION(n) ((((n) << 1)+1)/3) + +/* Alternative fraction that is otherwise close enough to (2n+1)/3 to make + * little difference. 8 * 2/3 == 8 * 5/8 == 5. 16 * 2/3 == 16 * 5/8 == 10. + * 32 * 2/3 = 21, 32 * 5/8 = 20. + * Its advantage is that it is faster to compute on machines with slow division. + * #define USABLE_FRACTION(n) (((n) >> 1) + ((n) >> 2) - ((n) >> 3)) +*/ + +/* GROWTH_RATE. Growth rate upon hitting maximum load. + * Currently set to used*2 + capacity/2. + * This means that dicts double in size when growing without deletions, + * but have more head room when the number of deletions is on a par with the + * number of insertions. + * Raising this to used*4 doubles memory consumption depending on the size of + * the dictionary, but results in half the number of resizes, less effort to + * resize. + * GROWTH_RATE was set to used*4 up to version 3.2. + * GROWTH_RATE was set to used*2 in version 3.3.0 + */ +#define GROWTH_RATE(d) (((d)->ma_used*2)+((d)->ma_keys->dk_size>>1)) + +#define ENSURE_ALLOWS_DELETIONS(d) \ + if ((d)->ma_keys->dk_lookup == lookdict_unicode_nodummy) { \ + (d)->ma_keys->dk_lookup = lookdict_unicode; \ + } + +/* This immutable, empty PyDictKeysObject is used for PyDict_Clear() + * (which cannot fail and thus can do no allocation). + */ +static PyDictKeysObject empty_keys_struct = { + 2, /* dk_refcnt 1 for this struct, 1 for dummy_struct */ + 1, /* dk_size */ + lookdict_split, /* dk_lookup */ + 0, /* dk_usable (immutable) */ + { + { 0, 0, 0 } /* dk_entries (empty) */ + } +}; + +static PyObject *empty_values[1] = { NULL }; + +#define Py_EMPTY_KEYS &empty_keys_struct + +static PyDictKeysObject *new_keys_object(Py_ssize_t size) +{ + PyDictKeysObject *dk; + Py_ssize_t i; + PyDictKeyEntry *ep0; + + assert(size >= PyDict_MINSIZE_SPLIT); + assert(IS_POWER_OF_2(size)); + dk = PyMem_MALLOC(sizeof(PyDictKeysObject) + + sizeof(PyDictKeyEntry) * (size-1)); + if (dk == NULL) { + PyErr_NoMemory(); + return NULL; + } + DK_DEBUG_INCREF dk->dk_refcnt = 1; + dk->dk_size = size; + dk->dk_usable = USABLE_FRACTION(size); + ep0 = &dk->dk_entries[0]; + /* Hash value of slot 0 is used by popitem, so it must be initialized */ + ep0->me_hash = 0; + for (i = 0; i < size; i++) { + ep0[i].me_key = NULL; + ep0[i].me_value = NULL; + } + dk->dk_lookup = lookdict_unicode_nodummy; + return dk; +} + +static void +free_keys_object(PyDictKeysObject *keys) +{ + PyDictKeyEntry *entries = &keys->dk_entries[0]; + Py_ssize_t i, n; + for (i = 0, n = DK_SIZE(keys); i < n; i++) { + Py_XDECREF(entries[i].me_key); + Py_XDECREF(entries[i].me_value); + } + PyMem_FREE(keys); +} + +#define new_values(size) PyMem_NEW(PyObject *, size) + +#define free_values(values) PyMem_FREE(values) + +/* Consumes a reference to the keys object */ +static PyObject * +new_dict(PyDictKeysObject *keys, PyObject **values) +{ + PyDictObject *mp; + assert(keys != NULL); + if (numfree) { + mp = free_list[--numfree]; + assert (mp != NULL); + assert (Py_TYPE(mp) == &PyDict_Type); + _Py_NewReference((PyObject *)mp); + } + else { + mp = PyObject_GC_New(PyDictObject, &PyDict_Type); + if (mp == NULL) { + DK_DECREF(keys); + free_values(values); + return NULL; + } + } + mp->ma_keys = keys; + mp->ma_values = values; + mp->ma_used = 0; + return (PyObject *)mp; +} + +/* Consumes a reference to the keys object */ +static PyObject * +new_dict_with_shared_keys(PyDictKeysObject *keys) +{ + PyObject **values; + Py_ssize_t i, size; + + size = DK_SIZE(keys); + values = new_values(size); + if (values == NULL) { + DK_DECREF(keys); + return PyErr_NoMemory(); + } + for (i = 0; i < size; i++) { + values[i] = NULL; + } + return new_dict(keys, values); +} + +PyObject * +PyDict_New(void) +{ + PyDictKeysObject *keys = new_keys_object(PyDict_MINSIZE_COMBINED); + if (keys == NULL) + return NULL; + return new_dict(keys, NULL); +} + +/* +The basic lookup function used by all operations. +This is based on Algorithm D from Knuth Vol. 3, Sec. 6.4. +Open addressing is preferred over chaining since the link overhead for +chaining would be substantial (100% with typical malloc overhead). + +The initial probe index is computed as hash mod the table size. Subsequent +probe indices are computed as explained earlier. + +All arithmetic on hash should ignore overflow. + +The details in this version are due to Tim Peters, building on many past +contributions by Reimer Behrends, Jyrki Alakuijala, Vladimir Marangozov and +Christian Tismer. + +lookdict() is general-purpose, and may return NULL if (and only if) a +comparison raises an exception (this was new in Python 2.5). +lookdict_unicode() below is specialized to string keys, comparison of which can +never raise an exception; that function can never return NULL. +lookdict_unicode_nodummy is further specialized for string keys that cannot be +the value. +For both, when the key isn't found a PyDictEntry* is returned +where the key would have been found, *value_addr points to the matching value +slot. +*/ +static PyDictKeyEntry * +lookdict(PyDictObject *mp, PyObject *key, + Py_hash_t hash, PyObject ***value_addr) +{ + size_t i; + size_t perturb; + PyDictKeyEntry *freeslot; + size_t mask; + PyDictKeyEntry *ep0; + PyDictKeyEntry *ep; + int cmp; + PyObject *startkey; + +top: + mask = DK_MASK(mp->ma_keys); + ep0 = &mp->ma_keys->dk_entries[0]; + i = (size_t)hash & mask; + ep = &ep0[i]; + if (ep->me_key == NULL || ep->me_key == key) { + *value_addr = &ep->me_value; + return ep; + } + if (ep->me_key == dummy) + freeslot = ep; + else { + if (ep->me_hash == hash) { + startkey = ep->me_key; + Py_INCREF(startkey); + cmp = PyObject_RichCompareBool(startkey, key, Py_EQ); + Py_DECREF(startkey); + if (cmp < 0) + return NULL; + if (ep0 == mp->ma_keys->dk_entries && ep->me_key == startkey) { + if (cmp > 0) { + *value_addr = &ep->me_value; + return ep; + } + } + else { + /* The dict was mutated, restart */ + goto top; + } + } + freeslot = NULL; + } + + /* In the loop, me_key == dummy is by far (factor of 100s) the + least likely outcome, so test for that last. */ + for (perturb = hash; ; perturb >>= PERTURB_SHIFT) { + i = (i << 2) + i + perturb + 1; + ep = &ep0[i & mask]; + if (ep->me_key == NULL) { + if (freeslot == NULL) { + *value_addr = &ep->me_value; + return ep; + } else { + *value_addr = &freeslot->me_value; + return freeslot; + } + } + if (ep->me_key == key) { + *value_addr = &ep->me_value; + return ep; + } + if (ep->me_hash == hash && ep->me_key != dummy) { + startkey = ep->me_key; + Py_INCREF(startkey); + cmp = PyObject_RichCompareBool(startkey, key, Py_EQ); + Py_DECREF(startkey); + if (cmp < 0) { + *value_addr = NULL; + return NULL; + } + if (ep0 == mp->ma_keys->dk_entries && ep->me_key == startkey) { + if (cmp > 0) { + *value_addr = &ep->me_value; + return ep; + } + } + else { + /* The dict was mutated, restart */ + goto top; + } + } + else if (ep->me_key == dummy && freeslot == NULL) + freeslot = ep; + } + assert(0); /* NOT REACHED */ + return 0; +} + +/* Specialized version for string-only keys */ +static PyDictKeyEntry * +lookdict_unicode(PyDictObject *mp, PyObject *key, + Py_hash_t hash, PyObject ***value_addr) +{ + size_t i; + size_t perturb; + PyDictKeyEntry *freeslot; + size_t mask = DK_MASK(mp->ma_keys); + PyDictKeyEntry *ep0 = &mp->ma_keys->dk_entries[0]; + PyDictKeyEntry *ep; + + /* Make sure this function doesn't have to handle non-unicode keys, + including subclasses of str; e.g., one reason to subclass + unicodes is to override __eq__, and for speed we don't cater to + that here. */ + if (!PyUnicode_CheckExact(key)) { + mp->ma_keys->dk_lookup = lookdict; + return lookdict(mp, key, hash, value_addr); + } + i = (size_t)hash & mask; + ep = &ep0[i]; + if (ep->me_key == NULL || ep->me_key == key) { + *value_addr = &ep->me_value; + return ep; + } + if (ep->me_key == dummy) + freeslot = ep; + else { + if (ep->me_hash == hash && unicode_eq(ep->me_key, key)) { + *value_addr = &ep->me_value; + return ep; + } + freeslot = NULL; + } + + /* In the loop, me_key == dummy is by far (factor of 100s) the + least likely outcome, so test for that last. */ + for (perturb = hash; ; perturb >>= PERTURB_SHIFT) { + i = (i << 2) + i + perturb + 1; + ep = &ep0[i & mask]; + if (ep->me_key == NULL) { + if (freeslot == NULL) { + *value_addr = &ep->me_value; + return ep; + } else { + *value_addr = &freeslot->me_value; + return freeslot; + } + } + if (ep->me_key == key + || (ep->me_hash == hash + && ep->me_key != dummy + && unicode_eq(ep->me_key, key))) { + *value_addr = &ep->me_value; + return ep; + } + if (ep->me_key == dummy && freeslot == NULL) + freeslot = ep; + } + assert(0); /* NOT REACHED */ + return 0; +} + +/* Faster version of lookdict_unicode when it is known that no keys + * will be present. */ +static PyDictKeyEntry * +lookdict_unicode_nodummy(PyDictObject *mp, PyObject *key, + Py_hash_t hash, PyObject ***value_addr) +{ + size_t i; + size_t perturb; + size_t mask = DK_MASK(mp->ma_keys); + PyDictKeyEntry *ep0 = &mp->ma_keys->dk_entries[0]; + PyDictKeyEntry *ep; + + /* Make sure this function doesn't have to handle non-unicode keys, + including subclasses of str; e.g., one reason to subclass + unicodes is to override __eq__, and for speed we don't cater to + that here. */ + if (!PyUnicode_CheckExact(key)) { + mp->ma_keys->dk_lookup = lookdict; + return lookdict(mp, key, hash, value_addr); + } + i = (size_t)hash & mask; + ep = &ep0[i]; + assert(ep->me_key == NULL || PyUnicode_CheckExact(ep->me_key)); + if (ep->me_key == NULL || ep->me_key == key || + (ep->me_hash == hash && unicode_eq(ep->me_key, key))) { + *value_addr = &ep->me_value; + return ep; + } + for (perturb = hash; ; perturb >>= PERTURB_SHIFT) { + i = (i << 2) + i + perturb + 1; + ep = &ep0[i & mask]; + assert(ep->me_key == NULL || PyUnicode_CheckExact(ep->me_key)); + if (ep->me_key == NULL || ep->me_key == key || + (ep->me_hash == hash && unicode_eq(ep->me_key, key))) { + *value_addr = &ep->me_value; + return ep; + } + } + assert(0); /* NOT REACHED */ + return 0; +} + +/* Version of lookdict for split tables. + * All split tables and only split tables use this lookup function. + * Split tables only contain unicode keys and no dummy keys, + * so algorithm is the same as lookdict_unicode_nodummy. + */ +static PyDictKeyEntry * +lookdict_split(PyDictObject *mp, PyObject *key, + Py_hash_t hash, PyObject ***value_addr) +{ + size_t i; + size_t perturb; + size_t mask = DK_MASK(mp->ma_keys); + PyDictKeyEntry *ep0 = &mp->ma_keys->dk_entries[0]; + PyDictKeyEntry *ep; + + if (!PyUnicode_CheckExact(key)) { + ep = lookdict(mp, key, hash, value_addr); + /* lookdict expects a combined-table, so fix value_addr */ + i = ep - ep0; + *value_addr = &mp->ma_values[i]; + return ep; + } + i = (size_t)hash & mask; + ep = &ep0[i]; + assert(ep->me_key == NULL || PyUnicode_CheckExact(ep->me_key)); + if (ep->me_key == NULL || ep->me_key == key || + (ep->me_hash == hash && unicode_eq(ep->me_key, key))) { + *value_addr = &mp->ma_values[i]; + return ep; + } + for (perturb = hash; ; perturb >>= PERTURB_SHIFT) { + i = (i << 2) + i + perturb + 1; + ep = &ep0[i & mask]; + assert(ep->me_key == NULL || PyUnicode_CheckExact(ep->me_key)); + if (ep->me_key == NULL || ep->me_key == key || + (ep->me_hash == hash && unicode_eq(ep->me_key, key))) { + *value_addr = &mp->ma_values[i & mask]; + return ep; + } + } + assert(0); /* NOT REACHED */ + return 0; +} + +int +_PyDict_HasOnlyStringKeys(PyObject *dict) +{ + Py_ssize_t pos = 0; + PyObject *key, *value; + assert(PyDict_Check(dict)); + /* Shortcut */ + if (((PyDictObject *)dict)->ma_keys->dk_lookup != lookdict) + return 1; + while (PyDict_Next(dict, &pos, &key, &value)) + if (!PyUnicode_Check(key)) + return 0; + return 1; +} + +#define MAINTAIN_TRACKING(mp, key, value) \ + do { \ + if (!_PyObject_GC_IS_TRACKED(mp)) { \ + if (_PyObject_GC_MAY_BE_TRACKED(key) || \ + _PyObject_GC_MAY_BE_TRACKED(value)) { \ + _PyObject_GC_TRACK(mp); \ + } \ + } \ + } while(0) + +void +_PyDict_MaybeUntrack(PyObject *op) +{ + PyDictObject *mp; + PyObject *value; + Py_ssize_t i, size; + + if (!PyDict_CheckExact(op) || !_PyObject_GC_IS_TRACKED(op)) + return; + + mp = (PyDictObject *) op; + size = DK_SIZE(mp->ma_keys); + if (_PyDict_HasSplitTable(mp)) { + for (i = 0; i < size; i++) { + if ((value = mp->ma_values[i]) == NULL) + continue; + if (_PyObject_GC_MAY_BE_TRACKED(value)) { + assert(!_PyObject_GC_MAY_BE_TRACKED( + mp->ma_keys->dk_entries[i].me_key)); + return; + } + } + } + else { + PyDictKeyEntry *ep0 = &mp->ma_keys->dk_entries[0]; + for (i = 0; i < size; i++) { + if ((value = ep0[i].me_value) == NULL) + continue; + if (_PyObject_GC_MAY_BE_TRACKED(value) || + _PyObject_GC_MAY_BE_TRACKED(ep0[i].me_key)) + return; + } + } + _PyObject_GC_UNTRACK(op); +} + +/* Internal function to find slot for an item from its hash + * when it is known that the key is not present in the dict. + */ +static PyDictKeyEntry * +find_empty_slot(PyDictObject *mp, PyObject *key, Py_hash_t hash, + PyObject ***value_addr) +{ + size_t i; + size_t perturb; + size_t mask = DK_MASK(mp->ma_keys); + PyDictKeyEntry *ep0 = &mp->ma_keys->dk_entries[0]; + PyDictKeyEntry *ep; + + assert(key != NULL); + if (!PyUnicode_CheckExact(key)) + mp->ma_keys->dk_lookup = lookdict; + i = hash & mask; + ep = &ep0[i]; + for (perturb = hash; ep->me_key != NULL; perturb >>= PERTURB_SHIFT) { + i = (i << 2) + i + perturb + 1; + ep = &ep0[i & mask]; + } + assert(ep->me_value == NULL); + if (mp->ma_values) + *value_addr = &mp->ma_values[i & mask]; + else + *value_addr = &ep->me_value; + return ep; +} + +static int +insertion_resize(PyDictObject *mp) +{ + return dictresize(mp, GROWTH_RATE(mp)); +} + +/* +Internal routine to insert a new item into the table. +Used both by the internal resize routine and by the public insert routine. +Returns -1 if an error occurred, or 0 on success. +*/ +static int +insertdict(PyDictObject *mp, PyObject *key, Py_hash_t hash, PyObject *value) +{ + PyObject *old_value; + PyObject **value_addr; + PyDictKeyEntry *ep; + assert(key != dummy); + + if (mp->ma_values != NULL && !PyUnicode_CheckExact(key)) { + if (insertion_resize(mp) < 0) + return -1; + } + + ep = mp->ma_keys->dk_lookup(mp, key, hash, &value_addr); + if (ep == NULL) { + return -1; + } + assert(PyUnicode_CheckExact(key) || mp->ma_keys->dk_lookup == lookdict); + Py_INCREF(value); + MAINTAIN_TRACKING(mp, key, value); + old_value = *value_addr; + if (old_value != NULL) { + assert(ep->me_key != NULL && ep->me_key != dummy); + *value_addr = value; + Py_DECREF(old_value); /* which **CAN** re-enter (see issue #22653) */ + } + else { + if (ep->me_key == NULL) { + Py_INCREF(key); + if (mp->ma_keys->dk_usable <= 0) { + /* Need to resize. */ + if (insertion_resize(mp) < 0) { + Py_DECREF(key); + Py_DECREF(value); + return -1; + } + ep = find_empty_slot(mp, key, hash, &value_addr); + } + mp->ma_keys->dk_usable--; + assert(mp->ma_keys->dk_usable >= 0); + ep->me_key = key; + ep->me_hash = hash; + } + else { + if (ep->me_key == dummy) { + Py_INCREF(key); + ep->me_key = key; + ep->me_hash = hash; + Py_DECREF(dummy); + } else { + assert(_PyDict_HasSplitTable(mp)); + } + } + mp->ma_used++; + *value_addr = value; + assert(ep->me_key != NULL && ep->me_key != dummy); + } + return 0; +} + +/* +Internal routine used by dictresize() to insert an item which is +known to be absent from the dict. This routine also assumes that +the dict contains no deleted entries. Besides the performance benefit, +using insertdict() in dictresize() is dangerous (SF bug #1456209). +Note that no refcounts are changed by this routine; if needed, the caller +is responsible for incref'ing `key` and `value`. +Neither mp->ma_used nor k->dk_usable are modified by this routine; the caller +must set them correctly +*/ +static void +insertdict_clean(PyDictObject *mp, PyObject *key, Py_hash_t hash, + PyObject *value) +{ + size_t i; + size_t perturb; + PyDictKeysObject *k = mp->ma_keys; + size_t mask = (size_t)DK_SIZE(k)-1; + PyDictKeyEntry *ep0 = &k->dk_entries[0]; + PyDictKeyEntry *ep; + + assert(k->dk_lookup != NULL); + assert(value != NULL); + assert(key != NULL); + assert(key != dummy); + assert(PyUnicode_CheckExact(key) || k->dk_lookup == lookdict); + i = hash & mask; + ep = &ep0[i]; + for (perturb = hash; ep->me_key != NULL; perturb >>= PERTURB_SHIFT) { + i = (i << 2) + i + perturb + 1; + ep = &ep0[i & mask]; + } + assert(ep->me_value == NULL); + ep->me_key = key; + ep->me_hash = hash; + ep->me_value = value; +} + +/* +Restructure the table by allocating a new table and reinserting all +items again. When entries have been deleted, the new table may +actually be smaller than the old one. +If a table is split (its keys and hashes are shared, its values are not), +then the values are temporarily copied into the table, it is resized as +a combined table, then the me_value slots in the old table are NULLed out. +After resizing a table is always combined, +but can be resplit by make_keys_shared(). +*/ +static int +dictresize(PyDictObject *mp, Py_ssize_t minused) +{ + Py_ssize_t newsize; + PyDictKeysObject *oldkeys; + PyObject **oldvalues; + Py_ssize_t i, oldsize; + +/* Find the smallest table size > minused. */ + for (newsize = PyDict_MINSIZE_COMBINED; + newsize <= minused && newsize > 0; + newsize <<= 1) + ; + if (newsize <= 0) { + PyErr_NoMemory(); + return -1; + } + oldkeys = mp->ma_keys; + oldvalues = mp->ma_values; + /* Allocate a new table. */ + mp->ma_keys = new_keys_object(newsize); + if (mp->ma_keys == NULL) { + mp->ma_keys = oldkeys; + return -1; + } + if (oldkeys->dk_lookup == lookdict) + mp->ma_keys->dk_lookup = lookdict; + oldsize = DK_SIZE(oldkeys); + mp->ma_values = NULL; + /* If empty then nothing to copy so just return */ + if (oldsize == 1) { + assert(oldkeys == Py_EMPTY_KEYS); + DK_DECREF(oldkeys); + return 0; + } + /* Main loop below assumes we can transfer refcount to new keys + * and that value is stored in me_value. + * Increment ref-counts and copy values here to compensate + * This (resizing a split table) should be relatively rare */ + if (oldvalues != NULL) { + for (i = 0; i < oldsize; i++) { + if (oldvalues[i] != NULL) { + Py_INCREF(oldkeys->dk_entries[i].me_key); + oldkeys->dk_entries[i].me_value = oldvalues[i]; + } + } + } + /* Main loop */ + for (i = 0; i < oldsize; i++) { + PyDictKeyEntry *ep = &oldkeys->dk_entries[i]; + if (ep->me_value != NULL) { + assert(ep->me_key != dummy); + insertdict_clean(mp, ep->me_key, ep->me_hash, ep->me_value); + } + } + mp->ma_keys->dk_usable -= mp->ma_used; + if (oldvalues != NULL) { + /* NULL out me_value slot in oldkeys, in case it was shared */ + for (i = 0; i < oldsize; i++) + oldkeys->dk_entries[i].me_value = NULL; + assert(oldvalues != empty_values); + free_values(oldvalues); + DK_DECREF(oldkeys); + } + else { + assert(oldkeys->dk_lookup != lookdict_split); + if (oldkeys->dk_lookup != lookdict_unicode_nodummy) { + PyDictKeyEntry *ep0 = &oldkeys->dk_entries[0]; + for (i = 0; i < oldsize; i++) { + if (ep0[i].me_key == dummy) + Py_DECREF(dummy); + } + } + assert(oldkeys->dk_refcnt == 1); + DK_DEBUG_DECREF PyMem_FREE(oldkeys); + } + return 0; +} + +/* Returns NULL if unable to split table. + * A NULL return does not necessarily indicate an error */ +static PyDictKeysObject * +make_keys_shared(PyObject *op) +{ + Py_ssize_t i; + Py_ssize_t size; + PyDictObject *mp = (PyDictObject *)op; + + if (!PyDict_CheckExact(op)) + return NULL; + if (!_PyDict_HasSplitTable(mp)) { + PyDictKeyEntry *ep0; + PyObject **values; + assert(mp->ma_keys->dk_refcnt == 1); + if (mp->ma_keys->dk_lookup == lookdict) { + return NULL; + } + else if (mp->ma_keys->dk_lookup == lookdict_unicode) { + /* Remove dummy keys */ + if (dictresize(mp, DK_SIZE(mp->ma_keys))) + return NULL; + } + assert(mp->ma_keys->dk_lookup == lookdict_unicode_nodummy); + /* Copy values into a new array */ + ep0 = &mp->ma_keys->dk_entries[0]; + size = DK_SIZE(mp->ma_keys); + values = new_values(size); + if (values == NULL) { + PyErr_SetString(PyExc_MemoryError, + "Not enough memory to allocate new values array"); + return NULL; + } + for (i = 0; i < size; i++) { + values[i] = ep0[i].me_value; + ep0[i].me_value = NULL; + } + mp->ma_keys->dk_lookup = lookdict_split; + mp->ma_values = values; + } + DK_INCREF(mp->ma_keys); + return mp->ma_keys; +} + +PyObject * +_PyDict_NewPresized(Py_ssize_t minused) +{ + Py_ssize_t newsize; + PyDictKeysObject *new_keys; + for (newsize = PyDict_MINSIZE_COMBINED; + newsize <= minused && newsize > 0; + newsize <<= 1) + ; + new_keys = new_keys_object(newsize); + if (new_keys == NULL) + return NULL; + return new_dict(new_keys, NULL); +} + +/* Note that, for historical reasons, PyDict_GetItem() suppresses all errors + * that may occur (originally dicts supported only string keys, and exceptions + * weren't possible). So, while the original intent was that a NULL return + * meant the key wasn't present, in reality it can mean that, or that an error + * (suppressed) occurred while computing the key's hash, or that some error + * (suppressed) occurred when comparing keys in the dict's internal probe + * sequence. A nasty example of the latter is when a Python-coded comparison + * function hits a stack-depth error, which can cause this to return NULL + * even if the key is present. + */ +PyObject * +PyDict_GetItem(PyObject *op, PyObject *key) +{ + Py_hash_t hash; + PyDictObject *mp = (PyDictObject *)op; + PyDictKeyEntry *ep; + PyThreadState *tstate; + PyObject **value_addr; + + if (!PyDict_Check(op)) + return NULL; + if (!PyUnicode_CheckExact(key) || + (hash = ((PyASCIIObject *) key)->hash) == -1) + { + hash = PyObject_Hash(key); + if (hash == -1) { + PyErr_Clear(); + return NULL; + } + } + + /* We can arrive here with a NULL tstate during initialization: try + running "python -Wi" for an example related to string interning. + Let's just hope that no exception occurs then... This must be + _PyThreadState_Current and not PyThreadState_GET() because in debug + mode, the latter complains if tstate is NULL. */ + tstate = (PyThreadState*)_Py_atomic_load_relaxed( + &_PyThreadState_Current); + if (tstate != NULL && tstate->curexc_type != NULL) { + /* preserve the existing exception */ + PyObject *err_type, *err_value, *err_tb; + PyErr_Fetch(&err_type, &err_value, &err_tb); + ep = (mp->ma_keys->dk_lookup)(mp, key, hash, &value_addr); + /* ignore errors */ + PyErr_Restore(err_type, err_value, err_tb); + if (ep == NULL) + return NULL; + } + else { + ep = (mp->ma_keys->dk_lookup)(mp, key, hash, &value_addr); + if (ep == NULL) { + PyErr_Clear(); + return NULL; + } + } + return *value_addr; +} + +PyObject * +_PyDict_GetItem_KnownHash(PyObject *op, PyObject *key, Py_hash_t hash) +{ + PyDictObject *mp = (PyDictObject *)op; + PyDictKeyEntry *ep; + PyThreadState *tstate; + PyObject **value_addr; + + if (!PyDict_Check(op)) + return NULL; + + /* We can arrive here with a NULL tstate during initialization: try + running "python -Wi" for an example related to string interning. + Let's just hope that no exception occurs then... This must be + _PyThreadState_Current and not PyThreadState_GET() because in debug + mode, the latter complains if tstate is NULL. */ + tstate = (PyThreadState*)_Py_atomic_load_relaxed( + &_PyThreadState_Current); + if (tstate != NULL && tstate->curexc_type != NULL) { + /* preserve the existing exception */ + PyObject *err_type, *err_value, *err_tb; + PyErr_Fetch(&err_type, &err_value, &err_tb); + ep = (mp->ma_keys->dk_lookup)(mp, key, hash, &value_addr); + /* ignore errors */ + PyErr_Restore(err_type, err_value, err_tb); + if (ep == NULL) + return NULL; + } + else { + ep = (mp->ma_keys->dk_lookup)(mp, key, hash, &value_addr); + if (ep == NULL) { + PyErr_Clear(); + return NULL; + } + } + return *value_addr; +} + +/* Variant of PyDict_GetItem() that doesn't suppress exceptions. + This returns NULL *with* an exception set if an exception occurred. + It returns NULL *without* an exception set if the key wasn't present. +*/ +PyObject * +PyDict_GetItemWithError(PyObject *op, PyObject *key) +{ + Py_hash_t hash; + PyDictObject*mp = (PyDictObject *)op; + PyDictKeyEntry *ep; + PyObject **value_addr; + + if (!PyDict_Check(op)) { + PyErr_BadInternalCall(); + return NULL; + } + if (!PyUnicode_CheckExact(key) || + (hash = ((PyASCIIObject *) key)->hash) == -1) + { + hash = PyObject_Hash(key); + if (hash == -1) { + return NULL; + } + } + + ep = (mp->ma_keys->dk_lookup)(mp, key, hash, &value_addr); + if (ep == NULL) + return NULL; + return *value_addr; +} + +PyObject * +_PyDict_GetItemIdWithError(PyObject *dp, struct _Py_Identifier *key) +{ + PyObject *kv; + kv = _PyUnicode_FromId(key); /* borrowed */ + if (kv == NULL) + return NULL; + return PyDict_GetItemWithError(dp, kv); +} + +/* Fast version of global value lookup. + * Lookup in globals, then builtins. + */ +PyObject * +_PyDict_LoadGlobal(PyDictObject *globals, PyDictObject *builtins, PyObject *key) +{ + PyObject *x; + if (PyUnicode_CheckExact(key)) { + PyObject **value_addr; + Py_hash_t hash = ((PyASCIIObject *)key)->hash; + if (hash != -1) { + PyDictKeyEntry *e; + e = globals->ma_keys->dk_lookup(globals, key, hash, &value_addr); + if (e == NULL) { + return NULL; + } + x = *value_addr; + if (x != NULL) + return x; + e = builtins->ma_keys->dk_lookup(builtins, key, hash, &value_addr); + if (e == NULL) { + return NULL; + } + x = *value_addr; + return x; + } + } + x = PyDict_GetItemWithError((PyObject *)globals, key); + if (x != NULL) + return x; + if (PyErr_Occurred()) + return NULL; + return PyDict_GetItemWithError((PyObject *)builtins, key); +} + +/* CAUTION: PyDict_SetItem() must guarantee that it won't resize the + * dictionary if it's merely replacing the value for an existing key. + * This means that it's safe to loop over a dictionary with PyDict_Next() + * and occasionally replace a value -- but you can't insert new keys or + * remove them. + */ +int +PyDict_SetItem(PyObject *op, PyObject *key, PyObject *value) +{ + PyDictObject *mp; + Py_hash_t hash; + if (!PyDict_Check(op)) { + PyErr_BadInternalCall(); + return -1; + } + assert(key); + assert(value); + mp = (PyDictObject *)op; + if (!PyUnicode_CheckExact(key) || + (hash = ((PyASCIIObject *) key)->hash) == -1) + { + hash = PyObject_Hash(key); + if (hash == -1) + return -1; + } + + /* insertdict() handles any resizing that might be necessary */ + return insertdict(mp, key, hash, value); +} + +int +_PyDict_SetItem_KnownHash(PyObject *op, PyObject *key, PyObject *value, + Py_hash_t hash) +{ + PyDictObject *mp; + + if (!PyDict_Check(op)) { + PyErr_BadInternalCall(); + return -1; + } + assert(key); + assert(value); + mp = (PyDictObject *)op; + + /* insertdict() handles any resizing that might be necessary */ + return insertdict(mp, key, hash, value); +} + +int +PyDict_DelItem(PyObject *op, PyObject *key) +{ + PyDictObject *mp; + Py_hash_t hash; + PyDictKeyEntry *ep; + PyObject *old_key, *old_value; + PyObject **value_addr; + + if (!PyDict_Check(op)) { + PyErr_BadInternalCall(); + return -1; + } + assert(key); + if (!PyUnicode_CheckExact(key) || + (hash = ((PyASCIIObject *) key)->hash) == -1) { + hash = PyObject_Hash(key); + if (hash == -1) + return -1; + } + mp = (PyDictObject *)op; + ep = (mp->ma_keys->dk_lookup)(mp, key, hash, &value_addr); + if (ep == NULL) + return -1; + if (*value_addr == NULL) { + _PyErr_SetKeyError(key); + return -1; + } + old_value = *value_addr; + *value_addr = NULL; + mp->ma_used--; + if (!_PyDict_HasSplitTable(mp)) { + ENSURE_ALLOWS_DELETIONS(mp); + old_key = ep->me_key; + Py_INCREF(dummy); + ep->me_key = dummy; + Py_DECREF(old_key); + } + Py_DECREF(old_value); + return 0; +} + +void +PyDict_Clear(PyObject *op) +{ + PyDictObject *mp; + PyDictKeysObject *oldkeys; + PyObject **oldvalues; + Py_ssize_t i, n; + + if (!PyDict_Check(op)) + return; + mp = ((PyDictObject *)op); + oldkeys = mp->ma_keys; + oldvalues = mp->ma_values; + if (oldvalues == empty_values) + return; + /* Empty the dict... */ + DK_INCREF(Py_EMPTY_KEYS); + mp->ma_keys = Py_EMPTY_KEYS; + mp->ma_values = empty_values; + mp->ma_used = 0; + /* ...then clear the keys and values */ + if (oldvalues != NULL) { + n = DK_SIZE(oldkeys); + for (i = 0; i < n; i++) + Py_CLEAR(oldvalues[i]); + free_values(oldvalues); + DK_DECREF(oldkeys); + } + else { + assert(oldkeys->dk_refcnt == 1); + DK_DECREF(oldkeys); + } +} + +/* Returns -1 if no more items (or op is not a dict), + * index of item otherwise. Stores value in pvalue + */ +Py_LOCAL_INLINE(Py_ssize_t) +dict_next(PyObject *op, Py_ssize_t i, PyObject **pvalue) +{ + Py_ssize_t mask, offset; + PyDictObject *mp; + PyObject **value_ptr; + + + if (!PyDict_Check(op)) + return -1; + mp = (PyDictObject *)op; + if (i < 0) + return -1; + if (mp->ma_values) { + value_ptr = &mp->ma_values[i]; + offset = sizeof(PyObject *); + } + else { + value_ptr = &mp->ma_keys->dk_entries[i].me_value; + offset = sizeof(PyDictKeyEntry); + } + mask = DK_MASK(mp->ma_keys); + while (i <= mask && *value_ptr == NULL) { + value_ptr = (PyObject **)(((char *)value_ptr) + offset); + i++; + } + if (i > mask) + return -1; + if (pvalue) + *pvalue = *value_ptr; + return i; +} + +/* + * Iterate over a dict. Use like so: + * + * Py_ssize_t i; + * PyObject *key, *value; + * i = 0; # important! i should not otherwise be changed by you + * while (PyDict_Next(yourdict, &i, &key, &value)) { + * Refer to borrowed references in key and value. + * } + * + * CAUTION: In general, it isn't safe to use PyDict_Next in a loop that + * mutates the dict. One exception: it is safe if the loop merely changes + * the values associated with the keys (but doesn't insert new keys or + * delete keys), via PyDict_SetItem(). + */ +int +PyDict_Next(PyObject *op, Py_ssize_t *ppos, PyObject **pkey, PyObject **pvalue) +{ + PyDictObject *mp; + Py_ssize_t i = dict_next(op, *ppos, pvalue); + if (i < 0) + return 0; + mp = (PyDictObject *)op; + *ppos = i+1; + if (pkey) + *pkey = mp->ma_keys->dk_entries[i].me_key; + return 1; +} + +/* Internal version of PyDict_Next that returns a hash value in addition + * to the key and value. + */ +int +_PyDict_Next(PyObject *op, Py_ssize_t *ppos, PyObject **pkey, + PyObject **pvalue, Py_hash_t *phash) +{ + PyDictObject *mp; + Py_ssize_t i = dict_next(op, *ppos, pvalue); + if (i < 0) + return 0; + mp = (PyDictObject *)op; + *ppos = i+1; + *phash = mp->ma_keys->dk_entries[i].me_hash; + if (pkey) + *pkey = mp->ma_keys->dk_entries[i].me_key; + return 1; +} + +/* Methods */ + +static void +dict_dealloc(PyDictObject *mp) +{ + PyObject **values = mp->ma_values; + PyDictKeysObject *keys = mp->ma_keys; + Py_ssize_t i, n; + PyObject_GC_UnTrack(mp); + Py_TRASHCAN_SAFE_BEGIN(mp) + if (values != NULL) { + if (values != empty_values) { + for (i = 0, n = DK_SIZE(mp->ma_keys); i < n; i++) { + Py_XDECREF(values[i]); + } + free_values(values); + } + DK_DECREF(keys); + } + else if (keys != NULL) { + assert(keys->dk_refcnt == 1); + DK_DECREF(keys); + } + if (numfree < PyDict_MAXFREELIST && Py_TYPE(mp) == &PyDict_Type) + free_list[numfree++] = mp; + else + Py_TYPE(mp)->tp_free((PyObject *)mp); + Py_TRASHCAN_SAFE_END(mp) +} + + +static PyObject * +dict_repr(PyDictObject *mp) +{ + Py_ssize_t i; + PyObject *key = NULL, *value = NULL; + _PyUnicodeWriter writer; + int first; + + i = Py_ReprEnter((PyObject *)mp); + if (i != 0) { + return i > 0 ? PyUnicode_FromString("{...}") : NULL; + } + + if (mp->ma_used == 0) { + Py_ReprLeave((PyObject *)mp); + return PyUnicode_FromString("{}"); + } + + _PyUnicodeWriter_Init(&writer); + writer.overallocate = 1; + /* "{" + "1: 2" + ", 3: 4" * (len - 1) + "}" */ + writer.min_length = 1 + 4 + (2 + 4) * (mp->ma_used - 1) + 1; + + if (_PyUnicodeWriter_WriteChar(&writer, '{') < 0) + goto error; + + /* Do repr() on each key+value pair, and insert ": " between them. + Note that repr may mutate the dict. */ + i = 0; + first = 1; + while (PyDict_Next((PyObject *)mp, &i, &key, &value)) { + PyObject *s; + int res; + + /* Prevent repr from deleting key or value during key format. */ + Py_INCREF(key); + Py_INCREF(value); + + if (!first) { + if (_PyUnicodeWriter_WriteASCIIString(&writer, ", ", 2) < 0) + goto error; + } + first = 0; + + s = PyObject_Repr(key); + if (s == NULL) + goto error; + res = _PyUnicodeWriter_WriteStr(&writer, s); + Py_DECREF(s); + if (res < 0) + goto error; + + if (_PyUnicodeWriter_WriteASCIIString(&writer, ": ", 2) < 0) + goto error; + + s = PyObject_Repr(value); + if (s == NULL) + goto error; + res = _PyUnicodeWriter_WriteStr(&writer, s); + Py_DECREF(s); + if (res < 0) + goto error; + + Py_CLEAR(key); + Py_CLEAR(value); + } + + writer.overallocate = 0; + if (_PyUnicodeWriter_WriteChar(&writer, '}') < 0) + goto error; + + Py_ReprLeave((PyObject *)mp); + + return _PyUnicodeWriter_Finish(&writer); + +error: + Py_ReprLeave((PyObject *)mp); + _PyUnicodeWriter_Dealloc(&writer); + Py_XDECREF(key); + Py_XDECREF(value); + return NULL; +} + +static Py_ssize_t +dict_length(PyDictObject *mp) +{ + return mp->ma_used; +} + +static PyObject * +dict_subscript(PyDictObject *mp, PyObject *key) +{ + PyObject *v; + Py_hash_t hash; + PyDictKeyEntry *ep; + PyObject **value_addr; + + if (!PyUnicode_CheckExact(key) || + (hash = ((PyASCIIObject *) key)->hash) == -1) { + hash = PyObject_Hash(key); + if (hash == -1) + return NULL; + } + ep = (mp->ma_keys->dk_lookup)(mp, key, hash, &value_addr); + if (ep == NULL) + return NULL; + v = *value_addr; + if (v == NULL) { + if (!PyDict_CheckExact(mp)) { + /* Look up __missing__ method if we're a subclass. */ + PyObject *missing, *res; + _Py_IDENTIFIER(__missing__); + missing = _PyObject_LookupSpecial((PyObject *)mp, &PyId___missing__); + if (missing != NULL) { + res = PyObject_CallFunctionObjArgs(missing, + key, NULL); + Py_DECREF(missing); + return res; + } + else if (PyErr_Occurred()) + return NULL; + } + _PyErr_SetKeyError(key); + return NULL; + } + else + Py_INCREF(v); + return v; +} + +static int +dict_ass_sub(PyDictObject *mp, PyObject *v, PyObject *w) +{ + if (w == NULL) + return PyDict_DelItem((PyObject *)mp, v); + else + return PyDict_SetItem((PyObject *)mp, v, w); +} + +static PyMappingMethods dict_as_mapping = { + (lenfunc)dict_length, /*mp_length*/ + (binaryfunc)dict_subscript, /*mp_subscript*/ + (objobjargproc)dict_ass_sub, /*mp_ass_subscript*/ +}; + +static PyObject * +dict_keys(PyDictObject *mp) +{ + PyObject *v; + Py_ssize_t i, j; + PyDictKeyEntry *ep; + Py_ssize_t size, n, offset; + PyObject **value_ptr; + + again: + n = mp->ma_used; + v = PyList_New(n); + if (v == NULL) + return NULL; + if (n != mp->ma_used) { + /* Durnit. The allocations caused the dict to resize. + * Just start over, this shouldn't normally happen. + */ + Py_DECREF(v); + goto again; + } + ep = &mp->ma_keys->dk_entries[0]; + size = DK_SIZE(mp->ma_keys); + if (mp->ma_values) { + value_ptr = mp->ma_values; + offset = sizeof(PyObject *); + } + else { + value_ptr = &ep[0].me_value; + offset = sizeof(PyDictKeyEntry); + } + for (i = 0, j = 0; i < size; i++) { + if (*value_ptr != NULL) { + PyObject *key = ep[i].me_key; + Py_INCREF(key); + PyList_SET_ITEM(v, j, key); + j++; + } + value_ptr = (PyObject **)(((char *)value_ptr) + offset); + } + assert(j == n); + return v; +} + +static PyObject * +dict_values(PyDictObject *mp) +{ + PyObject *v; + Py_ssize_t i, j; + Py_ssize_t size, n, offset; + PyObject **value_ptr; + + again: + n = mp->ma_used; + v = PyList_New(n); + if (v == NULL) + return NULL; + if (n != mp->ma_used) { + /* Durnit. The allocations caused the dict to resize. + * Just start over, this shouldn't normally happen. + */ + Py_DECREF(v); + goto again; + } + size = DK_SIZE(mp->ma_keys); + if (mp->ma_values) { + value_ptr = mp->ma_values; + offset = sizeof(PyObject *); + } + else { + value_ptr = &mp->ma_keys->dk_entries[0].me_value; + offset = sizeof(PyDictKeyEntry); + } + for (i = 0, j = 0; i < size; i++) { + PyObject *value = *value_ptr; + value_ptr = (PyObject **)(((char *)value_ptr) + offset); + if (value != NULL) { + Py_INCREF(value); + PyList_SET_ITEM(v, j, value); + j++; + } + } + assert(j == n); + return v; +} + +static PyObject * +dict_items(PyDictObject *mp) +{ + PyObject *v; + Py_ssize_t i, j, n; + Py_ssize_t size, offset; + PyObject *item, *key; + PyDictKeyEntry *ep; + PyObject **value_ptr; + + /* Preallocate the list of tuples, to avoid allocations during + * the loop over the items, which could trigger GC, which + * could resize the dict. :-( + */ + again: + n = mp->ma_used; + v = PyList_New(n); + if (v == NULL) + return NULL; + for (i = 0; i < n; i++) { + item = PyTuple_New(2); + if (item == NULL) { + Py_DECREF(v); + return NULL; + } + PyList_SET_ITEM(v, i, item); + } + if (n != mp->ma_used) { + /* Durnit. The allocations caused the dict to resize. + * Just start over, this shouldn't normally happen. + */ + Py_DECREF(v); + goto again; + } + /* Nothing we do below makes any function calls. */ + ep = mp->ma_keys->dk_entries; + size = DK_SIZE(mp->ma_keys); + if (mp->ma_values) { + value_ptr = mp->ma_values; + offset = sizeof(PyObject *); + } + else { + value_ptr = &ep[0].me_value; + offset = sizeof(PyDictKeyEntry); + } + for (i = 0, j = 0; i < size; i++) { + PyObject *value = *value_ptr; + value_ptr = (PyObject **)(((char *)value_ptr) + offset); + if (value != NULL) { + key = ep[i].me_key; + item = PyList_GET_ITEM(v, j); + Py_INCREF(key); + PyTuple_SET_ITEM(item, 0, key); + Py_INCREF(value); + PyTuple_SET_ITEM(item, 1, value); + j++; + } + } + assert(j == n); + return v; +} + +/*[clinic input] +@classmethod +dict.fromkeys + iterable: object + value: object=None + / + +Returns a new dict with keys from iterable and values equal to value. [clinic start generated code]*/ PyDoc_STRVAR(dict_fromkeys__doc__, @@ -31,6 +1786,486 @@ return return_value; } +static PyObject * +dict_fromkeys_impl(PyTypeObject *type, PyObject *iterable, PyObject *value) +/*[clinic end generated code: output=55f8dc0ffa87406f input=b85a667f9bf4669d]*/ +{ + PyObject *it; /* iter(seq) */ + PyObject *key; + PyObject *d; + int status; + + d = PyObject_CallObject((PyObject *)type, NULL); + if (d == NULL) + return NULL; + + if (PyDict_CheckExact(d) && ((PyDictObject *)d)->ma_used == 0) { + if (PyDict_CheckExact(iterable)) { + PyDictObject *mp = (PyDictObject *)d; + PyObject *oldvalue; + Py_ssize_t pos = 0; + PyObject *key; + Py_hash_t hash; + + if (dictresize(mp, Py_SIZE(iterable))) { + Py_DECREF(d); + return NULL; + } + + while (_PyDict_Next(iterable, &pos, &key, &oldvalue, &hash)) { + if (insertdict(mp, key, hash, value)) { + Py_DECREF(d); + return NULL; + } + } + return d; + } + if (PyAnySet_CheckExact(iterable)) { + PyDictObject *mp = (PyDictObject *)d; + Py_ssize_t pos = 0; + PyObject *key; + Py_hash_t hash; + + if (dictresize(mp, PySet_GET_SIZE(iterable))) { + Py_DECREF(d); + return NULL; + } + + while (_PySet_NextEntry(iterable, &pos, &key, &hash)) { + if (insertdict(mp, key, hash, value)) { + Py_DECREF(d); + return NULL; + } + } + return d; + } + } + + it = PyObject_GetIter(iterable); + if (it == NULL){ + Py_DECREF(d); + return NULL; + } + + if (PyDict_CheckExact(d)) { + while ((key = PyIter_Next(it)) != NULL) { + status = PyDict_SetItem(d, key, value); + Py_DECREF(key); + if (status < 0) + goto Fail; + } + } else { + while ((key = PyIter_Next(it)) != NULL) { + status = PyObject_SetItem(d, key, value); + Py_DECREF(key); + if (status < 0) + goto Fail; + } + } + + if (PyErr_Occurred()) + goto Fail; + Py_DECREF(it); + return d; + +Fail: + Py_DECREF(it); + Py_DECREF(d); + return NULL; +} + +static int +dict_update_common(PyObject *self, PyObject *args, PyObject *kwds, char *methname) +{ + PyObject *arg = NULL; + int result = 0; + + if (!PyArg_UnpackTuple(args, methname, 0, 1, &arg)) + result = -1; + + else if (arg != NULL) { + _Py_IDENTIFIER(keys); + if (_PyObject_HasAttrId(arg, &PyId_keys)) + result = PyDict_Merge(self, arg, 1); + else + result = PyDict_MergeFromSeq2(self, arg, 1); + } + if (result == 0 && kwds != NULL) { + if (PyArg_ValidateKeywordArguments(kwds)) + result = PyDict_Merge(self, kwds, 1); + else + result = -1; + } + return result; +} + +static PyObject * +dict_update(PyObject *self, PyObject *args, PyObject *kwds) +{ + if (dict_update_common(self, args, kwds, "update") != -1) + Py_RETURN_NONE; + return NULL; +} + +/* Update unconditionally replaces existing items. + Merge has a 3rd argument 'override'; if set, it acts like Update, + otherwise it leaves existing items unchanged. + + PyDict_{Update,Merge} update/merge from a mapping object. + + PyDict_MergeFromSeq2 updates/merges from any iterable object + producing iterable objects of length 2. +*/ + +int +PyDict_MergeFromSeq2(PyObject *d, PyObject *seq2, int override) +{ + PyObject *it; /* iter(seq2) */ + Py_ssize_t i; /* index into seq2 of current element */ + PyObject *item; /* seq2[i] */ + PyObject *fast; /* item as a 2-tuple or 2-list */ + + assert(d != NULL); + assert(PyDict_Check(d)); + assert(seq2 != NULL); + + it = PyObject_GetIter(seq2); + if (it == NULL) + return -1; + + for (i = 0; ; ++i) { + PyObject *key, *value; + Py_ssize_t n; + + fast = NULL; + item = PyIter_Next(it); + if (item == NULL) { + if (PyErr_Occurred()) + goto Fail; + break; + } + + /* Convert item to sequence, and verify length 2. */ + fast = PySequence_Fast(item, ""); + if (fast == NULL) { + if (PyErr_ExceptionMatches(PyExc_TypeError)) + PyErr_Format(PyExc_TypeError, + "cannot convert dictionary update " + "sequence element #%zd to a sequence", + i); + goto Fail; + } + n = PySequence_Fast_GET_SIZE(fast); + if (n != 2) { + PyErr_Format(PyExc_ValueError, + "dictionary update sequence element #%zd " + "has length %zd; 2 is required", + i, n); + goto Fail; + } + + /* Update/merge with this (key, value) pair. */ + key = PySequence_Fast_GET_ITEM(fast, 0); + value = PySequence_Fast_GET_ITEM(fast, 1); + if (override || PyDict_GetItem(d, key) == NULL) { + int status = PyDict_SetItem(d, key, value); + if (status < 0) + goto Fail; + } + Py_DECREF(fast); + Py_DECREF(item); + } + + i = 0; + goto Return; +Fail: + Py_XDECREF(item); + Py_XDECREF(fast); + i = -1; +Return: + Py_DECREF(it); + return Py_SAFE_DOWNCAST(i, Py_ssize_t, int); +} + +int +PyDict_Update(PyObject *a, PyObject *b) +{ + return PyDict_Merge(a, b, 1); +} + +int +PyDict_Merge(PyObject *a, PyObject *b, int override) +{ + PyDictObject *mp, *other; + Py_ssize_t i, n; + PyDictKeyEntry *entry; + + /* We accept for the argument either a concrete dictionary object, + * or an abstract "mapping" object. For the former, we can do + * things quite efficiently. For the latter, we only require that + * PyMapping_Keys() and PyObject_GetItem() be supported. + */ + if (a == NULL || !PyDict_Check(a) || b == NULL) { + PyErr_BadInternalCall(); + return -1; + } + mp = (PyDictObject*)a; + if (PyDict_Check(b)) { + other = (PyDictObject*)b; + if (other == mp || other->ma_used == 0) + /* a.update(a) or a.update({}); nothing to do */ + return 0; + if (mp->ma_used == 0) + /* Since the target dict is empty, PyDict_GetItem() + * always returns NULL. Setting override to 1 + * skips the unnecessary test. + */ + override = 1; + /* Do one big resize at the start, rather than + * incrementally resizing as we insert new items. Expect + * that there will be no (or few) overlapping keys. + */ + if (mp->ma_keys->dk_usable * 3 < other->ma_used * 2) + if (dictresize(mp, (mp->ma_used + other->ma_used)*2) != 0) + return -1; + for (i = 0, n = DK_SIZE(other->ma_keys); i < n; i++) { + PyObject *value; + entry = &other->ma_keys->dk_entries[i]; + if (other->ma_values) + value = other->ma_values[i]; + else + value = entry->me_value; + + if (value != NULL && + (override || + PyDict_GetItem(a, entry->me_key) == NULL)) { + if (insertdict(mp, entry->me_key, + entry->me_hash, + value) != 0) + return -1; + } + } + } + else { + /* Do it the generic, slower way */ + PyObject *keys = PyMapping_Keys(b); + PyObject *iter; + PyObject *key, *value; + int status; + + if (keys == NULL) + /* Docstring says this is equivalent to E.keys() so + * if E doesn't have a .keys() method we want + * AttributeError to percolate up. Might as well + * do the same for any other error. + */ + return -1; + + iter = PyObject_GetIter(keys); + Py_DECREF(keys); + if (iter == NULL) + return -1; + + for (key = PyIter_Next(iter); key; key = PyIter_Next(iter)) { + if (!override && PyDict_GetItem(a, key) != NULL) { + Py_DECREF(key); + continue; + } + value = PyObject_GetItem(b, key); + if (value == NULL) { + Py_DECREF(iter); + Py_DECREF(key); + return -1; + } + status = PyDict_SetItem(a, key, value); + Py_DECREF(key); + Py_DECREF(value); + if (status < 0) { + Py_DECREF(iter); + return -1; + } + } + Py_DECREF(iter); + if (PyErr_Occurred()) + /* Iterator completed, via error */ + return -1; + } + return 0; +} + +static PyObject * +dict_copy(PyDictObject *mp) +{ + return PyDict_Copy((PyObject*)mp); +} + +PyObject * +PyDict_Copy(PyObject *o) +{ + PyObject *copy; + PyDictObject *mp; + Py_ssize_t i, n; + + if (o == NULL || !PyDict_Check(o)) { + PyErr_BadInternalCall(); + return NULL; + } + mp = (PyDictObject *)o; + if (_PyDict_HasSplitTable(mp)) { + PyDictObject *split_copy; + PyObject **newvalues = new_values(DK_SIZE(mp->ma_keys)); + if (newvalues == NULL) + return PyErr_NoMemory(); + split_copy = PyObject_GC_New(PyDictObject, &PyDict_Type); + if (split_copy == NULL) { + free_values(newvalues); + return NULL; + } + split_copy->ma_values = newvalues; + split_copy->ma_keys = mp->ma_keys; + split_copy->ma_used = mp->ma_used; + DK_INCREF(mp->ma_keys); + for (i = 0, n = DK_SIZE(mp->ma_keys); i < n; i++) { + PyObject *value = mp->ma_values[i]; + Py_XINCREF(value); + split_copy->ma_values[i] = value; + } + if (_PyObject_GC_IS_TRACKED(mp)) + _PyObject_GC_TRACK(split_copy); + return (PyObject *)split_copy; + } + copy = PyDict_New(); + if (copy == NULL) + return NULL; + if (PyDict_Merge(copy, o, 1) == 0) + return copy; + Py_DECREF(copy); + return NULL; +} + +Py_ssize_t +PyDict_Size(PyObject *mp) +{ + if (mp == NULL || !PyDict_Check(mp)) { + PyErr_BadInternalCall(); + return -1; + } + return ((PyDictObject *)mp)->ma_used; +} + +PyObject * +PyDict_Keys(PyObject *mp) +{ + if (mp == NULL || !PyDict_Check(mp)) { + PyErr_BadInternalCall(); + return NULL; + } + return dict_keys((PyDictObject *)mp); +} + +PyObject * +PyDict_Values(PyObject *mp) +{ + if (mp == NULL || !PyDict_Check(mp)) { + PyErr_BadInternalCall(); + return NULL; + } + return dict_values((PyDictObject *)mp); +} + +PyObject * +PyDict_Items(PyObject *mp) +{ + if (mp == NULL || !PyDict_Check(mp)) { + PyErr_BadInternalCall(); + return NULL; + } + return dict_items((PyDictObject *)mp); +} + +/* Return 1 if dicts equal, 0 if not, -1 if error. + * Gets out as soon as any difference is detected. + * Uses only Py_EQ comparison. + */ +static int +dict_equal(PyDictObject *a, PyDictObject *b) +{ + Py_ssize_t i; + + if (a->ma_used != b->ma_used) + /* can't be equal if # of entries differ */ + return 0; + /* Same # of entries -- check all of 'em. Exit early on any diff. */ + for (i = 0; i < DK_SIZE(a->ma_keys); i++) { + PyDictKeyEntry *ep = &a->ma_keys->dk_entries[i]; + PyObject *aval; + if (a->ma_values) + aval = a->ma_values[i]; + else + aval = ep->me_value; + if (aval != NULL) { + int cmp; + PyObject *bval; + PyObject **vaddr; + PyObject *key = ep->me_key; + /* temporarily bump aval's refcount to ensure it stays + alive until we're done with it */ + Py_INCREF(aval); + /* ditto for key */ + Py_INCREF(key); + /* reuse the known hash value */ + if ((b->ma_keys->dk_lookup)(b, key, ep->me_hash, &vaddr) == NULL) + bval = NULL; + else + bval = *vaddr; + Py_DECREF(key); + if (bval == NULL) { + Py_DECREF(aval); + if (PyErr_Occurred()) + return -1; + return 0; + } + cmp = PyObject_RichCompareBool(aval, bval, Py_EQ); + Py_DECREF(aval); + if (cmp <= 0) /* error or not equal */ + return cmp; + } + } + return 1; +} + +static PyObject * +dict_richcompare(PyObject *v, PyObject *w, int op) +{ + int cmp; + PyObject *res; + + if (!PyDict_Check(v) || !PyDict_Check(w)) { + res = Py_NotImplemented; + } + else if (op == Py_EQ || op == Py_NE) { + cmp = dict_equal((PyDictObject *)v, (PyDictObject *)w); + if (cmp < 0) + return NULL; + res = (cmp == (op == Py_EQ)) ? Py_True : Py_False; + } + else + res = Py_NotImplemented; + Py_INCREF(res); + return res; +} + +/*[clinic input] + +@coexist +dict.__contains__ + + key: object + / + +True if D has a key k, else False. +[clinic start generated code]*/ + PyDoc_STRVAR(dict___contains____doc__, "__contains__($self, key, /)\n" "--\n" @@ -39,4 +2274,1654 @@ #define DICT___CONTAINS___METHODDEF \ {"__contains__", (PyCFunction)dict___contains__, METH_O|METH_COEXIST, dict___contains____doc__}, -/*[clinic end generated code: output=fe74d676332fdba6 input=a9049054013a1b77]*/ + +static PyObject * +dict___contains__(PyDictObject *self, PyObject *key) +/*[clinic end generated code: output=3cf3f8aaf2cc5cc3 input=b852b2a19b51ab24]*/ +{ + register PyDictObject *mp = self; + Py_hash_t hash; + PyDictKeyEntry *ep; + PyObject **value_addr; + + if (!PyUnicode_CheckExact(key) || + (hash = ((PyASCIIObject *) key)->hash) == -1) { + hash = PyObject_Hash(key); + if (hash == -1) + return NULL; + } + ep = (mp->ma_keys->dk_lookup)(mp, key, hash, &value_addr); + if (ep == NULL) + return NULL; + return PyBool_FromLong(*value_addr != NULL); +} + +static PyObject * +dict_get(PyDictObject *mp, PyObject *args) +{ + PyObject *key; + PyObject *failobj = Py_None; + PyObject *val = NULL; + Py_hash_t hash; + PyDictKeyEntry *ep; + PyObject **value_addr; + + if (!PyArg_UnpackTuple(args, "get", 1, 2, &key, &failobj)) + return NULL; + + if (!PyUnicode_CheckExact(key) || + (hash = ((PyASCIIObject *) key)->hash) == -1) { + hash = PyObject_Hash(key); + if (hash == -1) + return NULL; + } + ep = (mp->ma_keys->dk_lookup)(mp, key, hash, &value_addr); + if (ep == NULL) + return NULL; + val = *value_addr; + if (val == NULL) + val = failobj; + Py_INCREF(val); + return val; +} + +PyObject * +PyDict_SetDefault(PyObject *d, PyObject *key, PyObject *defaultobj) +{ + PyDictObject *mp = (PyDictObject *)d; + PyObject *val = NULL; + Py_hash_t hash; + PyDictKeyEntry *ep; + PyObject **value_addr; + + if (!PyDict_Check(d)) { + PyErr_BadInternalCall(); + return NULL; + } + if (!PyUnicode_CheckExact(key) || + (hash = ((PyASCIIObject *) key)->hash) == -1) { + hash = PyObject_Hash(key); + if (hash == -1) + return NULL; + } + ep = (mp->ma_keys->dk_lookup)(mp, key, hash, &value_addr); + if (ep == NULL) + return NULL; + val = *value_addr; + if (val == NULL) { + if (mp->ma_keys->dk_usable <= 0) { + /* Need to resize. */ + if (insertion_resize(mp) < 0) + return NULL; + ep = find_empty_slot(mp, key, hash, &value_addr); + } + Py_INCREF(defaultobj); + Py_INCREF(key); + MAINTAIN_TRACKING(mp, key, defaultobj); + ep->me_key = key; + ep->me_hash = hash; + *value_addr = defaultobj; + val = defaultobj; + mp->ma_keys->dk_usable--; + mp->ma_used++; + } + return val; +} + +static PyObject * +dict_setdefault(PyDictObject *mp, PyObject *args) +{ + PyObject *key, *val; + PyObject *defaultobj = Py_None; + + if (!PyArg_UnpackTuple(args, "setdefault", 1, 2, &key, &defaultobj)) + return NULL; + + val = PyDict_SetDefault((PyObject *)mp, key, defaultobj); + Py_XINCREF(val); + return val; +} + +static PyObject * +dict_clear(PyDictObject *mp) +{ + PyDict_Clear((PyObject *)mp); + Py_RETURN_NONE; +} + +static PyObject * +dict_pop(PyDictObject *mp, PyObject *args) +{ + Py_hash_t hash; + PyObject *old_value, *old_key; + PyObject *key, *deflt = NULL; + PyDictKeyEntry *ep; + PyObject **value_addr; + + if(!PyArg_UnpackTuple(args, "pop", 1, 2, &key, &deflt)) + return NULL; + if (mp->ma_used == 0) { + if (deflt) { + Py_INCREF(deflt); + return deflt; + } + _PyErr_SetKeyError(key); + return NULL; + } + if (!PyUnicode_CheckExact(key) || + (hash = ((PyASCIIObject *) key)->hash) == -1) { + hash = PyObject_Hash(key); + if (hash == -1) + return NULL; + } + ep = (mp->ma_keys->dk_lookup)(mp, key, hash, &value_addr); + if (ep == NULL) + return NULL; + old_value = *value_addr; + if (old_value == NULL) { + if (deflt) { + Py_INCREF(deflt); + return deflt; + } + _PyErr_SetKeyError(key); + return NULL; + } + *value_addr = NULL; + mp->ma_used--; + if (!_PyDict_HasSplitTable(mp)) { + ENSURE_ALLOWS_DELETIONS(mp); + old_key = ep->me_key; + Py_INCREF(dummy); + ep->me_key = dummy; + Py_DECREF(old_key); + } + return old_value; +} + +static PyObject * +dict_popitem(PyDictObject *mp) +{ + Py_hash_t i = 0; + PyDictKeyEntry *ep; + PyObject *res; + + + /* Allocate the result tuple before checking the size. Believe it + * or not, this allocation could trigger a garbage collection which + * could empty the dict, so if we checked the size first and that + * happened, the result would be an infinite loop (searching for an + * entry that no longer exists). Note that the usual popitem() + * idiom is "while d: k, v = d.popitem()". so needing to throw the + * tuple away if the dict *is* empty isn't a significant + * inefficiency -- possible, but unlikely in practice. + */ + res = PyTuple_New(2); + if (res == NULL) + return NULL; + if (mp->ma_used == 0) { + Py_DECREF(res); + PyErr_SetString(PyExc_KeyError, + "popitem(): dictionary is empty"); + return NULL; + } + /* Convert split table to combined table */ + if (mp->ma_keys->dk_lookup == lookdict_split) { + if (dictresize(mp, DK_SIZE(mp->ma_keys))) { + Py_DECREF(res); + return NULL; + } + } + ENSURE_ALLOWS_DELETIONS(mp); + /* Set ep to "the first" dict entry with a value. We abuse the hash + * field of slot 0 to hold a search finger: + * If slot 0 has a value, use slot 0. + * Else slot 0 is being used to hold a search finger, + * and we use its hash value as the first index to look. + */ + ep = &mp->ma_keys->dk_entries[0]; + if (ep->me_value == NULL) { + Py_ssize_t mask = DK_MASK(mp->ma_keys); + i = ep->me_hash; + /* The hash field may be a real hash value, or it may be a + * legit search finger, or it may be a once-legit search + * finger that's out of bounds now because it wrapped around + * or the table shrunk -- simply make sure it's in bounds now. + */ + if (i > mask || i < 1) + i = 1; /* skip slot 0 */ + while ((ep = &mp->ma_keys->dk_entries[i])->me_value == NULL) { + i++; + if (i > mask) + i = 1; + } + } + PyTuple_SET_ITEM(res, 0, ep->me_key); + PyTuple_SET_ITEM(res, 1, ep->me_value); + Py_INCREF(dummy); + ep->me_key = dummy; + ep->me_value = NULL; + mp->ma_used--; + assert(mp->ma_keys->dk_entries[0].me_value == NULL); + mp->ma_keys->dk_entries[0].me_hash = i + 1; /* next place to start */ + return res; +} + +static int +dict_traverse(PyObject *op, visitproc visit, void *arg) +{ + Py_ssize_t i, n; + PyDictObject *mp = (PyDictObject *)op; + if (mp->ma_keys->dk_lookup == lookdict) { + for (i = 0; i < DK_SIZE(mp->ma_keys); i++) { + if (mp->ma_keys->dk_entries[i].me_value != NULL) { + Py_VISIT(mp->ma_keys->dk_entries[i].me_value); + Py_VISIT(mp->ma_keys->dk_entries[i].me_key); + } + } + } else { + if (mp->ma_values != NULL) { + for (i = 0, n = DK_SIZE(mp->ma_keys); i < n; i++) { + Py_VISIT(mp->ma_values[i]); + } + } + else { + for (i = 0, n = DK_SIZE(mp->ma_keys); i < n; i++) { + Py_VISIT(mp->ma_keys->dk_entries[i].me_value); + } + } + } + return 0; +} + +static int +dict_tp_clear(PyObject *op) +{ + PyDict_Clear(op); + return 0; +} + +static PyObject *dictiter_new(PyDictObject *, PyTypeObject *); + +static PyObject * +dict_sizeof(PyDictObject *mp) +{ + Py_ssize_t size, res; + + size = DK_SIZE(mp->ma_keys); + res = sizeof(PyDictObject); + if (mp->ma_values) + res += size * sizeof(PyObject*); + /* If the dictionary is split, the keys portion is accounted-for + in the type object. */ + if (mp->ma_keys->dk_refcnt == 1) + res += sizeof(PyDictKeysObject) + (size-1) * sizeof(PyDictKeyEntry); + return PyLong_FromSsize_t(res); +} + +Py_ssize_t +_PyDict_KeysSize(PyDictKeysObject *keys) +{ + return sizeof(PyDictKeysObject) + (DK_SIZE(keys)-1) * sizeof(PyDictKeyEntry); +} + +PyDoc_STRVAR(getitem__doc__, "x.__getitem__(y) <==> x[y]"); + +PyDoc_STRVAR(sizeof__doc__, +"D.__sizeof__() -> size of D in memory, in bytes"); + +PyDoc_STRVAR(get__doc__, +"D.get(k[,d]) -> D[k] if k in D, else d. d defaults to None."); + +PyDoc_STRVAR(setdefault_doc__, +"D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D"); + +PyDoc_STRVAR(pop__doc__, +"D.pop(k[,d]) -> v, remove specified key and return the corresponding value.\n\ +If key is not found, d is returned if given, otherwise KeyError is raised"); + +PyDoc_STRVAR(popitem__doc__, +"D.popitem() -> (k, v), remove and return some (key, value) pair as a\n\ +2-tuple; but raise KeyError if D is empty."); + +PyDoc_STRVAR(update__doc__, +"D.update([E, ]**F) -> None. Update D from dict/iterable E and F.\n\ +If E is present and has a .keys() method, then does: for k in E: D[k] = E[k]\n\ +If E is present and lacks a .keys() method, then does: for k, v in E: D[k] = v\n\ +In either case, this is followed by: for k in F: D[k] = F[k]"); + +PyDoc_STRVAR(clear__doc__, +"D.clear() -> None. Remove all items from D."); + +PyDoc_STRVAR(copy__doc__, +"D.copy() -> a shallow copy of D"); + +/* Forward */ +static PyObject *dictkeys_new(PyObject *); +static PyObject *dictitems_new(PyObject *); +static PyObject *dictvalues_new(PyObject *); + +PyDoc_STRVAR(keys__doc__, + "D.keys() -> a set-like object providing a view on D's keys"); +PyDoc_STRVAR(items__doc__, + "D.items() -> a set-like object providing a view on D's items"); +PyDoc_STRVAR(values__doc__, + "D.values() -> an object providing a view on D's values"); + +static PyMethodDef mapp_methods[] = { + DICT___CONTAINS___METHODDEF + {"__getitem__", (PyCFunction)dict_subscript, METH_O | METH_COEXIST, + getitem__doc__}, + {"__sizeof__", (PyCFunction)dict_sizeof, METH_NOARGS, + sizeof__doc__}, + {"get", (PyCFunction)dict_get, METH_VARARGS, + get__doc__}, + {"setdefault", (PyCFunction)dict_setdefault, METH_VARARGS, + setdefault_doc__}, + {"pop", (PyCFunction)dict_pop, METH_VARARGS, + pop__doc__}, + {"popitem", (PyCFunction)dict_popitem, METH_NOARGS, + popitem__doc__}, + {"keys", (PyCFunction)dictkeys_new, METH_NOARGS, + keys__doc__}, + {"items", (PyCFunction)dictitems_new, METH_NOARGS, + items__doc__}, + {"values", (PyCFunction)dictvalues_new, METH_NOARGS, + values__doc__}, + {"update", (PyCFunction)dict_update, METH_VARARGS | METH_KEYWORDS, + update__doc__}, + DICT_FROMKEYS_METHODDEF + {"clear", (PyCFunction)dict_clear, METH_NOARGS, + clear__doc__}, + {"copy", (PyCFunction)dict_copy, METH_NOARGS, + copy__doc__}, + {NULL, NULL} /* sentinel */ +}; + +/* Return 1 if `key` is in dict `op`, 0 if not, and -1 on error. */ +int +PyDict_Contains(PyObject *op, PyObject *key) +{ + Py_hash_t hash; + PyDictObject *mp = (PyDictObject *)op; + PyDictKeyEntry *ep; + PyObject **value_addr; + + if (!PyUnicode_CheckExact(key) || + (hash = ((PyASCIIObject *) key)->hash) == -1) { + hash = PyObject_Hash(key); + if (hash == -1) + return -1; + } + ep = (mp->ma_keys->dk_lookup)(mp, key, hash, &value_addr); + return (ep == NULL) ? -1 : (*value_addr != NULL); +} + +/* Internal version of PyDict_Contains used when the hash value is already known */ +int +_PyDict_Contains(PyObject *op, PyObject *key, Py_hash_t hash) +{ + PyDictObject *mp = (PyDictObject *)op; + PyDictKeyEntry *ep; + PyObject **value_addr; + + ep = (mp->ma_keys->dk_lookup)(mp, key, hash, &value_addr); + return (ep == NULL) ? -1 : (*value_addr != NULL); +} + +/* Hack to implement "key in dict" */ +static PySequenceMethods dict_as_sequence = { + 0, /* sq_length */ + 0, /* sq_concat */ + 0, /* sq_repeat */ + 0, /* sq_item */ + 0, /* sq_slice */ + 0, /* sq_ass_item */ + 0, /* sq_ass_slice */ + PyDict_Contains, /* sq_contains */ + 0, /* sq_inplace_concat */ + 0, /* sq_inplace_repeat */ +}; + +static PyObject * +dict_new(PyTypeObject *type, PyObject *args, PyObject *kwds) +{ + PyObject *self; + PyDictObject *d; + + assert(type != NULL && type->tp_alloc != NULL); + self = type->tp_alloc(type, 0); + if (self == NULL) + return NULL; + d = (PyDictObject *)self; + + /* The object has been implicitly tracked by tp_alloc */ + if (type == &PyDict_Type) + _PyObject_GC_UNTRACK(d); + + d->ma_used = 0; + d->ma_keys = new_keys_object(PyDict_MINSIZE_COMBINED); + if (d->ma_keys == NULL) { + Py_DECREF(self); + return NULL; + } + return self; +} + +static int +dict_init(PyObject *self, PyObject *args, PyObject *kwds) +{ + return dict_update_common(self, args, kwds, "dict"); +} + +static PyObject * +dict_iter(PyDictObject *dict) +{ + return dictiter_new(dict, &PyDictIterKey_Type); +} + +PyDoc_STRVAR(dictionary_doc, +"dict() -> new empty dictionary\n" +"dict(mapping) -> new dictionary initialized from a mapping object's\n" +" (key, value) pairs\n" +"dict(iterable) -> new dictionary initialized as if via:\n" +" d = {}\n" +" for k, v in iterable:\n" +" d[k] = v\n" +"dict(**kwargs) -> new dictionary initialized with the name=value pairs\n" +" in the keyword argument list. For example: dict(one=1, two=2)"); + +PyTypeObject PyDict_Type = { + PyVarObject_HEAD_INIT(&PyType_Type, 0) + "dict", + sizeof(PyDictObject), + 0, + (destructor)dict_dealloc, /* tp_dealloc */ + 0, /* tp_print */ + 0, /* tp_getattr */ + 0, /* tp_setattr */ + 0, /* tp_reserved */ + (reprfunc)dict_repr, /* tp_repr */ + 0, /* tp_as_number */ + &dict_as_sequence, /* tp_as_sequence */ + &dict_as_mapping, /* tp_as_mapping */ + PyObject_HashNotImplemented, /* tp_hash */ + 0, /* tp_call */ + 0, /* tp_str */ + PyObject_GenericGetAttr, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | + Py_TPFLAGS_BASETYPE | Py_TPFLAGS_DICT_SUBCLASS, /* tp_flags */ + dictionary_doc, /* tp_doc */ + dict_traverse, /* tp_traverse */ + dict_tp_clear, /* tp_clear */ + dict_richcompare, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + (getiterfunc)dict_iter, /* tp_iter */ + 0, /* tp_iternext */ + mapp_methods, /* tp_methods */ + 0, /* tp_members */ + 0, /* tp_getset */ + 0, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + dict_init, /* tp_init */ + PyType_GenericAlloc, /* tp_alloc */ + dict_new, /* tp_new */ + PyObject_GC_Del, /* tp_free */ +}; + +PyObject * +_PyDict_GetItemId(PyObject *dp, struct _Py_Identifier *key) +{ + PyObject *kv; + kv = _PyUnicode_FromId(key); /* borrowed */ + if (kv == NULL) { + PyErr_Clear(); + return NULL; + } + return PyDict_GetItem(dp, kv); +} + +/* For backward compatibility with old dictionary interface */ + +PyObject * +PyDict_GetItemString(PyObject *v, const char *key) +{ + PyObject *kv, *rv; + kv = PyUnicode_FromString(key); + if (kv == NULL) { + PyErr_Clear(); + return NULL; + } + rv = PyDict_GetItem(v, kv); + Py_DECREF(kv); + return rv; +} + +int +_PyDict_SetItemId(PyObject *v, struct _Py_Identifier *key, PyObject *item) +{ + PyObject *kv; + kv = _PyUnicode_FromId(key); /* borrowed */ + if (kv == NULL) + return -1; + return PyDict_SetItem(v, kv, item); +} + +int +PyDict_SetItemString(PyObject *v, const char *key, PyObject *item) +{ + PyObject *kv; + int err; + kv = PyUnicode_FromString(key); + if (kv == NULL) + return -1; + PyUnicode_InternInPlace(&kv); /* XXX Should we really? */ + err = PyDict_SetItem(v, kv, item); + Py_DECREF(kv); + return err; +} + +int +_PyDict_DelItemId(PyObject *v, _Py_Identifier *key) +{ + PyObject *kv = _PyUnicode_FromId(key); /* borrowed */ + if (kv == NULL) + return -1; + return PyDict_DelItem(v, kv); +} + +int +PyDict_DelItemString(PyObject *v, const char *key) +{ + PyObject *kv; + int err; + kv = PyUnicode_FromString(key); + if (kv == NULL) + return -1; + err = PyDict_DelItem(v, kv); + Py_DECREF(kv); + return err; +} + +/* Dictionary iterator types */ + +typedef struct { + PyObject_HEAD + PyDictObject *di_dict; /* Set to NULL when iterator is exhausted */ + Py_ssize_t di_used; + Py_ssize_t di_pos; + PyObject* di_result; /* reusable result tuple for iteritems */ + Py_ssize_t len; +} dictiterobject; + +static PyObject * +dictiter_new(PyDictObject *dict, PyTypeObject *itertype) +{ + dictiterobject *di; + di = PyObject_GC_New(dictiterobject, itertype); + if (di == NULL) + return NULL; + Py_INCREF(dict); + di->di_dict = dict; + di->di_used = dict->ma_used; + di->di_pos = 0; + di->len = dict->ma_used; + if (itertype == &PyDictIterItem_Type) { + di->di_result = PyTuple_Pack(2, Py_None, Py_None); + if (di->di_result == NULL) { + Py_DECREF(di); + return NULL; + } + } + else + di->di_result = NULL; + _PyObject_GC_TRACK(di); + return (PyObject *)di; +} + +static void +dictiter_dealloc(dictiterobject *di) +{ + Py_XDECREF(di->di_dict); + Py_XDECREF(di->di_result); + PyObject_GC_Del(di); +} + +static int +dictiter_traverse(dictiterobject *di, visitproc visit, void *arg) +{ + Py_VISIT(di->di_dict); + Py_VISIT(di->di_result); + return 0; +} + +static PyObject * +dictiter_len(dictiterobject *di) +{ + Py_ssize_t len = 0; + if (di->di_dict != NULL && di->di_used == di->di_dict->ma_used) + len = di->len; + return PyLong_FromSize_t(len); +} + +PyDoc_STRVAR(length_hint_doc, + "Private method returning an estimate of len(list(it))."); + +static PyObject * +dictiter_reduce(dictiterobject *di); + +PyDoc_STRVAR(reduce_doc, "Return state information for pickling."); + +static PyMethodDef dictiter_methods[] = { + {"__length_hint__", (PyCFunction)dictiter_len, METH_NOARGS, + length_hint_doc}, + {"__reduce__", (PyCFunction)dictiter_reduce, METH_NOARGS, + reduce_doc}, + {NULL, NULL} /* sentinel */ +}; + +static PyObject *dictiter_iternextkey(dictiterobject *di) +{ + PyObject *key; + Py_ssize_t i, mask, offset; + PyDictKeysObject *k; + PyDictObject *d = di->di_dict; + PyObject **value_ptr; + + if (d == NULL) + return NULL; + assert (PyDict_Check(d)); + + if (di->di_used != d->ma_used) { + PyErr_SetString(PyExc_RuntimeError, + "dictionary changed size during iteration"); + di->di_used = -1; /* Make this state sticky */ + return NULL; + } + + i = di->di_pos; + if (i < 0) + goto fail; + k = d->ma_keys; + if (d->ma_values) { + value_ptr = &d->ma_values[i]; + offset = sizeof(PyObject *); + } + else { + value_ptr = &k->dk_entries[i].me_value; + offset = sizeof(PyDictKeyEntry); + } + mask = DK_SIZE(k)-1; + while (i <= mask && *value_ptr == NULL) { + value_ptr = (PyObject **)(((char *)value_ptr) + offset); + i++; + } + di->di_pos = i+1; + if (i > mask) + goto fail; + di->len--; + key = k->dk_entries[i].me_key; + Py_INCREF(key); + return key; + +fail: + Py_DECREF(d); + di->di_dict = NULL; + return NULL; +} + +PyTypeObject PyDictIterKey_Type = { + PyVarObject_HEAD_INIT(&PyType_Type, 0) + "dict_keyiterator", /* tp_name */ + sizeof(dictiterobject), /* tp_basicsize */ + 0, /* tp_itemsize */ + /* methods */ + (destructor)dictiter_dealloc, /* tp_dealloc */ + 0, /* tp_print */ + 0, /* tp_getattr */ + 0, /* tp_setattr */ + 0, /* tp_reserved */ + 0, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + 0, /* tp_str */ + PyObject_GenericGetAttr, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */ + 0, /* tp_doc */ + (traverseproc)dictiter_traverse, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + PyObject_SelfIter, /* tp_iter */ + (iternextfunc)dictiter_iternextkey, /* tp_iternext */ + dictiter_methods, /* tp_methods */ + 0, +}; + +static PyObject *dictiter_iternextvalue(dictiterobject *di) +{ + PyObject *value; + Py_ssize_t i, mask, offset; + PyDictObject *d = di->di_dict; + PyObject **value_ptr; + + if (d == NULL) + return NULL; + assert (PyDict_Check(d)); + + if (di->di_used != d->ma_used) { + PyErr_SetString(PyExc_RuntimeError, + "dictionary changed size during iteration"); + di->di_used = -1; /* Make this state sticky */ + return NULL; + } + + i = di->di_pos; + mask = DK_SIZE(d->ma_keys)-1; + if (i < 0 || i > mask) + goto fail; + if (d->ma_values) { + value_ptr = &d->ma_values[i]; + offset = sizeof(PyObject *); + } + else { + value_ptr = &d->ma_keys->dk_entries[i].me_value; + offset = sizeof(PyDictKeyEntry); + } + while (i <= mask && *value_ptr == NULL) { + value_ptr = (PyObject **)(((char *)value_ptr) + offset); + i++; + if (i > mask) + goto fail; + } + di->di_pos = i+1; + di->len--; + value = *value_ptr; + Py_INCREF(value); + return value; + +fail: + Py_DECREF(d); + di->di_dict = NULL; + return NULL; +} + +PyTypeObject PyDictIterValue_Type = { + PyVarObject_HEAD_INIT(&PyType_Type, 0) + "dict_valueiterator", /* tp_name */ + sizeof(dictiterobject), /* tp_basicsize */ + 0, /* tp_itemsize */ + /* methods */ + (destructor)dictiter_dealloc, /* tp_dealloc */ + 0, /* tp_print */ + 0, /* tp_getattr */ + 0, /* tp_setattr */ + 0, /* tp_reserved */ + 0, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + 0, /* tp_str */ + PyObject_GenericGetAttr, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */ + 0, /* tp_doc */ + (traverseproc)dictiter_traverse, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + PyObject_SelfIter, /* tp_iter */ + (iternextfunc)dictiter_iternextvalue, /* tp_iternext */ + dictiter_methods, /* tp_methods */ + 0, +}; + +static PyObject *dictiter_iternextitem(dictiterobject *di) +{ + PyObject *key, *value, *result = di->di_result; + Py_ssize_t i, mask, offset; + PyDictObject *d = di->di_dict; + PyObject **value_ptr; + + if (d == NULL) + return NULL; + assert (PyDict_Check(d)); + + if (di->di_used != d->ma_used) { + PyErr_SetString(PyExc_RuntimeError, + "dictionary changed size during iteration"); + di->di_used = -1; /* Make this state sticky */ + return NULL; + } + + i = di->di_pos; + if (i < 0) + goto fail; + mask = DK_SIZE(d->ma_keys)-1; + if (d->ma_values) { + value_ptr = &d->ma_values[i]; + offset = sizeof(PyObject *); + } + else { + value_ptr = &d->ma_keys->dk_entries[i].me_value; + offset = sizeof(PyDictKeyEntry); + } + while (i <= mask && *value_ptr == NULL) { + value_ptr = (PyObject **)(((char *)value_ptr) + offset); + i++; + } + di->di_pos = i+1; + if (i > mask) + goto fail; + + if (result->ob_refcnt == 1) { + Py_INCREF(result); + Py_DECREF(PyTuple_GET_ITEM(result, 0)); + Py_DECREF(PyTuple_GET_ITEM(result, 1)); + } else { + result = PyTuple_New(2); + if (result == NULL) + return NULL; + } + di->len--; + key = d->ma_keys->dk_entries[i].me_key; + value = *value_ptr; + Py_INCREF(key); + Py_INCREF(value); + PyTuple_SET_ITEM(result, 0, key); + PyTuple_SET_ITEM(result, 1, value); + return result; + +fail: + Py_DECREF(d); + di->di_dict = NULL; + return NULL; +} + +PyTypeObject PyDictIterItem_Type = { + PyVarObject_HEAD_INIT(&PyType_Type, 0) + "dict_itemiterator", /* tp_name */ + sizeof(dictiterobject), /* tp_basicsize */ + 0, /* tp_itemsize */ + /* methods */ + (destructor)dictiter_dealloc, /* tp_dealloc */ + 0, /* tp_print */ + 0, /* tp_getattr */ + 0, /* tp_setattr */ + 0, /* tp_reserved */ + 0, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + 0, /* tp_str */ + PyObject_GenericGetAttr, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */ + 0, /* tp_doc */ + (traverseproc)dictiter_traverse, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + PyObject_SelfIter, /* tp_iter */ + (iternextfunc)dictiter_iternextitem, /* tp_iternext */ + dictiter_methods, /* tp_methods */ + 0, +}; + + +static PyObject * +dictiter_reduce(dictiterobject *di) +{ + PyObject *list; + dictiterobject tmp; + + list = PyList_New(0); + if (!list) + return NULL; + + /* copy the itertor state */ + tmp = *di; + Py_XINCREF(tmp.di_dict); + + /* iterate the temporary into a list */ + for(;;) { + PyObject *element = 0; + if (Py_TYPE(di) == &PyDictIterItem_Type) + element = dictiter_iternextitem(&tmp); + else if (Py_TYPE(di) == &PyDictIterKey_Type) + element = dictiter_iternextkey(&tmp); + else if (Py_TYPE(di) == &PyDictIterValue_Type) + element = dictiter_iternextvalue(&tmp); + else + assert(0); + if (element) { + if (PyList_Append(list, element)) { + Py_DECREF(element); + Py_DECREF(list); + Py_XDECREF(tmp.di_dict); + return NULL; + } + Py_DECREF(element); + } else + break; + } + Py_XDECREF(tmp.di_dict); + /* check for error */ + if (tmp.di_dict != NULL) { + /* we have an error */ + Py_DECREF(list); + return NULL; + } + return Py_BuildValue("N(N)", _PyObject_GetBuiltin("iter"), list); +} + +/***********************************************/ +/* View objects for keys(), items(), values(). */ +/***********************************************/ + +/* The instance lay-out is the same for all three; but the type differs. */ + +typedef struct { + PyObject_HEAD + PyDictObject *dv_dict; +} dictviewobject; + + +static void +dictview_dealloc(dictviewobject *dv) +{ + Py_XDECREF(dv->dv_dict); + PyObject_GC_Del(dv); +} + +static int +dictview_traverse(dictviewobject *dv, visitproc visit, void *arg) +{ + Py_VISIT(dv->dv_dict); + return 0; +} + +static Py_ssize_t +dictview_len(dictviewobject *dv) +{ + Py_ssize_t len = 0; + if (dv->dv_dict != NULL) + len = dv->dv_dict->ma_used; + return len; +} + +static PyObject * +dictview_new(PyObject *dict, PyTypeObject *type) +{ + dictviewobject *dv; + if (dict == NULL) { + PyErr_BadInternalCall(); + return NULL; + } + if (!PyDict_Check(dict)) { + /* XXX Get rid of this restriction later */ + PyErr_Format(PyExc_TypeError, + "%s() requires a dict argument, not '%s'", + type->tp_name, dict->ob_type->tp_name); + return NULL; + } + dv = PyObject_GC_New(dictviewobject, type); + if (dv == NULL) + return NULL; + Py_INCREF(dict); + dv->dv_dict = (PyDictObject *)dict; + _PyObject_GC_TRACK(dv); + return (PyObject *)dv; +} + +/* TODO(guido): The views objects are not complete: + + * support more set operations + * support arbitrary mappings? + - either these should be static or exported in dictobject.h + - if public then they should probably be in builtins +*/ + +/* Return 1 if self is a subset of other, iterating over self; + 0 if not; -1 if an error occurred. */ +static int +all_contained_in(PyObject *self, PyObject *other) +{ + PyObject *iter = PyObject_GetIter(self); + int ok = 1; + + if (iter == NULL) + return -1; + for (;;) { + PyObject *next = PyIter_Next(iter); + if (next == NULL) { + if (PyErr_Occurred()) + ok = -1; + break; + } + ok = PySequence_Contains(other, next); + Py_DECREF(next); + if (ok <= 0) + break; + } + Py_DECREF(iter); + return ok; +} + +static PyObject * +dictview_richcompare(PyObject *self, PyObject *other, int op) +{ + Py_ssize_t len_self, len_other; + int ok; + PyObject *result; + + assert(self != NULL); + assert(PyDictViewSet_Check(self)); + assert(other != NULL); + + if (!PyAnySet_Check(other) && !PyDictViewSet_Check(other)) + Py_RETURN_NOTIMPLEMENTED; + + len_self = PyObject_Size(self); + if (len_self < 0) + return NULL; + len_other = PyObject_Size(other); + if (len_other < 0) + return NULL; + + ok = 0; + switch(op) { + + case Py_NE: + case Py_EQ: + if (len_self == len_other) + ok = all_contained_in(self, other); + if (op == Py_NE && ok >= 0) + ok = !ok; + break; + + case Py_LT: + if (len_self < len_other) + ok = all_contained_in(self, other); + break; + + case Py_LE: + if (len_self <= len_other) + ok = all_contained_in(self, other); + break; + + case Py_GT: + if (len_self > len_other) + ok = all_contained_in(other, self); + break; + + case Py_GE: + if (len_self >= len_other) + ok = all_contained_in(other, self); + break; + + } + if (ok < 0) + return NULL; + result = ok ? Py_True : Py_False; + Py_INCREF(result); + return result; +} + +static PyObject * +dictview_repr(dictviewobject *dv) +{ + PyObject *seq; + PyObject *result; + + seq = PySequence_List((PyObject *)dv); + if (seq == NULL) + return NULL; + + result = PyUnicode_FromFormat("%s(%R)", Py_TYPE(dv)->tp_name, seq); + Py_DECREF(seq); + return result; +} + +/*** dict_keys ***/ + +static PyObject * +dictkeys_iter(dictviewobject *dv) +{ + if (dv->dv_dict == NULL) { + Py_RETURN_NONE; + } + return dictiter_new(dv->dv_dict, &PyDictIterKey_Type); +} + +static int +dictkeys_contains(dictviewobject *dv, PyObject *obj) +{ + if (dv->dv_dict == NULL) + return 0; + return PyDict_Contains((PyObject *)dv->dv_dict, obj); +} + +static PySequenceMethods dictkeys_as_sequence = { + (lenfunc)dictview_len, /* sq_length */ + 0, /* sq_concat */ + 0, /* sq_repeat */ + 0, /* sq_item */ + 0, /* sq_slice */ + 0, /* sq_ass_item */ + 0, /* sq_ass_slice */ + (objobjproc)dictkeys_contains, /* sq_contains */ +}; + +static PyObject* +dictviews_sub(PyObject* self, PyObject *other) +{ + PyObject *result = PySet_New(self); + PyObject *tmp; + _Py_IDENTIFIER(difference_update); + + if (result == NULL) + return NULL; + + tmp = _PyObject_CallMethodId(result, &PyId_difference_update, "O", other); + if (tmp == NULL) { + Py_DECREF(result); + return NULL; + } + + Py_DECREF(tmp); + return result; +} + +PyObject* +_PyDictView_Intersect(PyObject* self, PyObject *other) +{ + PyObject *result = PySet_New(self); + PyObject *tmp; + _Py_IDENTIFIER(intersection_update); + + if (result == NULL) + return NULL; + + tmp = _PyObject_CallMethodId(result, &PyId_intersection_update, "O", other); + if (tmp == NULL) { + Py_DECREF(result); + return NULL; + } + + Py_DECREF(tmp); + return result; +} + +static PyObject* +dictviews_or(PyObject* self, PyObject *other) +{ + PyObject *result = PySet_New(self); + PyObject *tmp; + _Py_IDENTIFIER(update); + + if (result == NULL) + return NULL; + + tmp = _PyObject_CallMethodId(result, &PyId_update, "O", other); + if (tmp == NULL) { + Py_DECREF(result); + return NULL; + } + + Py_DECREF(tmp); + return result; +} + +static PyObject* +dictviews_xor(PyObject* self, PyObject *other) +{ + PyObject *result = PySet_New(self); + PyObject *tmp; + _Py_IDENTIFIER(symmetric_difference_update); + + if (result == NULL) + return NULL; + + tmp = _PyObject_CallMethodId(result, &PyId_symmetric_difference_update, "O", + other); + if (tmp == NULL) { + Py_DECREF(result); + return NULL; + } + + Py_DECREF(tmp); + return result; +} + +static PyNumberMethods dictviews_as_number = { + 0, /*nb_add*/ + (binaryfunc)dictviews_sub, /*nb_subtract*/ + 0, /*nb_multiply*/ + 0, /*nb_remainder*/ + 0, /*nb_divmod*/ + 0, /*nb_power*/ + 0, /*nb_negative*/ + 0, /*nb_positive*/ + 0, /*nb_absolute*/ + 0, /*nb_bool*/ + 0, /*nb_invert*/ + 0, /*nb_lshift*/ + 0, /*nb_rshift*/ + (binaryfunc)_PyDictView_Intersect, /*nb_and*/ + (binaryfunc)dictviews_xor, /*nb_xor*/ + (binaryfunc)dictviews_or, /*nb_or*/ +}; + +static PyObject* +dictviews_isdisjoint(PyObject *self, PyObject *other) +{ + PyObject *it; + PyObject *item = NULL; + + if (self == other) { + if (dictview_len((dictviewobject *)self) == 0) + Py_RETURN_TRUE; + else + Py_RETURN_FALSE; + } + + /* Iterate over the shorter object (only if other is a set, + * because PySequence_Contains may be expensive otherwise): */ + if (PyAnySet_Check(other) || PyDictViewSet_Check(other)) { + Py_ssize_t len_self = dictview_len((dictviewobject *)self); + Py_ssize_t len_other = PyObject_Size(other); + if (len_other == -1) + return NULL; + + if ((len_other > len_self)) { + PyObject *tmp = other; + other = self; + self = tmp; + } + } + + it = PyObject_GetIter(other); + if (it == NULL) + return NULL; + + while ((item = PyIter_Next(it)) != NULL) { + int contains = PySequence_Contains(self, item); + Py_DECREF(item); + if (contains == -1) { + Py_DECREF(it); + return NULL; + } + + if (contains) { + Py_DECREF(it); + Py_RETURN_FALSE; + } + } + Py_DECREF(it); + if (PyErr_Occurred()) + return NULL; /* PyIter_Next raised an exception. */ + Py_RETURN_TRUE; +} + +PyDoc_STRVAR(isdisjoint_doc, +"Return True if the view and the given iterable have a null intersection."); + +static PyMethodDef dictkeys_methods[] = { + {"isdisjoint", (PyCFunction)dictviews_isdisjoint, METH_O, + isdisjoint_doc}, + {NULL, NULL} /* sentinel */ +}; + +PyTypeObject PyDictKeys_Type = { + PyVarObject_HEAD_INIT(&PyType_Type, 0) + "dict_keys", /* tp_name */ + sizeof(dictviewobject), /* tp_basicsize */ + 0, /* tp_itemsize */ + /* methods */ + (destructor)dictview_dealloc, /* tp_dealloc */ + 0, /* tp_print */ + 0, /* tp_getattr */ + 0, /* tp_setattr */ + 0, /* tp_reserved */ + (reprfunc)dictview_repr, /* tp_repr */ + &dictviews_as_number, /* tp_as_number */ + &dictkeys_as_sequence, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + 0, /* tp_str */ + PyObject_GenericGetAttr, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */ + 0, /* tp_doc */ + (traverseproc)dictview_traverse, /* tp_traverse */ + 0, /* tp_clear */ + dictview_richcompare, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + (getiterfunc)dictkeys_iter, /* tp_iter */ + 0, /* tp_iternext */ + dictkeys_methods, /* tp_methods */ + 0, +}; + +static PyObject * +dictkeys_new(PyObject *dict) +{ + return dictview_new(dict, &PyDictKeys_Type); +} + +/*** dict_items ***/ + +static PyObject * +dictitems_iter(dictviewobject *dv) +{ + if (dv->dv_dict == NULL) { + Py_RETURN_NONE; + } + return dictiter_new(dv->dv_dict, &PyDictIterItem_Type); +} + +static int +dictitems_contains(dictviewobject *dv, PyObject *obj) +{ + PyObject *key, *value, *found; + if (dv->dv_dict == NULL) + return 0; + if (!PyTuple_Check(obj) || PyTuple_GET_SIZE(obj) != 2) + return 0; + key = PyTuple_GET_ITEM(obj, 0); + value = PyTuple_GET_ITEM(obj, 1); + found = PyDict_GetItem((PyObject *)dv->dv_dict, key); + if (found == NULL) { + if (PyErr_Occurred()) + return -1; + return 0; + } + return PyObject_RichCompareBool(value, found, Py_EQ); +} + +static PySequenceMethods dictitems_as_sequence = { + (lenfunc)dictview_len, /* sq_length */ + 0, /* sq_concat */ + 0, /* sq_repeat */ + 0, /* sq_item */ + 0, /* sq_slice */ + 0, /* sq_ass_item */ + 0, /* sq_ass_slice */ + (objobjproc)dictitems_contains, /* sq_contains */ +}; + +static PyMethodDef dictitems_methods[] = { + {"isdisjoint", (PyCFunction)dictviews_isdisjoint, METH_O, + isdisjoint_doc}, + {NULL, NULL} /* sentinel */ +}; + +PyTypeObject PyDictItems_Type = { + PyVarObject_HEAD_INIT(&PyType_Type, 0) + "dict_items", /* tp_name */ + sizeof(dictviewobject), /* tp_basicsize */ + 0, /* tp_itemsize */ + /* methods */ + (destructor)dictview_dealloc, /* tp_dealloc */ + 0, /* tp_print */ + 0, /* tp_getattr */ + 0, /* tp_setattr */ + 0, /* tp_reserved */ + (reprfunc)dictview_repr, /* tp_repr */ + &dictviews_as_number, /* tp_as_number */ + &dictitems_as_sequence, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + 0, /* tp_str */ + PyObject_GenericGetAttr, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */ + 0, /* tp_doc */ + (traverseproc)dictview_traverse, /* tp_traverse */ + 0, /* tp_clear */ + dictview_richcompare, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + (getiterfunc)dictitems_iter, /* tp_iter */ + 0, /* tp_iternext */ + dictitems_methods, /* tp_methods */ + 0, +}; + +static PyObject * +dictitems_new(PyObject *dict) +{ + return dictview_new(dict, &PyDictItems_Type); +} + +/*** dict_values ***/ + +static PyObject * +dictvalues_iter(dictviewobject *dv) +{ + if (dv->dv_dict == NULL) { + Py_RETURN_NONE; + } + return dictiter_new(dv->dv_dict, &PyDictIterValue_Type); +} + +static PySequenceMethods dictvalues_as_sequence = { + (lenfunc)dictview_len, /* sq_length */ + 0, /* sq_concat */ + 0, /* sq_repeat */ + 0, /* sq_item */ + 0, /* sq_slice */ + 0, /* sq_ass_item */ + 0, /* sq_ass_slice */ + (objobjproc)0, /* sq_contains */ +}; + +static PyMethodDef dictvalues_methods[] = { + {NULL, NULL} /* sentinel */ +}; + +PyTypeObject PyDictValues_Type = { + PyVarObject_HEAD_INIT(&PyType_Type, 0) + "dict_values", /* tp_name */ + sizeof(dictviewobject), /* tp_basicsize */ + 0, /* tp_itemsize */ + /* methods */ + (destructor)dictview_dealloc, /* tp_dealloc */ + 0, /* tp_print */ + 0, /* tp_getattr */ + 0, /* tp_setattr */ + 0, /* tp_reserved */ + (reprfunc)dictview_repr, /* tp_repr */ + 0, /* tp_as_number */ + &dictvalues_as_sequence, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + 0, /* tp_str */ + PyObject_GenericGetAttr, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */ + 0, /* tp_doc */ + (traverseproc)dictview_traverse, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + (getiterfunc)dictvalues_iter, /* tp_iter */ + 0, /* tp_iternext */ + dictvalues_methods, /* tp_methods */ + 0, +}; + +static PyObject * +dictvalues_new(PyObject *dict) +{ + return dictview_new(dict, &PyDictValues_Type); +} + +/* Returns NULL if cannot allocate a new PyDictKeysObject, + but does not set an error */ +PyDictKeysObject * +_PyDict_NewKeysForClass(void) +{ + PyDictKeysObject *keys = new_keys_object(PyDict_MINSIZE_SPLIT); + if (keys == NULL) + PyErr_Clear(); + else + keys->dk_lookup = lookdict_split; + return keys; +} + +#define CACHED_KEYS(tp) (((PyHeapTypeObject*)tp)->ht_cached_keys) + +PyObject * +PyObject_GenericGetDict(PyObject *obj, void *context) +{ + PyObject *dict, **dictptr = _PyObject_GetDictPtr(obj); + if (dictptr == NULL) { + PyErr_SetString(PyExc_AttributeError, + "This object has no __dict__"); + return NULL; + } + dict = *dictptr; + if (dict == NULL) { + PyTypeObject *tp = Py_TYPE(obj); + if ((tp->tp_flags & Py_TPFLAGS_HEAPTYPE) && CACHED_KEYS(tp)) { + DK_INCREF(CACHED_KEYS(tp)); + *dictptr = dict = new_dict_with_shared_keys(CACHED_KEYS(tp)); + } + else { + *dictptr = dict = PyDict_New(); + } + } + Py_XINCREF(dict); + return dict; +} + +int +_PyObjectDict_SetItem(PyTypeObject *tp, PyObject **dictptr, + PyObject *key, PyObject *value) +{ + PyObject *dict; + int res; + PyDictKeysObject *cached; + + assert(dictptr != NULL); + if ((tp->tp_flags & Py_TPFLAGS_HEAPTYPE) && (cached = CACHED_KEYS(tp))) { + assert(dictptr != NULL); + dict = *dictptr; + if (dict == NULL) { + DK_INCREF(cached); + dict = new_dict_with_shared_keys(cached); + if (dict == NULL) + return -1; + *dictptr = dict; + } + if (value == NULL) { + res = PyDict_DelItem(dict, key); + if (cached != ((PyDictObject *)dict)->ma_keys) { + CACHED_KEYS(tp) = NULL; + DK_DECREF(cached); + } + } else { + res = PyDict_SetItem(dict, key, value); + if (cached != ((PyDictObject *)dict)->ma_keys) { + /* Either update tp->ht_cached_keys or delete it */ + if (cached->dk_refcnt == 1) { + CACHED_KEYS(tp) = make_keys_shared(dict); + } else { + CACHED_KEYS(tp) = NULL; + } + DK_DECREF(cached); + if (CACHED_KEYS(tp) == NULL && PyErr_Occurred()) + return -1; + } + } + } else { + dict = *dictptr; + if (dict == NULL) { + dict = PyDict_New(); + if (dict == NULL) + return -1; + *dictptr = dict; + } + if (value == NULL) { + res = PyDict_DelItem(dict, key); + } else { + res = PyDict_SetItem(dict, key, value); + } + } + return res; +} + +void +_PyDictKeys_DecRef(PyDictKeysObject *keys) +{ + DK_DECREF(keys); +} + + +/* ARGSUSED */ +static PyObject * +dummy_repr(PyObject *op) +{ + return PyUnicode_FromString(""); +} + +/* ARGUSED */ +static void +dummy_dealloc(PyObject* ignore) +{ + /* This should never get called, but we also don't want to SEGV if + * we accidentally decref dummy-key out of existence. + */ + Py_FatalError("deallocating "); +} + +static PyTypeObject PyDictDummy_Type = { + PyVarObject_HEAD_INIT(&PyType_Type, 0) + " type", + 0, + 0, + dummy_dealloc, /*tp_dealloc*/ /*never called*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_reserved*/ + dummy_repr, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash */ + 0, /*tp_call */ + 0, /*tp_str */ + 0, /*tp_getattro */ + 0, /*tp_setattro */ + 0, /*tp_as_buffer */ + Py_TPFLAGS_DEFAULT, /*tp_flags */ +}; + +static PyObject _dummy_struct = { + _PyObject_EXTRA_INIT + 2, &PyDictDummy_Type +}; + diff -r 9a0caf6e7a16 Objects/dictobject.c --- a/Objects/dictobject.c Tue Apr 07 01:30:33 2015 -0400 +++ b/Objects/dictobject.c Tue Apr 07 06:17:38 2015 -0400 @@ -3412,8 +3412,8 @@ return result; } -static PyObject* -dictviews_and(PyObject* self, PyObject *other) +PyObject* +_PyDictView_Intersect(PyObject* self, PyObject *other) { PyObject *result = PySet_New(self); PyObject *tmp; @@ -3487,7 +3487,7 @@ 0, /*nb_invert*/ 0, /*nb_lshift*/ 0, /*nb_rshift*/ - (binaryfunc)dictviews_and, /*nb_and*/ + (binaryfunc)_PyDictView_Intersect, /*nb_and*/ (binaryfunc)dictviews_xor, /*nb_xor*/ (binaryfunc)dictviews_or, /*nb_or*/ }; diff -r 9a0caf6e7a16 Parser/Python.asdl --- a/Parser/Python.asdl Tue Apr 07 01:30:33 2015 -0400 +++ b/Parser/Python.asdl Tue Apr 07 06:17:38 2015 -0400 @@ -14,8 +14,6 @@ | ClassDef(identifier name, expr* bases, keyword* keywords, - expr? starargs, - expr? kwargs, stmt* body, expr* decorator_list) | Return(expr? value) @@ -64,8 +62,7 @@ -- need sequences for compare to distinguish between -- x < 4 < 3 and (x < 4) < 3 | Compare(expr left, cmpop* ops, expr* comparators) - | Call(expr func, expr* args, keyword* keywords, - expr? starargs, expr? kwargs) + | Call(expr func, expr* args, keyword* keywords) | Num(object n) -- a number as a PyObject. | Str(string s) -- need to specify raw, unicode, etc? | Bytes(bytes s) @@ -109,8 +106,8 @@ arg = (identifier arg, expr? annotation) attributes (int lineno, int col_offset) - -- keyword arguments supplied to call - keyword = (identifier arg, expr value) + -- keyword arguments supplied to call (NULL identifier for **kwargs) + keyword = (identifier? arg, expr value) -- import name with optional 'as' alias. alias = (identifier name, identifier? asname) diff -r 9a0caf6e7a16 Python/Python-ast.c --- a/Python/Python-ast.c Tue Apr 07 01:30:33 2015 -0400 +++ b/Python/Python-ast.c Tue Apr 07 06:17:38 2015 -0400 @@ -48,14 +48,10 @@ static PyTypeObject *ClassDef_type; _Py_IDENTIFIER(bases); _Py_IDENTIFIER(keywords); -_Py_IDENTIFIER(starargs); -_Py_IDENTIFIER(kwargs); static char *ClassDef_fields[]={ "name", "bases", "keywords", - "starargs", - "kwargs", "body", "decorator_list", }; @@ -254,8 +250,6 @@ "func", "args", "keywords", - "starargs", - "kwargs", }; static PyTypeObject *Num_type; _Py_IDENTIFIER(n); @@ -812,7 +806,7 @@ FunctionDef_type = make_type("FunctionDef", stmt_type, FunctionDef_fields, 5); if (!FunctionDef_type) return 0; - ClassDef_type = make_type("ClassDef", stmt_type, ClassDef_fields, 7); + ClassDef_type = make_type("ClassDef", stmt_type, ClassDef_fields, 5); if (!ClassDef_type) return 0; Return_type = make_type("Return", stmt_type, Return_fields, 1); if (!Return_type) return 0; @@ -884,7 +878,7 @@ if (!YieldFrom_type) return 0; Compare_type = make_type("Compare", expr_type, Compare_fields, 3); if (!Compare_type) return 0; - Call_type = make_type("Call", expr_type, Call_fields, 5); + Call_type = make_type("Call", expr_type, Call_fields, 3); if (!Call_type) return 0; Num_type = make_type("Num", expr_type, Num_fields, 1); if (!Num_type) return 0; @@ -1207,9 +1201,9 @@ } stmt_ty -ClassDef(identifier name, asdl_seq * bases, asdl_seq * keywords, expr_ty - starargs, expr_ty kwargs, asdl_seq * body, asdl_seq * decorator_list, - int lineno, int col_offset, PyArena *arena) +ClassDef(identifier name, asdl_seq * bases, asdl_seq * keywords, asdl_seq * + body, asdl_seq * decorator_list, int lineno, int col_offset, PyArena + *arena) { stmt_ty p; if (!name) { @@ -1224,8 +1218,6 @@ p->v.ClassDef.name = name; p->v.ClassDef.bases = bases; p->v.ClassDef.keywords = keywords; - p->v.ClassDef.starargs = starargs; - p->v.ClassDef.kwargs = kwargs; p->v.ClassDef.body = body; p->v.ClassDef.decorator_list = decorator_list; p->lineno = lineno; @@ -1885,8 +1877,8 @@ } expr_ty -Call(expr_ty func, asdl_seq * args, asdl_seq * keywords, expr_ty starargs, - expr_ty kwargs, int lineno, int col_offset, PyArena *arena) +Call(expr_ty func, asdl_seq * args, asdl_seq * keywords, int lineno, int + col_offset, PyArena *arena) { expr_ty p; if (!func) { @@ -1901,8 +1893,6 @@ p->v.Call.func = func; p->v.Call.args = args; p->v.Call.keywords = keywords; - p->v.Call.starargs = starargs; - p->v.Call.kwargs = kwargs; p->lineno = lineno; p->col_offset = col_offset; return p; @@ -2276,11 +2266,6 @@ keyword(identifier arg, expr_ty value, PyArena *arena) { keyword_ty p; - if (!arg) { - PyErr_SetString(PyExc_ValueError, - "field arg is required for keyword"); - return NULL; - } if (!value) { PyErr_SetString(PyExc_ValueError, "field value is required for keyword"); @@ -2442,16 +2427,6 @@ if (_PyObject_SetAttrId(result, &PyId_keywords, value) == -1) goto failed; Py_DECREF(value); - value = ast2obj_expr(o->v.ClassDef.starargs); - if (!value) goto failed; - if (_PyObject_SetAttrId(result, &PyId_starargs, value) == -1) - goto failed; - Py_DECREF(value); - value = ast2obj_expr(o->v.ClassDef.kwargs); - if (!value) goto failed; - if (_PyObject_SetAttrId(result, &PyId_kwargs, value) == -1) - goto failed; - Py_DECREF(value); value = ast2obj_list(o->v.ClassDef.body, ast2obj_stmt); if (!value) goto failed; if (_PyObject_SetAttrId(result, &PyId_body, value) == -1) @@ -2964,16 +2939,6 @@ if (_PyObject_SetAttrId(result, &PyId_keywords, value) == -1) goto failed; Py_DECREF(value); - value = ast2obj_expr(o->v.Call.starargs); - if (!value) goto failed; - if (_PyObject_SetAttrId(result, &PyId_starargs, value) == -1) - goto failed; - Py_DECREF(value); - value = ast2obj_expr(o->v.Call.kwargs); - if (!value) goto failed; - if (_PyObject_SetAttrId(result, &PyId_kwargs, value) == -1) - goto failed; - Py_DECREF(value); break; case Num_kind: result = PyType_GenericNew(Num_type, NULL, NULL); @@ -3875,8 +3840,6 @@ identifier name; asdl_seq* bases; asdl_seq* keywords; - expr_ty starargs; - expr_ty kwargs; asdl_seq* body; asdl_seq* decorator_list; @@ -3939,26 +3902,6 @@ PyErr_SetString(PyExc_TypeError, "required field \"keywords\" missing from ClassDef"); return 1; } - if (exists_not_none(obj, &PyId_starargs)) { - int res; - tmp = _PyObject_GetAttrId(obj, &PyId_starargs); - if (tmp == NULL) goto failed; - res = obj2ast_expr(tmp, &starargs, arena); - if (res != 0) goto failed; - Py_CLEAR(tmp); - } else { - starargs = NULL; - } - if (exists_not_none(obj, &PyId_kwargs)) { - int res; - tmp = _PyObject_GetAttrId(obj, &PyId_kwargs); - if (tmp == NULL) goto failed; - res = obj2ast_expr(tmp, &kwargs, arena); - if (res != 0) goto failed; - Py_CLEAR(tmp); - } else { - kwargs = NULL; - } if (_PyObject_HasAttrId(obj, &PyId_body)) { int res; Py_ssize_t len; @@ -4007,8 +3950,8 @@ PyErr_SetString(PyExc_TypeError, "required field \"decorator_list\" missing from ClassDef"); return 1; } - *out = ClassDef(name, bases, keywords, starargs, kwargs, body, - decorator_list, lineno, col_offset, arena); + *out = ClassDef(name, bases, keywords, body, decorator_list, lineno, + col_offset, arena); if (*out == NULL) goto failed; return 0; } @@ -5506,8 +5449,6 @@ expr_ty func; asdl_seq* args; asdl_seq* keywords; - expr_ty starargs; - expr_ty kwargs; if (_PyObject_HasAttrId(obj, &PyId_func)) { int res; @@ -5568,28 +5509,7 @@ PyErr_SetString(PyExc_TypeError, "required field \"keywords\" missing from Call"); return 1; } - if (exists_not_none(obj, &PyId_starargs)) { - int res; - tmp = _PyObject_GetAttrId(obj, &PyId_starargs); - if (tmp == NULL) goto failed; - res = obj2ast_expr(tmp, &starargs, arena); - if (res != 0) goto failed; - Py_CLEAR(tmp); - } else { - starargs = NULL; - } - if (exists_not_none(obj, &PyId_kwargs)) { - int res; - tmp = _PyObject_GetAttrId(obj, &PyId_kwargs); - if (tmp == NULL) goto failed; - res = obj2ast_expr(tmp, &kwargs, arena); - if (res != 0) goto failed; - Py_CLEAR(tmp); - } else { - kwargs = NULL; - } - *out = Call(func, args, keywords, starargs, kwargs, lineno, col_offset, - arena); + *out = Call(func, args, keywords, lineno, col_offset, arena); if (*out == NULL) goto failed; return 0; } @@ -6737,7 +6657,7 @@ identifier arg; expr_ty value; - if (_PyObject_HasAttrId(obj, &PyId_arg)) { + if (exists_not_none(obj, &PyId_arg)) { int res; tmp = _PyObject_GetAttrId(obj, &PyId_arg); if (tmp == NULL) goto failed; @@ -6745,8 +6665,7 @@ if (res != 0) goto failed; Py_CLEAR(tmp); } else { - PyErr_SetString(PyExc_TypeError, "required field \"arg\" missing from keyword"); - return 1; + arg = NULL; } if (_PyObject_HasAttrId(obj, &PyId_value)) { int res; diff -r 9a0caf6e7a16 Python/ast.c --- a/Python/ast.c Tue Apr 07 01:30:33 2015 -0400 +++ b/Python/ast.c Tue Apr 07 06:17:38 2015 -0400 @@ -235,9 +235,7 @@ case Call_kind: return validate_expr(exp->v.Call.func, Load) && validate_exprs(exp->v.Call.args, Load, 0) && - validate_keywords(exp->v.Call.keywords) && - (!exp->v.Call.starargs || validate_expr(exp->v.Call.starargs, Load)) && - (!exp->v.Call.kwargs || validate_expr(exp->v.Call.kwargs, Load)); + validate_keywords(exp->v.Call.keywords); case Num_kind: { PyObject *n = exp->v.Num.n; if (!PyLong_CheckExact(n) && !PyFloat_CheckExact(n) && @@ -322,9 +320,7 @@ return validate_body(stmt->v.ClassDef.body, "ClassDef") && validate_exprs(stmt->v.ClassDef.bases, Load, 0) && validate_keywords(stmt->v.ClassDef.keywords) && - validate_exprs(stmt->v.ClassDef.decorator_list, Load, 0) && - (!stmt->v.ClassDef.starargs || validate_expr(stmt->v.ClassDef.starargs, Load)) && - (!stmt->v.ClassDef.kwargs || validate_expr(stmt->v.ClassDef.kwargs, Load)); + validate_exprs(stmt->v.ClassDef.decorator_list, Load, 0); case Return_kind: return !stmt->v.Return.value || validate_expr(stmt->v.Return.value, Load); case Delete_kind: @@ -848,7 +844,8 @@ }; static int -forbidden_name(struct compiling *c, identifier name, const node *n, int full_checks) +forbidden_name(struct compiling *c, identifier name, const node *n, + int full_checks) { assert(PyUnicode_Check(name)); if (PyUnicode_CompareWithASCIIString(name, "__debug__") == 0) { @@ -1445,7 +1442,7 @@ name_expr = NULL; } else if (NCH(n) == 5) { /* Call with no arguments */ - d = Call(name_expr, NULL, NULL, NULL, NULL, LINENO(n), + d = Call(name_expr, NULL, NULL, LINENO(n), n->n_col_offset, c->c_arena); if (!d) return NULL; @@ -1735,16 +1732,22 @@ static expr_ty ast_for_itercomp(struct compiling *c, const node *n, int type) { - /* testlist_comp: test ( comp_for | (',' test)* [','] ) - argument: [test '='] test [comp_for] # Really [keyword '='] test */ + /* testlist_comp: (test|star_expr) + * ( comp_for | (',' (test|star_expr))* [','] ) */ expr_ty elt; asdl_seq *comps; + node *ch; assert(NCH(n) > 1); - elt = ast_for_expr(c, CHILD(n, 0)); + ch = CHILD(n, 0); + elt = ast_for_expr(c, ch); if (!elt) return NULL; + if (elt->kind == Starred_kind) { + ast_error(c, ch, "iterable unpacking cannot be used in comprehension"); + return NULL; + } comps = ast_for_comprehension(c, CHILD(n, 1)); if (!comps) @@ -1761,23 +1764,61 @@ return NULL; } +/* Fills in the key, value pair corresponding to the dict element. In case + * of an unpacking, key is NULL. *i is advanced by the number of ast + * elements. Iff successful, nonzero is returned. + */ +static int +ast_for_dictelement(struct compiling *c, const node *n, int *i, + expr_ty *key, expr_ty *value) +{ + expr_ty expression; + if (TYPE(CHILD(n, *i)) == DOUBLESTAR) { + assert(NCH(n) - *i >= 2); + + expression = ast_for_expr(c, CHILD(n, *i + 1)); + if (!expression) + return 0; + *key = NULL; + *value = expression; + + *i += 2; + } + else { + assert(NCH(n) - *i >= 3); + + expression = ast_for_expr(c, CHILD(n, *i)); + if (!expression) + return 0; + *key = expression; + + REQ(CHILD(n, *i + 1), COLON); + + expression = ast_for_expr(c, CHILD(n, *i + 2)); + if (!expression) + return 0; + *value = expression; + + *i += 3; + } + return 1; +} + static expr_ty ast_for_dictcomp(struct compiling *c, const node *n) { expr_ty key, value; asdl_seq *comps; - - assert(NCH(n) > 3); - REQ(CHILD(n, 1), COLON); - - key = ast_for_expr(c, CHILD(n, 0)); - if (!key) + int i; + + i = 0; + + if (!ast_for_dictelement(c, n, &i, &key, &value)) return NULL; - value = ast_for_expr(c, CHILD(n, 2)); - if (!value) - return NULL; - - comps = ast_for_comprehension(c, CHILD(n, 3)); + assert(key); + assert(NCH(n) - i >= 1); + + comps = ast_for_comprehension(c, CHILD(n, i)); if (!comps) return NULL; @@ -1785,6 +1826,39 @@ } static expr_ty +ast_for_dictdisplay(struct compiling *c, const node *n) +{ + int i; + int j; + int size; + asdl_seq *keys, *values; + + size = (NCH(n) + 1) / 3; /* +1 in case no trailing comma */ + keys = _Py_asdl_seq_new(size, c->c_arena); + if (!keys) + return NULL; + + values = _Py_asdl_seq_new(size, c->c_arena); + if (!values) + return NULL; + + j = 0; + for (i = 0; i < NCH(n); i++) { + expr_ty key, value; + + if (!ast_for_dictelement(c, n, &i, &key, &value)) + return NULL; + asdl_seq_SET(keys, j, key); + asdl_seq_SET(values, j, value); + + j++; + } + keys->size = j; + values->size = j; + return Dict(keys, values, LINENO(n), n->n_col_offset, c->c_arena); +} + +static expr_ty ast_for_genexp(struct compiling *c, const node *n) { assert(TYPE(n) == (testlist_comp) || TYPE(n) == (argument)); @@ -1805,6 +1879,27 @@ return ast_for_itercomp(c, n, COMP_SETCOMP); } +static expr_ty +ast_for_setdisplay(struct compiling *c, const node *n) +{ + int i; + int size; + asdl_seq *elts; + + assert(TYPE(n) == (dictorsetmaker)); + size = (NCH(n) + 1) / 2; /* +1 in case no trailing comma */ + elts = _Py_asdl_seq_new(size, c->c_arena); + if (!elts) + return NULL; + for (i = 0; i < NCH(n); i += 2) { + expr_ty expression; + expression = ast_for_expr(c, CHILD(n, i)); + if (!expression) + return NULL; + asdl_seq_SET(elts, i / 2, expression); + } + return Set(elts, LINENO(n), n->n_col_offset, c->c_arena); +} static expr_ty ast_for_atom(struct compiling *c, const node *n) @@ -1915,62 +2010,42 @@ else return ast_for_listcomp(c, ch); case LBRACE: { - /* dictorsetmaker: test ':' test (',' test ':' test)* [','] | - * test (gen_for | (',' test)* [',']) */ - int i, size; - asdl_seq *keys, *values; - + /* dictorsetmaker: ( ((test ':' test | '**' test) + * (comp_for | (',' (test ':' test | '**' test))* [','])) | + * ((test | '*' test) + * (comp_for | (',' (test | '*' test))* [','])) ) */ ch = CHILD(n, 1); if (TYPE(ch) == RBRACE) { - /* it's an empty dict */ + /* It's an empty dict. */ return Dict(NULL, NULL, LINENO(n), n->n_col_offset, c->c_arena); - } else if (NCH(ch) == 1 || TYPE(CHILD(ch, 1)) == COMMA) { - /* it's a simple set */ - asdl_seq *elts; - size = (NCH(ch) + 1) / 2; /* +1 in case no trailing comma */ - elts = _Py_asdl_seq_new(size, c->c_arena); - if (!elts) - return NULL; - for (i = 0; i < NCH(ch); i += 2) { - expr_ty expression; - expression = ast_for_expr(c, CHILD(ch, i)); - if (!expression) + } + else { + int is_dict = (TYPE(CHILD(ch, 0)) == DOUBLESTAR); + if (NCH(ch) == 1 || + (NCH(ch) > 1 && + TYPE(CHILD(ch, 1)) == COMMA)) { + /* It's a set display. */ + return ast_for_setdisplay(c, ch); + } + else if (NCH(ch) > 1 && + TYPE(CHILD(ch, 1)) == comp_for) { + /* It's a set comprehension. */ + return ast_for_setcomp(c, ch); + } + else if (NCH(ch) > 3 - is_dict && + TYPE(CHILD(ch, 3 - is_dict)) == comp_for) { + /* It's a dictionary comprehension. */ + if (is_dict) { + ast_error(c, n, "dict unpacking cannot be used in " + "dict comprehension"); return NULL; - asdl_seq_SET(elts, i / 2, expression); + } + return ast_for_dictcomp(c, ch); } - return Set(elts, LINENO(n), n->n_col_offset, c->c_arena); - } else if (TYPE(CHILD(ch, 1)) == comp_for) { - /* it's a set comprehension */ - return ast_for_setcomp(c, ch); - } else if (NCH(ch) > 3 && TYPE(CHILD(ch, 3)) == comp_for) { - return ast_for_dictcomp(c, ch); - } else { - /* it's a dict */ - size = (NCH(ch) + 1) / 4; /* +1 in case no trailing comma */ - keys = _Py_asdl_seq_new(size, c->c_arena); - if (!keys) - return NULL; - - values = _Py_asdl_seq_new(size, c->c_arena); - if (!values) - return NULL; - - for (i = 0; i < NCH(ch); i += 4) { - expr_ty expression; - - expression = ast_for_expr(c, CHILD(ch, i)); - if (!expression) - return NULL; - - asdl_seq_SET(keys, i / 4, expression); - - expression = ast_for_expr(c, CHILD(ch, i + 2)); - if (!expression) - return NULL; - - asdl_seq_SET(values, i / 4, expression); + else { + /* It's a dictionary display. */ + return ast_for_dictdisplay(c, ch); } - return Dict(keys, values, LINENO(n), n->n_col_offset, c->c_arena); } } default: @@ -2106,7 +2181,7 @@ REQ(n, trailer); if (TYPE(CHILD(n, 0)) == LPAR) { if (NCH(n) == 2) - return Call(left_expr, NULL, NULL, NULL, NULL, LINENO(n), + return Call(left_expr, NULL, NULL, LINENO(n), n->n_col_offset, c->c_arena); else return ast_for_call(c, CHILD(n, 1), left_expr); @@ -2415,15 +2490,14 @@ ast_for_call(struct compiling *c, const node *n, expr_ty func) { /* - arglist: (argument ',')* (argument [',']| '*' test [',' '**' test] - | '**' test) - argument: [test '='] (test) [comp_for] # Really [keyword '='] test + arglist: argument (',' argument)* [','] + argument: ( test [comp_for] | '*' test | test '=' test | '**' test ) */ int i, nargs, nkeywords, ngens; + int ndoublestars; asdl_seq *args; asdl_seq *keywords; - expr_ty vararg = NULL, kwarg = NULL; REQ(n, arglist); @@ -2437,7 +2511,10 @@ nargs++; else if (TYPE(CHILD(ch, 1)) == comp_for) ngens++; + else if (TYPE(CHILD(ch, 0)) == STAR) + nargs++; else + /* TYPE(CHILD(ch, 0)) == DOUBLESTAR or keyword argument */ nkeywords++; } } @@ -2458,41 +2535,82 @@ keywords = _Py_asdl_seq_new(nkeywords, c->c_arena); if (!keywords) return NULL; - nargs = 0; - nkeywords = 0; + + nargs = 0; /* positional arguments + iterable argument unpackings */ + nkeywords = 0; /* keyword arguments + keyword argument unpackings */ + ndoublestars = 0; /* just keyword argument unpackings */ for (i = 0; i < NCH(n); i++) { node *ch = CHILD(n, i); if (TYPE(ch) == argument) { expr_ty e; + node *chch = CHILD(ch, 0); if (NCH(ch) == 1) { - if (nkeywords) { - ast_error(c, CHILD(ch, 0), - "non-keyword arg after keyword arg"); - return NULL; + if (TYPE(chch) == star_expr) { + /* an iterable argument unpacking */ + expr_ty starred; + if (ndoublestars) { + ast_error(c, chch, + "iterable argument unpacking follows " + "keyword argument unpacking"); + return NULL; + } + e = ast_for_expr(c, CHILD(chch, 1)); + if (!e) + return NULL; + starred = Starred(e, Load, LINENO(chch), + chch->n_col_offset, + c->c_arena); + if (!starred) + return NULL; + asdl_seq_SET(args, nargs++, starred); } - if (vararg) { - ast_error(c, CHILD(ch, 0), - "only named arguments may follow *expression"); - return NULL; + else { + /* a positional argument */ + if (nkeywords) { + if (ndoublestars) { + ast_error(c, chch, + "positional argument follows " + "keyword argument unpacking"); + } + else { + ast_error(c, chch, + "positional argument follows " + "keyword argument"); + } + return NULL; + } + e = ast_for_expr(c, chch); + if (!e) + return NULL; + asdl_seq_SET(args, nargs++, e); } - e = ast_for_expr(c, CHILD(ch, 0)); + } + else if (TYPE(chch) == DOUBLESTAR) { + /* a keyword argument unpacking */ + keyword_ty kw; + i++; + e = ast_for_expr(c, CHILD(ch, 1)); if (!e) return NULL; - asdl_seq_SET(args, nargs++, e); + kw = keyword(NULL, e, c->c_arena); + asdl_seq_SET(keywords, nkeywords++, kw); + ndoublestars++; } else if (TYPE(CHILD(ch, 1)) == comp_for) { + /* the lone generator expression */ e = ast_for_genexp(c, ch); if (!e) return NULL; asdl_seq_SET(args, nargs++, e); } else { + /* a keyword argument */ keyword_ty kw; identifier key, tmp; int k; - /* CHILD(ch, 0) is test, but must be an identifier? */ - e = ast_for_expr(c, CHILD(ch, 0)); + /* chch is test, but must be an identifier? */ + e = ast_for_expr(c, chch); if (!e) return NULL; /* f(lambda x: x[0] = 3) ends up getting parsed with @@ -2501,19 +2619,24 @@ * then is very confusing. */ if (e->kind == Lambda_kind) { - ast_error(c, CHILD(ch, 0), "lambda cannot contain assignment"); + ast_error(c, chch, + "lambda cannot contain assignment"); return NULL; - } else if (e->kind != Name_kind) { - ast_error(c, CHILD(ch, 0), "keyword can't be an expression"); + } + else if (e->kind != Name_kind) { + ast_error(c, chch, + "keyword can't be an expression"); return NULL; - } else if (forbidden_name(c, e->v.Name.id, ch, 1)) { + } + else if (forbidden_name(c, e->v.Name.id, ch, 1)) { return NULL; } key = e->v.Name.id; for (k = 0; k < nkeywords; k++) { tmp = ((keyword_ty)asdl_seq_GET(keywords, k))->arg; - if (!PyUnicode_Compare(tmp, key)) { - ast_error(c, CHILD(ch, 0), "keyword argument repeated"); + if (tmp && !PyUnicode_Compare(tmp, key)) { + ast_error(c, chch, + "keyword argument repeated"); return NULL; } } @@ -2526,21 +2649,9 @@ asdl_seq_SET(keywords, nkeywords++, kw); } } - else if (TYPE(ch) == STAR) { - vararg = ast_for_expr(c, CHILD(n, i+1)); - if (!vararg) - return NULL; - i++; - } - else if (TYPE(ch) == DOUBLESTAR) { - kwarg = ast_for_expr(c, CHILD(n, i+1)); - if (!kwarg) - return NULL; - i++; - } } - return Call(func, args, keywords, vararg, kwarg, func->lineno, func->col_offset, c->c_arena); + return Call(func, args, keywords, func->lineno, func->col_offset, c->c_arena); } static expr_ty @@ -3520,8 +3631,8 @@ return NULL; if (forbidden_name(c, classname, CHILD(n, 3), 0)) return NULL; - return ClassDef(classname, NULL, NULL, NULL, NULL, s, decorator_seq, - LINENO(n), n->n_col_offset, c->c_arena); + return ClassDef(classname, NULL, NULL, s, decorator_seq, LINENO(n), + n->n_col_offset, c->c_arena); } if (TYPE(CHILD(n, 3)) == RPAR) { /* class NAME '(' ')' ':' suite */ @@ -3533,8 +3644,8 @@ return NULL; if (forbidden_name(c, classname, CHILD(n, 3), 0)) return NULL; - return ClassDef(classname, NULL, NULL, NULL, NULL, s, decorator_seq, - LINENO(n), n->n_col_offset, c->c_arena); + return ClassDef(classname, NULL, NULL, s, decorator_seq, LINENO(n), + n->n_col_offset, c->c_arena); } /* class NAME '(' arglist ')' ':' suite */ @@ -3559,8 +3670,7 @@ if (forbidden_name(c, classname, CHILD(n, 1), 0)) return NULL; - return ClassDef(classname, call->v.Call.args, call->v.Call.keywords, - call->v.Call.starargs, call->v.Call.kwargs, s, + return ClassDef(classname, call->v.Call.args, call->v.Call.keywords, s, decorator_seq, LINENO(n), n->n_col_offset, c->c_arena); } diff -r 9a0caf6e7a16 Python/ceval.c --- a/Python/ceval.c Tue Apr 07 01:30:33 2015 -0400 +++ b/Python/ceval.c Tue Apr 07 06:17:38 2015 -0400 @@ -12,8 +12,10 @@ #include "Python.h" #include "code.h" +#include "dictobject.h" #include "frameobject.h" #include "opcode.h" +#include "setobject.h" #include "structmember.h" #include @@ -2379,6 +2381,59 @@ DISPATCH(); } + TARGET(BUILD_TUPLE_UNPACK) { + int i; + PyObject *sum = PyList_New(0); + PyObject *as_tuple; + if (sum == NULL) + goto error; + + for (i = oparg; i > 0; i--) { + PyObject *none_val; + + none_val = _PyList_Extend((PyListObject *)sum, PEEK(i)); + if (none_val == NULL) { + Py_DECREF(sum); + goto error; + } + Py_DECREF(none_val); + } + + // Convert to tuple + as_tuple = PyList_AsTuple(sum); + Py_DECREF(sum); + if (as_tuple == NULL) + goto error; + + while (oparg--) + Py_DECREF(POP()); + PUSH(as_tuple); + DISPATCH(); + } + + TARGET(BUILD_LIST_UNPACK) { + int i; + PyObject *sum = PyList_New(0); + if (sum == NULL) + goto error; + + for (i = oparg; i > 0; i--) { + PyObject *none_val; + + none_val = _PyList_Extend((PyListObject *)sum, PEEK(i)); + if (none_val == NULL) { + Py_DECREF(sum); + goto error; + } + Py_DECREF(none_val); + } + + while (oparg--) + Py_DECREF(POP()); + PUSH(sum); + DISPATCH(); + } + TARGET(BUILD_SET) { PyObject *set = PySet_New(NULL); int err = 0; @@ -2398,14 +2453,126 @@ DISPATCH(); } + TARGET(BUILD_SET_UNPACK) { + int i; + PyObject *sum = PySet_New(NULL); + if (sum == NULL) + goto error; + + for (i = oparg; i > 0; i--) { + if (_PySet_Update(sum, PEEK(i)) < 0) { + Py_DECREF(sum); + goto error; + } + } + + while (oparg--) + Py_DECREF(POP()); + PUSH(sum); + DISPATCH(); + } + TARGET(BUILD_MAP) { PyObject *map = _PyDict_NewPresized((Py_ssize_t)oparg); if (map == NULL) goto error; + while (--oparg >= 0) { + int err; + PyObject *key = TOP(); + PyObject *value = SECOND(); + STACKADJ(-2); + err = PyDict_SetItem(map, key, value); + Py_DECREF(value); + Py_DECREF(key); + if (err != 0) { + Py_DECREF(map); + goto error; + } + } PUSH(map); DISPATCH(); } + TARGET_WITH_IMPL(BUILD_MAP_UNPACK_WITH_CALL, _build_map_unpack) + TARGET(BUILD_MAP_UNPACK) + _build_map_unpack: { + int with_call = opcode == BUILD_MAP_UNPACK_WITH_CALL; + int num_maps; + int function_location; + int i; + PyObject *sum = PyDict_New(); + if (sum == NULL) + goto error; + if (with_call) { + num_maps = oparg & 0xff; + function_location = (oparg>>8) & 0xff; + } else { + num_maps = oparg; + } + + for (i = num_maps; i > 0; i--) { + PyObject *arg = PEEK(i); + if (with_call) { + PyObject *intersection = _PyDictView_Intersect(sum, arg); + + if (intersection == NULL) { + if (PyErr_ExceptionMatches(PyExc_AttributeError)) { + PyObject *func = ( + PEEK(function_location + num_maps)); + PyErr_Format(PyExc_TypeError, + "%.200s%.200s argument after ** " + "must be a mapping, not %.200s", + PyEval_GetFuncName(func), + PyEval_GetFuncDesc(func), + arg->ob_type->tp_name); + } + Py_DECREF(sum); + goto error; + } + + if (PySet_GET_SIZE(intersection)) { + Py_ssize_t idx = 0; + PyObject *key; + PyObject *func = PEEK(function_location + num_maps); + Py_hash_t hash; + _PySet_NextEntry(intersection, &idx, &key, &hash); + if (!PyUnicode_Check(key)) { + PyErr_Format(PyExc_TypeError, + "%.200s%.200s keywords must be strings", + PyEval_GetFuncName(func), + PyEval_GetFuncDesc(func)); + } else { + PyErr_Format(PyExc_TypeError, + "%.200s%.200s got multiple " + "values for keyword argument '%U'", + PyEval_GetFuncName(func), + PyEval_GetFuncDesc(func), + key); + } + Py_DECREF(intersection); + Py_DECREF(sum); + goto error; + } + Py_DECREF(intersection); + } + + if (PyDict_Update(sum, arg) < 0) { + if (PyErr_ExceptionMatches(PyExc_AttributeError)) { + PyErr_Format(PyExc_TypeError, + "'%.200s' object is not a mapping", + arg->ob_type->tp_name); + } + Py_DECREF(sum); + goto error; + } + } + + while (num_maps--) + Py_DECREF(POP()); + PUSH(sum); + DISPATCH(); + } + TARGET(STORE_MAP) { PyObject *key = TOP(); PyObject *value = SECOND(); @@ -3050,6 +3217,7 @@ goto dispatch_opcode; } + #if USE_COMPUTED_GOTOS _unknown_opcode: #endif @@ -4547,6 +4715,12 @@ kwdict = d; } } + if (nk > 0) { + kwdict = update_keyword_args(kwdict, nk, pp_stack, func); + if (kwdict == NULL) + goto ext_call_fail; + } + if (flags & CALL_FLAG_VAR) { stararg = EXT_POP(*pp_stack); if (!PyTuple_Check(stararg)) { @@ -4568,11 +4742,6 @@ } nstar = PyTuple_GET_SIZE(stararg); } - if (nk > 0) { - kwdict = update_keyword_args(kwdict, nk, pp_stack, func); - if (kwdict == NULL) - goto ext_call_fail; - } callargs = update_star_args(na, nstar, stararg, pp_stack); if (callargs == NULL) goto ext_call_fail; diff -r 9a0caf6e7a16 Python/compile.c --- a/Python/compile.c Tue Apr 07 01:30:33 2015 -0400 +++ b/Python/compile.c Tue Apr 07 06:17:38 2015 -0400 @@ -157,7 +157,7 @@ int c_interactive; /* true if in interactive mode */ int c_nestlevel; - struct compiler_unit *u; /* compiler state for current block */ + struct compiler_unit *u; /* compiler state for current block */ PyObject *c_stack; /* Python list holding compiler_unit ptrs */ PyArena *c_arena; /* pointer to memory allocation arena */ }; @@ -195,9 +195,7 @@ static int compiler_with(struct compiler *, stmt_ty, int); static int compiler_call_helper(struct compiler *c, Py_ssize_t n, asdl_seq *args, - asdl_seq *keywords, - expr_ty starargs, - expr_ty kwargs); + asdl_seq *keywords); static int compiler_try_except(struct compiler *, stmt_ty); static int compiler_set_qualname(struct compiler *); @@ -606,7 +604,10 @@ /* Push the old compiler_unit on the stack. */ if (c->u) { - PyObject *capsule = PyCapsule_New(c->u, COMPILER_CAPSULE_NAME_COMPILER_UNIT, NULL); + PyObject *capsule = PyCapsule_New( + c->u, + COMPILER_CAPSULE_NAME_COMPILER_UNIT, + NULL); if (!capsule || PyList_Append(c->c_stack, capsule) < 0) { Py_XDECREF(capsule); compiler_unit_free(u); @@ -642,7 +643,9 @@ n = PyList_GET_SIZE(c->c_stack) - 1; if (n >= 0) { capsule = PyList_GET_ITEM(c->c_stack, n); - c->u = (struct compiler_unit *)PyCapsule_GetPointer(capsule, COMPILER_CAPSULE_NAME_COMPILER_UNIT); + c->u = (struct compiler_unit *)PyCapsule_GetPointer( + capsule, + COMPILER_CAPSULE_NAME_COMPILER_UNIT); assert(c->u); /* we are deleting from a list so this really shouldn't fail */ if (PySequence_DelItem(c->c_stack, n) < 0) @@ -672,10 +675,12 @@ PyObject *mangled, *capsule; capsule = PyList_GET_ITEM(c->c_stack, stack_size - 1); - parent = (struct compiler_unit *)PyCapsule_GetPointer(capsule, COMPILER_CAPSULE_NAME_COMPILER_UNIT); + parent = (struct compiler_unit *)PyCapsule_GetPointer( + capsule, COMPILER_CAPSULE_NAME_COMPILER_UNIT); assert(parent); - if (u->u_scope_type == COMPILER_SCOPE_FUNCTION || u->u_scope_type == COMPILER_SCOPE_CLASS) { + if (u->u_scope_type == COMPILER_SCOPE_FUNCTION + || u->u_scope_type == COMPILER_SCOPE_CLASS) { assert(u->u_name); mangled = _Py_Mangle(parent->u_private, u->u_name); if (!mangled) @@ -973,6 +978,13 @@ case BUILD_LIST: case BUILD_SET: return 1-oparg; + case BUILD_LIST_UNPACK: + case BUILD_TUPLE_UNPACK: + case BUILD_SET_UNPACK: + case BUILD_MAP_UNPACK: + return 1 - oparg; + case BUILD_MAP_UNPACK_WITH_CALL: + return 1 - (oparg & 0xFF); case BUILD_MAP: return 1; case LOAD_ATTR: @@ -1719,7 +1731,7 @@ { PyCodeObject *co; PyObject *str; - int i; + Py_ssize_t i; asdl_seq* decos = s->v.ClassDef.decorator_list; if (!compiler_decorators(c, decos)) @@ -1821,9 +1833,7 @@ /* 5. generate the rest of the code for the call */ if (!compiler_call_helper(c, 2, s->v.ClassDef.bases, - s->v.ClassDef.keywords, - s->v.ClassDef.starargs, - s->v.ClassDef.kwargs)) + s->v.ClassDef.keywords)) return 0; /* 6. apply decorators */ @@ -2046,7 +2056,7 @@ static const char LOOP_ERROR_MSG[] = "'continue' not properly in loop"; static const char IN_FINALLY_ERROR_MSG[] = "'continue' not supported inside 'finally' clause"; - int i; + Py_ssize_t i; if (!c->u->u_nfblocks) return compiler_error(c, LOOP_ERROR_MSG); @@ -2872,67 +2882,145 @@ } static int +starunpack_helper(struct compiler *c, asdl_seq *elts, + int single_op, int inner_op, int outer_op) +{ + Py_ssize_t n = asdl_seq_LEN(elts); + Py_ssize_t i, nsubitems = 0, nseen = 0; + for (i = 0; i < n; i++) { + expr_ty elt = asdl_seq_GET(elts, i); + if (elt->kind == Starred_kind) { + if (nseen) { + ADDOP_I(c, inner_op, nseen); + nseen = 0; + nsubitems++; + } + VISIT(c, expr, elt->v.Starred.value); + nsubitems++; + } + else { + VISIT(c, expr, elt); + nseen++; + } + } + if (nsubitems) { + if (nseen) { + ADDOP_I(c, inner_op, nseen); + nsubitems++; + } + ADDOP_I(c, outer_op, nsubitems); + } + else + ADDOP_I(c, single_op, nseen); + return 1; +} + +static int +assignment_helper(struct compiler *c, asdl_seq *elts) +{ + Py_ssize_t n = asdl_seq_LEN(elts); + Py_ssize_t i; + int seen_star = 0; + for (i = 0; i < n; i++) { + expr_ty elt = asdl_seq_GET(elts, i); + if (elt->kind == Starred_kind && !seen_star) { + if ((i >= (1 << 8)) || + (n-i-1 >= (INT_MAX >> 8))) + return compiler_error(c, + "too many expressions in " + "star-unpacking assignment"); + ADDOP_I(c, UNPACK_EX, (i + ((n-i-1) << 8))); + seen_star = 1; + asdl_seq_SET(elts, i, elt->v.Starred.value); + } + else if (elt->kind == Starred_kind) { + return compiler_error(c, + "two starred expressions in assignment"); + } + } + if (!seen_star) { + ADDOP_I(c, UNPACK_SEQUENCE, n); + } + VISIT_SEQ(c, expr, elts); + return 1; +} + +static int compiler_list(struct compiler *c, expr_ty e) { - Py_ssize_t n = asdl_seq_LEN(e->v.List.elts); + asdl_seq *elts = e->v.List.elts; if (e->v.List.ctx == Store) { - int i, seen_star = 0; - for (i = 0; i < n; i++) { - expr_ty elt = asdl_seq_GET(e->v.List.elts, i); - if (elt->kind == Starred_kind && !seen_star) { - if ((i >= (1 << 8)) || - (n-i-1 >= (INT_MAX >> 8))) - return compiler_error(c, - "too many expressions in " - "star-unpacking assignment"); - ADDOP_I(c, UNPACK_EX, (i + ((n-i-1) << 8))); - seen_star = 1; - asdl_seq_SET(e->v.List.elts, i, elt->v.Starred.value); - } else if (elt->kind == Starred_kind) { - return compiler_error(c, - "two starred expressions in assignment"); - } - } - if (!seen_star) { - ADDOP_I(c, UNPACK_SEQUENCE, n); - } + return assignment_helper(c, elts); } - VISIT_SEQ(c, expr, e->v.List.elts); - if (e->v.List.ctx == Load) { - ADDOP_I(c, BUILD_LIST, n); + else if (e->v.List.ctx == Load) { + return starunpack_helper(c, elts, + BUILD_LIST, BUILD_TUPLE, BUILD_LIST_UNPACK); } + else + VISIT_SEQ(c, expr, elts); return 1; } static int compiler_tuple(struct compiler *c, expr_ty e) { - Py_ssize_t n = asdl_seq_LEN(e->v.Tuple.elts); + asdl_seq *elts = e->v.Tuple.elts; if (e->v.Tuple.ctx == Store) { - int i, seen_star = 0; - for (i = 0; i < n; i++) { - expr_ty elt = asdl_seq_GET(e->v.Tuple.elts, i); - if (elt->kind == Starred_kind && !seen_star) { - if ((i >= (1 << 8)) || - (n-i-1 >= (INT_MAX >> 8))) - return compiler_error(c, - "too many expressions in " - "star-unpacking assignment"); - ADDOP_I(c, UNPACK_EX, (i + ((n-i-1) << 8))); - seen_star = 1; - asdl_seq_SET(e->v.Tuple.elts, i, elt->v.Starred.value); - } else if (elt->kind == Starred_kind) { - return compiler_error(c, - "two starred expressions in assignment"); - } + return assignment_helper(c, elts); + } + else if (e->v.Tuple.ctx == Load) { + return starunpack_helper(c, elts, + BUILD_TUPLE, BUILD_TUPLE, BUILD_TUPLE_UNPACK); + } + else + VISIT_SEQ(c, expr, elts); + return 1; +} + +static int +compiler_set(struct compiler *c, expr_ty e) +{ + return starunpack_helper(c, e->v.Set.elts, BUILD_SET, + BUILD_SET, BUILD_SET_UNPACK); +} + +static int +compiler_dict(struct compiler *c, expr_ty e) +{ + Py_ssize_t i, n, containers, elements; + int is_unpacking = 0; + n = asdl_seq_LEN(e->v.Dict.values); + containers = 0; + elements = 0; + for (i = 0; i < n; i++) { + is_unpacking = (expr_ty)asdl_seq_GET(e->v.Dict.keys, i) == NULL; + if (elements == 0xFFFF || (elements && is_unpacking)) { + ADDOP_I(c, BUILD_MAP, elements); + containers++; + elements = 0; } - if (!seen_star) { - ADDOP_I(c, UNPACK_SEQUENCE, n); + if (is_unpacking) { + VISIT(c, expr, (expr_ty)asdl_seq_GET(e->v.Dict.values, i)); + containers++; + } + else { + VISIT(c, expr, (expr_ty)asdl_seq_GET(e->v.Dict.values, i)); + VISIT(c, expr, (expr_ty)asdl_seq_GET(e->v.Dict.keys, i)); + elements++; } } - VISIT_SEQ(c, expr, e->v.Tuple.elts); - if (e->v.Tuple.ctx == Load) { - ADDOP_I(c, BUILD_TUPLE, n); + if (elements || containers == 0) { + ADDOP_I(c, BUILD_MAP, elements); + containers++; + } + /* If there is more than one dict, they need to be merged into a new + * dict. If there is one dict and it's an unpacking, then it needs + * to be copied into a new dict." */ + while (containers > 1 || is_unpacking) { + int oparg = containers < 255 ? containers : 255; + ADDOP_I(c, BUILD_MAP_UNPACK, oparg); + containers -= (oparg - 1); + is_unpacking = 0; } return 1; } @@ -2988,9 +3076,7 @@ VISIT(c, expr, e->v.Call.func); return compiler_call_helper(c, 0, e->v.Call.args, - e->v.Call.keywords, - e->v.Call.starargs, - e->v.Call.kwargs); + e->v.Call.keywords); } /* shared code between compiler_call and compiler_class */ @@ -2998,26 +3084,102 @@ compiler_call_helper(struct compiler *c, Py_ssize_t n, /* Args already pushed */ asdl_seq *args, - asdl_seq *keywords, - expr_ty starargs, - expr_ty kwargs) + asdl_seq *keywords) { int code = 0; - - n += asdl_seq_LEN(args); - VISIT_SEQ(c, expr, args); - if (keywords) { - VISIT_SEQ(c, keyword, keywords); - n |= asdl_seq_LEN(keywords) << 8; + Py_ssize_t nelts, i, nseen, nkw; + + /* the number of tuples and dictionaries on the stack */ + Py_ssize_t nsubargs = 0, nsubkwargs = 0; + + nkw = 0; + nseen = 0; /* the number of positional arguments on the stack */ + nelts = asdl_seq_LEN(args); + for (i = 0; i < nelts; i++) { + expr_ty elt = asdl_seq_GET(args, i); + if (elt->kind == Starred_kind) { + /* A star-arg. If we've seen positional arguments, + pack the positional arguments into a + tuple. */ + if (nseen) { + ADDOP_I(c, BUILD_TUPLE, nseen); + nseen = 0; + nsubargs++; + } + VISIT(c, expr, elt->v.Starred.value); + nsubargs++; + } + else if (nsubargs) { + /* We've seen star-args already, so we + count towards items-to-pack-into-tuple. */ + VISIT(c, expr, elt); + nseen++; + } + else { + /* Positional arguments before star-arguments + are left on the stack. */ + VISIT(c, expr, elt); + n++; + } } - if (starargs) { - VISIT(c, expr, starargs); + if (nseen) { + /* Pack up any trailing positional arguments. */ + ADDOP_I(c, BUILD_TUPLE, nseen); + nsubargs++; + } + if (nsubargs) { code |= 1; + if (nsubargs > 1) { + /* If we ended up with more than one stararg, we need + to concatenate them into a single sequence. */ + ADDOP_I(c, BUILD_LIST_UNPACK, nsubargs); + } } - if (kwargs) { - VISIT(c, expr, kwargs); + + /* Same dance again for keyword arguments */ + nseen = 0; /* the number of keyword arguments on the stack following */ + nelts = asdl_seq_LEN(keywords); + for (i = 0; i < nelts; i++) { + keyword_ty kw = asdl_seq_GET(keywords, i); + if (kw->arg == NULL) { + /* A keyword argument unpacking. */ + if (nseen) { + ADDOP_I(c, BUILD_MAP, nseen); + nseen = 0; + nsubkwargs++; + } + VISIT(c, expr, kw->value); + nsubkwargs++; + } + else if (nsubkwargs) { + /* A keyword argument and we already have a dict. */ + VISIT(c, expr, kw->value); + ADDOP_O(c, LOAD_CONST, kw->arg, consts); + nseen++; + } + else { + /* keyword argument */ + VISIT(c, keyword, kw) + nkw++; + } + } + if (nseen) { + /* Pack up any trailing keyword arguments. */ + ADDOP_I(c, BUILD_MAP, nseen); + nsubkwargs++; + } + if (nsubkwargs) { code |= 2; + if (nsubkwargs > 1) { + /* Pack it all up */ + int function_pos = n + (code & 1) + nkw + 1; + ADDOP_I(c, BUILD_MAP_UNPACK_WITH_CALL, nsubkwargs | (function_pos << 8)); + } } + assert(n < 1<<8); + assert(nkw < 1<<24); + n |= nkw << 8; + switch (code) { case 0: ADDOP_I(c, CALL_FUNCTION, n); @@ -3142,8 +3304,9 @@ } static int -compiler_comprehension(struct compiler *c, expr_ty e, int type, identifier name, - asdl_seq *generators, expr_ty elt, expr_ty val) +compiler_comprehension(struct compiler *c, expr_ty e, int type, + identifier name, asdl_seq *generators, expr_ty elt, + expr_ty val) { PyCodeObject *co = NULL; expr_ty outermost_iter; @@ -3400,8 +3563,6 @@ static int compiler_visit_expr(struct compiler *c, expr_ty e) { - Py_ssize_t i, n; - /* If expr e has a different line number than the last expr/stmt, set a new line number for the next instruction. */ @@ -3428,23 +3589,9 @@ case IfExp_kind: return compiler_ifexp(c, e); case Dict_kind: - n = asdl_seq_LEN(e->v.Dict.values); - /* BUILD_MAP parameter is only used to preallocate the dictionary, - it doesn't need to be exact */ - ADDOP_I(c, BUILD_MAP, (n>0xFFFF ? 0xFFFF : n)); - for (i = 0; i < n; i++) { - VISIT(c, expr, - (expr_ty)asdl_seq_GET(e->v.Dict.values, i)); - VISIT(c, expr, - (expr_ty)asdl_seq_GET(e->v.Dict.keys, i)); - ADDOP(c, STORE_MAP); - } - break; + return compiler_dict(c, e); case Set_kind: - n = asdl_seq_LEN(e->v.Set.elts); - VISIT_SEQ(c, expr, e->v.Set.elts); - ADDOP_I(c, BUILD_SET, n); - break; + return compiler_set(c, e); case GeneratorExp_kind: return compiler_genexp(c, e); case ListComp_kind: @@ -3555,7 +3702,7 @@ "starred assignment target must be in a list or tuple"); default: return compiler_error(c, - "can use starred expression only as assignment target"); + "can't use starred expression here"); } break; case Name_kind: diff -r 9a0caf6e7a16 Python/graminit.c --- a/Python/graminit.c Tue Apr 07 01:30:33 2015 -0400 +++ b/Python/graminit.c Tue Apr 07 06:17:38 2015 -0400 @@ -1569,60 +1569,78 @@ {2, arcs_71_1}, {2, arcs_71_2}, }; -static arc arcs_72_0[1] = { +static arc arcs_72_0[3] = { {24, 1}, + {32, 2}, + {48, 3}, }; static arc arcs_72_1[4] = { - {25, 2}, - {159, 3}, - {30, 4}, + {25, 4}, + {159, 5}, + {30, 6}, {0, 1}, }; static arc arcs_72_2[1] = { - {24, 5}, + {104, 7}, }; -static arc arcs_72_3[1] = { +static arc arcs_72_3[3] = { + {159, 5}, + {30, 6}, {0, 3}, }; -static arc arcs_72_4[2] = { - {24, 6}, - {0, 4}, +static arc arcs_72_4[1] = { + {24, 7}, }; -static arc arcs_72_5[3] = { - {159, 3}, - {30, 7}, +static arc arcs_72_5[1] = { {0, 5}, }; -static arc arcs_72_6[2] = { - {30, 4}, +static arc arcs_72_6[3] = { + {24, 8}, + {48, 8}, {0, 6}, }; -static arc arcs_72_7[2] = { - {24, 8}, +static arc arcs_72_7[3] = { + {159, 5}, + {30, 9}, {0, 7}, }; -static arc arcs_72_8[1] = { - {25, 9}, +static arc arcs_72_8[2] = { + {30, 6}, + {0, 8}, }; -static arc arcs_72_9[1] = { +static arc arcs_72_9[3] = { {24, 10}, + {32, 11}, + {0, 9}, }; -static arc arcs_72_10[2] = { - {30, 7}, - {0, 10}, +static arc arcs_72_10[1] = { + {25, 12}, }; -static state states_72[11] = { - {1, arcs_72_0}, +static arc arcs_72_11[1] = { + {104, 13}, +}; +static arc arcs_72_12[1] = { + {24, 13}, +}; +static arc arcs_72_13[2] = { + {30, 9}, + {0, 13}, +}; +static state states_72[14] = { + {3, arcs_72_0}, {4, arcs_72_1}, {1, arcs_72_2}, - {1, arcs_72_3}, - {2, arcs_72_4}, - {3, arcs_72_5}, - {2, arcs_72_6}, - {2, arcs_72_7}, - {1, arcs_72_8}, - {1, arcs_72_9}, - {2, arcs_72_10}, + {3, arcs_72_3}, + {1, arcs_72_4}, + {1, arcs_72_5}, + {3, arcs_72_6}, + {3, arcs_72_7}, + {2, arcs_72_8}, + {3, arcs_72_9}, + {1, arcs_72_10}, + {1, arcs_72_11}, + {1, arcs_72_12}, + {2, arcs_72_13}, }; static arc arcs_73_0[1] = { {163, 1}, @@ -1660,67 +1678,47 @@ {1, arcs_73_6}, {1, arcs_73_7}, }; -static arc arcs_74_0[3] = { +static arc arcs_74_0[1] = { {164, 1}, - {31, 2}, - {32, 3}, }; static arc arcs_74_1[2] = { - {30, 4}, + {30, 2}, {0, 1}, }; -static arc arcs_74_2[1] = { - {24, 5}, +static arc arcs_74_2[2] = { + {164, 1}, + {0, 2}, }; -static arc arcs_74_3[1] = { - {24, 6}, +static state states_74[3] = { + {1, arcs_74_0}, + {2, arcs_74_1}, + {2, arcs_74_2}, }; -static arc arcs_74_4[4] = { - {164, 1}, - {31, 2}, - {32, 3}, - {0, 4}, -}; -static arc arcs_74_5[2] = { - {30, 7}, - {0, 5}, -}; -static arc arcs_74_6[1] = { - {0, 6}, -}; -static arc arcs_74_7[2] = { - {164, 5}, - {32, 3}, -}; -static state states_74[8] = { - {3, arcs_74_0}, - {2, arcs_74_1}, - {1, arcs_74_2}, - {1, arcs_74_3}, - {4, arcs_74_4}, - {2, arcs_74_5}, - {1, arcs_74_6}, - {2, arcs_74_7}, -}; -static arc arcs_75_0[1] = { +static arc arcs_75_0[3] = { {24, 1}, + {32, 2}, + {48, 3}, }; static arc arcs_75_1[3] = { - {159, 2}, - {29, 3}, + {159, 3}, + {29, 4}, {0, 1}, }; static arc arcs_75_2[1] = { - {0, 2}, + {104, 3}, }; static arc arcs_75_3[1] = { - {24, 2}, + {0, 3}, }; -static state states_75[4] = { - {1, arcs_75_0}, +static arc arcs_75_4[1] = { + {24, 3}, +}; +static state states_75[5] = { + {3, arcs_75_0}, {3, arcs_75_1}, {1, arcs_75_2}, {1, arcs_75_3}, + {1, arcs_75_4}, }; static arc arcs_76_0[2] = { {159, 1}, @@ -1964,14 +1962,14 @@ "\000\040\040\200\000\000\000\000\000\000\001\000\000\000\000\000\000\014\241\174\000\000"}, {327, "testlist", 0, 3, states_71, "\000\040\040\000\000\000\000\000\000\000\001\000\000\000\041\000\000\014\241\174\000\000"}, - {328, "dictorsetmaker", 0, 11, states_72, - "\000\040\040\000\000\000\000\000\000\000\001\000\000\000\041\000\000\014\241\174\000\000"}, + {328, "dictorsetmaker", 0, 14, states_72, + "\000\040\040\200\001\000\000\000\000\000\001\000\000\000\041\000\000\014\241\174\000\000"}, {329, "classdef", 0, 8, states_73, "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\010\000"}, - {330, "arglist", 0, 8, states_74, + {330, "arglist", 0, 3, states_74, "\000\040\040\200\001\000\000\000\000\000\001\000\000\000\041\000\000\014\241\174\000\000"}, - {331, "argument", 0, 4, states_75, - "\000\040\040\000\000\000\000\000\000\000\001\000\000\000\041\000\000\014\241\174\000\000"}, + {331, "argument", 0, 5, states_75, + "\000\040\040\200\001\000\000\000\000\000\001\000\000\000\041\000\000\014\241\174\000\000"}, {332, "comp_iter", 0, 2, states_76, "\000\000\000\000\000\000\000\000\000\000\000\040\002\000\000\000\000\000\000\000\000\000"}, {333, "comp_for", 0, 6, states_77, diff -r 9a0caf6e7a16 Python/importlib.h --- a/Python/importlib.h Tue Apr 07 01:30:33 2015 -0400 +++ b/Python/importlib.h Tue Apr 07 06:17:38 2015 -0400 @@ -705,7 +705,7 @@ 4,0,0,0,114,4,0,0,0,114,5,0,0,0,218,25, 95,99,97,108,108,95,119,105,116,104,95,102,114,97,109,101, 115,95,114,101,109,111,118,101,100,57,1,0,0,115,2,0, - 0,0,0,8,114,114,0,0,0,105,248,12,0,0,233,2, + 0,0,0,8,114,114,0,0,0,105,2,13,0,0,233,2, 0,0,0,114,13,0,0,0,115,2,0,0,0,13,10,90, 11,95,95,112,121,99,97,99,104,101,95,95,122,3,46,112, 121,122,4,46,112,121,99,122,4,46,112,121,111,78,99,2, @@ -774,7 +774,7 @@ 114,101,115,116,90,3,116,97,103,218,8,102,105,108,101,110, 97,109,101,114,4,0,0,0,114,4,0,0,0,114,5,0, 0,0,218,17,99,97,99,104,101,95,102,114,111,109,95,115, - 111,117,114,99,101,182,1,0,0,115,22,0,0,0,0,13, + 111,117,114,99,101,178,1,0,0,115,22,0,0,0,0,13, 31,1,6,1,9,2,6,1,18,1,24,1,12,1,12,1, 12,1,43,1,114,132,0,0,0,99,1,0,0,0,0,0, 0,0,5,0,0,0,5,0,0,0,67,0,0,0,115,184, @@ -832,7 +832,7 @@ 97,99,104,101,90,13,98,97,115,101,95,102,105,108,101,110, 97,109,101,114,4,0,0,0,114,4,0,0,0,114,5,0, 0,0,218,17,115,111,117,114,99,101,95,102,114,111,109,95, - 99,97,99,104,101,209,1,0,0,115,24,0,0,0,0,9, + 99,97,99,104,101,205,1,0,0,115,24,0,0,0,0,9, 18,1,12,1,18,1,18,1,12,1,9,1,15,1,21,1, 9,1,12,1,19,1,114,136,0,0,0,99,1,0,0,0, 0,0,0,0,5,0,0,0,12,0,0,0,67,0,0,0, @@ -868,7 +868,7 @@ 0,0,0,90,9,101,120,116,101,110,115,105,111,110,218,11, 115,111,117,114,99,101,95,112,97,116,104,114,4,0,0,0, 114,4,0,0,0,114,5,0,0,0,218,15,95,103,101,116, - 95,115,111,117,114,99,101,102,105,108,101,232,1,0,0,115, + 95,115,111,117,114,99,101,102,105,108,101,228,1,0,0,115, 20,0,0,0,0,7,18,1,4,1,24,1,35,1,4,1, 3,1,16,1,19,1,21,1,114,143,0,0,0,99,1,0, 0,0,0,0,0,0,2,0,0,0,11,0,0,0,67,0, @@ -883,7 +883,7 @@ 128,0,0,0,41,3,114,39,0,0,0,114,41,0,0,0, 114,40,0,0,0,41,2,114,35,0,0,0,114,42,0,0, 0,114,4,0,0,0,114,4,0,0,0,114,5,0,0,0, - 218,10,95,99,97,108,99,95,109,111,100,101,251,1,0,0, + 218,10,95,99,97,108,99,95,109,111,100,101,247,1,0,0, 115,12,0,0,0,0,2,3,1,19,1,13,1,11,3,10, 1,114,145,0,0,0,218,9,118,101,114,98,111,115,105,116, 121,114,29,0,0,0,99,1,0,0,0,1,0,0,0,3, @@ -905,7 +905,7 @@ 109,101,115,115,97,103,101,114,146,0,0,0,114,80,0,0, 0,114,4,0,0,0,114,4,0,0,0,114,5,0,0,0, 218,16,95,118,101,114,98,111,115,101,95,109,101,115,115,97, - 103,101,7,2,0,0,115,8,0,0,0,0,2,18,1,15, + 103,101,3,2,0,0,115,8,0,0,0,0,2,18,1,15, 1,10,1,114,153,0,0,0,99,1,0,0,0,0,0,0, 0,2,0,0,0,4,0,0,0,3,0,0,0,115,38,0, 0,0,100,1,0,135,0,0,102,1,0,100,2,0,100,3, @@ -940,14 +940,14 @@ 67,0,0,0,114,80,0,0,0,114,108,0,0,0,41,1, 218,6,109,101,116,104,111,100,114,4,0,0,0,114,5,0, 0,0,218,19,95,99,104,101,99,107,95,110,97,109,101,95, - 119,114,97,112,112,101,114,23,2,0,0,115,10,0,0,0, + 119,114,97,112,112,101,114,19,2,0,0,115,10,0,0,0, 0,1,12,1,12,1,15,1,22,1,122,40,95,99,104,101, 99,107,95,110,97,109,101,46,60,108,111,99,97,108,115,62, 46,95,99,104,101,99,107,95,110,97,109,101,95,119,114,97, 112,112,101,114,41,1,114,65,0,0,0,41,2,114,155,0, 0,0,114,156,0,0,0,114,4,0,0,0,41,1,114,155, 0,0,0,114,5,0,0,0,218,11,95,99,104,101,99,107, - 95,110,97,109,101,15,2,0,0,115,6,0,0,0,0,8, + 95,110,97,109,101,11,2,0,0,115,6,0,0,0,0,8, 21,6,13,1,114,157,0,0,0,99,1,0,0,0,0,0, 0,0,2,0,0,0,3,0,0,0,3,0,0,0,115,35, 0,0,0,135,0,0,102,1,0,100,1,0,100,2,0,134, @@ -969,7 +969,7 @@ 0,218,8,102,117,108,108,110,97,109,101,41,1,218,3,102, 120,110,114,4,0,0,0,114,5,0,0,0,218,25,95,114, 101,113,117,105,114,101,115,95,98,117,105,108,116,105,110,95, - 119,114,97,112,112,101,114,35,2,0,0,115,8,0,0,0, + 119,114,97,112,112,101,114,31,2,0,0,115,8,0,0,0, 0,1,15,1,18,1,9,1,122,52,95,114,101,113,117,105, 114,101,115,95,98,117,105,108,116,105,110,46,60,108,111,99, 97,108,115,62,46,95,114,101,113,117,105,114,101,115,95,98, @@ -977,7 +977,7 @@ 114,65,0,0,0,41,2,114,160,0,0,0,114,161,0,0, 0,114,4,0,0,0,41,1,114,160,0,0,0,114,5,0, 0,0,218,17,95,114,101,113,117,105,114,101,115,95,98,117, - 105,108,116,105,110,33,2,0,0,115,6,0,0,0,0,2, + 105,108,116,105,110,29,2,0,0,115,6,0,0,0,0,2, 18,5,13,1,114,162,0,0,0,99,1,0,0,0,0,0, 0,0,2,0,0,0,3,0,0,0,3,0,0,0,115,35, 0,0,0,135,0,0,102,1,0,100,1,0,100,2,0,134, @@ -998,14 +998,14 @@ 0,0,114,159,0,0,0,41,1,114,160,0,0,0,114,4, 0,0,0,114,5,0,0,0,218,24,95,114,101,113,117,105, 114,101,115,95,102,114,111,122,101,110,95,119,114,97,112,112, - 101,114,46,2,0,0,115,8,0,0,0,0,1,15,1,18, + 101,114,42,2,0,0,115,8,0,0,0,0,1,15,1,18, 1,9,1,122,50,95,114,101,113,117,105,114,101,115,95,102, 114,111,122,101,110,46,60,108,111,99,97,108,115,62,46,95, 114,101,113,117,105,114,101,115,95,102,114,111,122,101,110,95, 119,114,97,112,112,101,114,41,1,114,65,0,0,0,41,2, 114,160,0,0,0,114,164,0,0,0,114,4,0,0,0,41, 1,114,160,0,0,0,114,5,0,0,0,218,16,95,114,101, - 113,117,105,114,101,115,95,102,114,111,122,101,110,44,2,0, + 113,117,105,114,101,115,95,102,114,111,122,101,110,40,2,0, 0,115,6,0,0,0,0,2,18,5,13,1,114,165,0,0, 0,99,2,0,0,0,0,0,0,0,5,0,0,0,4,0, 0,0,67,0,0,0,115,84,0,0,0,124,0,0,106,0, @@ -1035,7 +1035,7 @@ 8,112,111,114,116,105,111,110,115,218,3,109,115,103,114,4, 0,0,0,114,4,0,0,0,114,5,0,0,0,218,17,95, 102,105,110,100,95,109,111,100,117,108,101,95,115,104,105,109, - 55,2,0,0,115,10,0,0,0,0,10,21,1,24,1,6, + 51,2,0,0,115,10,0,0,0,0,10,21,1,24,1,6, 1,29,1,114,173,0,0,0,99,2,0,0,0,0,0,0, 0,4,0,0,0,3,0,0,0,67,0,0,0,115,81,0, 0,0,116,0,0,124,1,0,124,0,0,131,2,0,125,2, @@ -1058,7 +1058,7 @@ 218,4,115,112,101,99,218,6,109,111,100,117,108,101,114,4, 0,0,0,114,4,0,0,0,114,5,0,0,0,218,17,95, 108,111,97,100,95,109,111,100,117,108,101,95,115,104,105,109, - 73,2,0,0,115,12,0,0,0,0,6,15,1,15,1,13, + 69,2,0,0,115,12,0,0,0,0,6,15,1,15,1,13, 1,13,1,11,2,114,179,0,0,0,99,4,0,0,0,0, 0,0,0,11,0,0,0,19,0,0,0,67,0,0,0,115, 228,1,0,0,105,0,0,125,4,0,124,2,0,100,1,0, @@ -1142,7 +1142,7 @@ 115,111,117,114,99,101,95,115,105,122,101,114,4,0,0,0, 114,4,0,0,0,114,5,0,0,0,218,25,95,118,97,108, 105,100,97,116,101,95,98,121,116,101,99,111,100,101,95,104, - 101,97,100,101,114,88,2,0,0,115,76,0,0,0,0,11, + 101,97,100,101,114,84,2,0,0,115,76,0,0,0,0,11, 6,1,12,1,13,3,6,1,12,1,10,1,16,1,16,1, 16,1,12,1,18,1,10,1,18,1,18,1,15,1,10,1, 15,1,18,1,15,1,10,1,12,1,12,1,3,1,20,1, @@ -1173,7 +1173,7 @@ 114,141,0,0,0,114,142,0,0,0,218,4,99,111,100,101, 114,4,0,0,0,114,4,0,0,0,114,5,0,0,0,218, 17,95,99,111,109,112,105,108,101,95,98,121,116,101,99,111, - 100,101,143,2,0,0,115,16,0,0,0,0,2,15,1,15, + 100,101,139,2,0,0,115,16,0,0,0,0,2,15,1,15, 1,13,1,12,1,16,1,4,2,18,1,114,194,0,0,0, 114,84,0,0,0,99,3,0,0,0,0,0,0,0,4,0, 0,0,3,0,0,0,67,0,0,0,115,76,0,0,0,116, @@ -1193,7 +1193,7 @@ 0,114,182,0,0,0,114,188,0,0,0,114,53,0,0,0, 114,4,0,0,0,114,4,0,0,0,114,5,0,0,0,218, 17,95,99,111,100,101,95,116,111,95,98,121,116,101,99,111, - 100,101,155,2,0,0,115,10,0,0,0,0,3,12,1,19, + 100,101,151,2,0,0,115,10,0,0,0,0,3,12,1,19, 1,19,1,22,1,114,197,0,0,0,99,1,0,0,0,0, 0,0,0,5,0,0,0,4,0,0,0,67,0,0,0,115, 89,0,0,0,100,1,0,100,2,0,108,0,0,125,1,0, @@ -1221,7 +1221,7 @@ 100,108,105,110,101,218,8,101,110,99,111,100,105,110,103,90, 15,110,101,119,108,105,110,101,95,100,101,99,111,100,101,114, 114,4,0,0,0,114,4,0,0,0,114,5,0,0,0,218, - 13,100,101,99,111,100,101,95,115,111,117,114,99,101,165,2, + 13,100,101,99,111,100,101,95,115,111,117,114,99,101,161,2, 0,0,115,10,0,0,0,0,5,12,1,18,1,15,1,18, 1,114,202,0,0,0,99,1,0,0,0,0,0,0,0,5, 0,0,0,35,0,0,0,67,0,0,0,115,6,1,0,0, @@ -1256,7 +1256,7 @@ 114,47,0,0,0,41,5,114,178,0,0,0,114,170,0,0, 0,114,177,0,0,0,114,67,0,0,0,114,131,0,0,0, 114,4,0,0,0,114,4,0,0,0,114,5,0,0,0,218, - 12,95,109,111,100,117,108,101,95,114,101,112,114,179,2,0, + 12,95,109,111,100,117,108,101,95,114,101,112,114,175,2,0, 0,115,46,0,0,0,0,2,18,1,15,4,3,1,17,1, 13,1,5,1,3,1,13,1,13,1,5,2,12,1,10,4, 3,1,13,1,13,1,11,1,3,1,13,1,13,1,12,1, @@ -1273,7 +1273,7 @@ 1,78,41,3,218,7,95,109,111,100,117,108,101,114,207,0, 0,0,218,5,95,115,112,101,99,41,2,114,71,0,0,0, 114,178,0,0,0,114,4,0,0,0,114,4,0,0,0,114, - 5,0,0,0,114,72,0,0,0,217,2,0,0,115,4,0, + 5,0,0,0,114,72,0,0,0,213,2,0,0,115,4,0, 0,0,0,1,9,1,122,26,95,105,110,115,116,97,108,108, 101,100,95,115,97,102,101,108,121,46,95,95,105,110,105,116, 95,95,99,1,0,0,0,0,0,0,0,1,0,0,0,3, @@ -1284,7 +1284,7 @@ 105,110,105,116,105,97,108,105,122,105,110,103,114,213,0,0, 0,114,7,0,0,0,114,73,0,0,0,114,67,0,0,0, 41,1,114,71,0,0,0,114,4,0,0,0,114,4,0,0, - 0,114,5,0,0,0,114,75,0,0,0,221,2,0,0,115, + 0,114,5,0,0,0,114,75,0,0,0,217,2,0,0,115, 4,0,0,0,0,4,12,1,122,27,95,105,110,115,116,97, 108,108,101,100,95,115,97,102,101,108,121,46,95,95,101,110, 116,101,114,95,95,99,1,0,0,0,0,0,0,0,3,0, @@ -1302,7 +1302,7 @@ 0,100,0,0,107,9,0,86,1,113,3,0,100,0,0,83, 41,1,78,114,4,0,0,0,41,2,114,22,0,0,0,114, 76,0,0,0,114,4,0,0,0,114,4,0,0,0,114,5, - 0,0,0,114,77,0,0,0,231,2,0,0,115,2,0,0, + 0,0,0,114,77,0,0,0,227,2,0,0,115,2,0,0, 0,6,0,122,45,95,105,110,115,116,97,108,108,101,100,95, 115,97,102,101,108,121,46,95,95,101,120,105,116,95,95,46, 60,108,111,99,97,108,115,62,46,60,103,101,110,101,120,112, @@ -1312,14 +1312,14 @@ 0,0,114,79,0,0,0,114,153,0,0,0,114,170,0,0, 0,114,215,0,0,0,41,3,114,71,0,0,0,114,80,0, 0,0,114,177,0,0,0,114,4,0,0,0,114,4,0,0, - 0,114,5,0,0,0,114,81,0,0,0,228,2,0,0,115, + 0,114,5,0,0,0,114,81,0,0,0,224,2,0,0,115, 18,0,0,0,0,1,3,1,9,1,25,1,3,1,17,1, 13,1,8,2,26,2,122,26,95,105,110,115,116,97,108,108, 101,100,95,115,97,102,101,108,121,46,95,95,101,120,105,116, 95,95,78,41,6,114,57,0,0,0,114,56,0,0,0,114, 58,0,0,0,114,72,0,0,0,114,75,0,0,0,114,81, 0,0,0,114,4,0,0,0,114,4,0,0,0,114,4,0, - 0,0,114,5,0,0,0,114,212,0,0,0,215,2,0,0, + 0,0,114,5,0,0,0,114,212,0,0,0,211,2,0,0, 115,6,0,0,0,12,2,12,4,12,7,114,212,0,0,0, 99,0,0,0,0,0,0,0,0,0,0,0,0,8,0,0, 0,64,0,0,0,115,172,0,0,0,101,0,0,90,1,0, @@ -1444,7 +1444,7 @@ 104,101,100,41,6,114,71,0,0,0,114,67,0,0,0,114, 170,0,0,0,114,217,0,0,0,114,218,0,0,0,114,219, 0,0,0,114,4,0,0,0,114,4,0,0,0,114,5,0, - 0,0,114,72,0,0,0,23,3,0,0,115,14,0,0,0, + 0,0,114,72,0,0,0,19,3,0,0,115,14,0,0,0, 0,2,9,1,9,1,9,1,9,1,21,3,9,1,122,19, 77,111,100,117,108,101,83,112,101,99,46,95,95,105,110,105, 116,95,95,99,1,0,0,0,0,0,0,0,2,0,0,0, @@ -1468,7 +1468,7 @@ 100,114,220,0,0,0,218,9,95,95,99,108,97,115,115,95, 95,114,57,0,0,0,114,26,0,0,0,41,2,114,71,0, 0,0,114,80,0,0,0,114,4,0,0,0,114,4,0,0, - 0,114,5,0,0,0,114,101,0,0,0,35,3,0,0,115, + 0,114,5,0,0,0,114,101,0,0,0,31,3,0,0,115, 16,0,0,0,0,1,15,1,21,1,15,1,25,1,15,1, 12,1,13,1,122,19,77,111,100,117,108,101,83,112,101,99, 46,95,95,114,101,112,114,95,95,99,2,0,0,0,0,0, @@ -1488,7 +1488,7 @@ 116,105,111,110,114,208,0,0,0,41,3,114,71,0,0,0, 218,5,111,116,104,101,114,218,4,115,109,115,108,114,4,0, 0,0,114,4,0,0,0,114,5,0,0,0,218,6,95,95, - 101,113,95,95,45,3,0,0,115,20,0,0,0,0,1,9, + 101,113,95,95,41,3,0,0,115,20,0,0,0,0,1,9, 1,3,1,18,1,18,1,18,1,15,1,18,1,20,1,13, 1,122,17,77,111,100,117,108,101,83,112,101,99,46,95,95, 101,113,95,95,99,1,0,0,0,0,0,0,0,2,0,0, @@ -1508,7 +1508,7 @@ 0,0,114,123,0,0,0,218,17,66,89,84,69,67,79,68, 69,95,83,85,70,70,73,88,69,83,41,2,114,71,0,0, 0,114,131,0,0,0,114,4,0,0,0,114,4,0,0,0, - 114,5,0,0,0,114,225,0,0,0,57,3,0,0,115,22, + 114,5,0,0,0,114,225,0,0,0,53,3,0,0,115,22, 0,0,0,0,2,15,1,24,1,9,1,21,1,3,1,19, 1,13,1,8,1,21,1,9,1,122,17,77,111,100,117,108, 101,83,112,101,99,46,99,97,99,104,101,100,99,2,0,0, @@ -1516,7 +1516,7 @@ 0,115,13,0,0,0,124,1,0,124,0,0,95,0,0,100, 0,0,83,41,1,78,41,1,114,222,0,0,0,41,2,114, 71,0,0,0,114,225,0,0,0,114,4,0,0,0,114,4, - 0,0,0,114,5,0,0,0,114,225,0,0,0,71,3,0, + 0,0,0,114,5,0,0,0,114,225,0,0,0,67,3,0, 0,115,2,0,0,0,0,2,99,1,0,0,0,0,0,0, 0,1,0,0,0,2,0,0,0,67,0,0,0,115,46,0, 0,0,124,0,0,106,0,0,100,1,0,107,8,0,114,35, @@ -1527,14 +1527,14 @@ 101,110,116,46,78,114,116,0,0,0,114,84,0,0,0,41, 3,114,220,0,0,0,114,67,0,0,0,114,32,0,0,0, 41,1,114,71,0,0,0,114,4,0,0,0,114,4,0,0, - 0,114,5,0,0,0,218,6,112,97,114,101,110,116,75,3, + 0,114,5,0,0,0,218,6,112,97,114,101,110,116,71,3, 0,0,115,6,0,0,0,0,3,15,1,20,2,122,17,77, 111,100,117,108,101,83,112,101,99,46,112,97,114,101,110,116, 99,1,0,0,0,0,0,0,0,1,0,0,0,1,0,0, 0,67,0,0,0,115,7,0,0,0,124,0,0,106,0,0, 83,41,1,78,41,1,114,221,0,0,0,41,1,114,71,0, 0,0,114,4,0,0,0,114,4,0,0,0,114,5,0,0, - 0,114,226,0,0,0,83,3,0,0,115,2,0,0,0,0, + 0,114,226,0,0,0,79,3,0,0,115,2,0,0,0,0, 2,122,23,77,111,100,117,108,101,83,112,101,99,46,104,97, 115,95,108,111,99,97,116,105,111,110,99,2,0,0,0,0, 0,0,0,2,0,0,0,2,0,0,0,67,0,0,0,115, @@ -1542,14 +1542,14 @@ 95,1,0,100,0,0,83,41,1,78,41,2,218,4,98,111, 111,108,114,221,0,0,0,41,2,114,71,0,0,0,218,5, 118,97,108,117,101,114,4,0,0,0,114,4,0,0,0,114, - 5,0,0,0,114,226,0,0,0,87,3,0,0,115,2,0, + 5,0,0,0,114,226,0,0,0,83,3,0,0,115,2,0, 0,0,0,2,41,12,114,57,0,0,0,114,56,0,0,0, 114,58,0,0,0,114,59,0,0,0,114,72,0,0,0,114, 101,0,0,0,114,229,0,0,0,218,8,112,114,111,112,101, 114,116,121,114,225,0,0,0,218,6,115,101,116,116,101,114, 114,233,0,0,0,114,226,0,0,0,114,4,0,0,0,114, 4,0,0,0,114,4,0,0,0,114,5,0,0,0,114,216, - 0,0,0,242,2,0,0,115,20,0,0,0,12,35,6,2, + 0,0,0,238,2,0,0,115,20,0,0,0,12,35,6,2, 15,1,15,11,12,10,12,12,18,14,21,4,18,8,18,4, 114,216,0,0,0,114,217,0,0,0,114,219,0,0,0,99, 2,0,0,0,2,0,0,0,5,0,0,0,15,0,0,0, @@ -1577,7 +1577,7 @@ 0,0,0,41,5,114,67,0,0,0,114,170,0,0,0,114, 217,0,0,0,114,219,0,0,0,90,6,115,101,97,114,99, 104,114,4,0,0,0,114,4,0,0,0,114,5,0,0,0, - 114,174,0,0,0,92,3,0,0,115,28,0,0,0,0,2, + 114,174,0,0,0,88,3,0,0,115,28,0,0,0,0,2, 15,1,12,1,16,1,18,1,15,1,7,2,12,1,15,1, 3,1,19,1,13,1,14,3,6,2,114,174,0,0,0,114, 170,0,0,0,114,220,0,0,0,99,2,0,0,0,2,0, @@ -1637,7 +1637,7 @@ 177,0,0,0,218,12,108,111,97,100,101,114,95,99,108,97, 115,115,114,126,0,0,0,114,219,0,0,0,90,7,100,105, 114,110,97,109,101,114,4,0,0,0,114,4,0,0,0,114, - 5,0,0,0,114,239,0,0,0,117,3,0,0,115,60,0, + 5,0,0,0,114,239,0,0,0,113,3,0,0,115,60,0, 0,0,0,12,12,4,6,1,15,2,3,1,19,1,13,1, 5,8,21,1,9,3,12,1,22,1,21,1,15,1,9,1, 5,2,4,3,12,2,15,1,3,1,19,1,13,1,5,2, @@ -1677,7 +1677,7 @@ 0,0,114,177,0,0,0,114,67,0,0,0,114,242,0,0, 0,114,225,0,0,0,114,220,0,0,0,114,4,0,0,0, 114,4,0,0,0,114,5,0,0,0,218,17,95,115,112,101, - 99,95,102,114,111,109,95,109,111,100,117,108,101,181,3,0, + 99,95,102,114,111,109,95,109,111,100,117,108,101,177,3,0, 0,115,72,0,0,0,0,2,3,1,13,1,13,1,5,2, 12,1,4,2,9,1,12,1,3,1,13,1,13,2,5,1, 3,1,13,1,13,1,11,1,12,1,12,1,3,1,13,1, @@ -1732,7 +1732,7 @@ 41,4,114,177,0,0,0,114,178,0,0,0,114,248,0,0, 0,114,170,0,0,0,114,4,0,0,0,114,4,0,0,0, 114,5,0,0,0,218,18,95,105,110,105,116,95,109,111,100, - 117,108,101,95,97,116,116,114,115,226,3,0,0,115,86,0, + 117,108,101,95,97,116,116,114,115,222,3,0,0,115,86,0, 0,0,0,4,30,1,3,1,16,1,13,1,5,2,30,1, 9,1,12,2,15,1,15,1,12,1,3,1,13,1,13,1, 5,2,30,1,3,1,16,1,13,1,5,2,3,1,13,1, @@ -1766,7 +1766,7 @@ 0,0,114,67,0,0,0,114,253,0,0,0,41,2,114,177, 0,0,0,114,178,0,0,0,114,4,0,0,0,114,4,0, 0,0,114,5,0,0,0,218,16,109,111,100,117,108,101,95, - 102,114,111,109,95,115,112,101,99,26,4,0,0,115,20,0, + 102,114,111,109,95,115,112,101,99,22,4,0,0,115,20,0, 0,0,0,3,6,1,18,3,21,1,18,1,9,2,13,1, 12,1,15,1,13,1,114,1,1,0,0,99,1,0,0,0, 0,0,0,0,2,0,0,0,3,0,0,0,67,0,0,0, @@ -1791,7 +1791,7 @@ 0,0,0,114,217,0,0,0,114,170,0,0,0,114,47,0, 0,0,114,226,0,0,0,41,2,114,177,0,0,0,114,67, 0,0,0,114,4,0,0,0,114,4,0,0,0,114,5,0, - 0,0,114,209,0,0,0,44,4,0,0,115,16,0,0,0, + 0,0,114,209,0,0,0,40,4,0,0,115,16,0,0,0, 0,3,30,1,15,1,15,1,13,2,22,2,9,1,19,2, 114,209,0,0,0,99,2,0,0,0,0,0,0,0,4,0, 0,0,12,0,0,0,67,0,0,0,115,252,0,0,0,124, @@ -1826,7 +1826,7 @@ 11,108,111,97,100,95,109,111,100,117,108,101,114,255,0,0, 0,41,4,114,177,0,0,0,114,178,0,0,0,114,67,0, 0,0,114,172,0,0,0,114,4,0,0,0,114,4,0,0, - 0,114,5,0,0,0,114,175,0,0,0,61,4,0,0,115, + 0,114,5,0,0,0,114,175,0,0,0,57,4,0,0,115, 32,0,0,0,0,2,9,1,10,1,13,1,24,1,15,1, 18,1,15,1,15,1,21,2,19,1,4,1,19,1,18,4, 19,2,22,1,114,175,0,0,0,99,1,0,0,0,0,0, @@ -1857,7 +1857,7 @@ 0,114,178,0,0,0,114,4,0,0,0,114,4,0,0,0, 114,5,0,0,0,218,25,95,108,111,97,100,95,98,97,99, 107,119,97,114,100,95,99,111,109,112,97,116,105,98,108,101, - 86,4,0,0,115,40,0,0,0,0,4,19,2,16,1,24, + 82,4,0,0,115,40,0,0,0,0,4,19,2,16,1,24, 1,3,1,16,1,13,1,5,1,24,1,3,4,12,1,15, 1,29,1,13,1,5,1,24,1,3,1,13,1,13,1,5, 1,114,4,1,0,0,99,1,0,0,0,0,0,0,0,2, @@ -1879,7 +1879,7 @@ 114,67,0,0,0,114,255,0,0,0,114,7,0,0,0,114, 73,0,0,0,41,2,114,177,0,0,0,114,178,0,0,0, 114,4,0,0,0,114,4,0,0,0,114,5,0,0,0,218, - 14,95,108,111,97,100,95,117,110,108,111,99,107,101,100,115, + 14,95,108,111,97,100,95,117,110,108,111,99,107,101,100,111, 4,0,0,115,20,0,0,0,0,2,15,2,18,1,10,2, 12,1,13,1,15,1,15,1,24,3,22,5,114,5,1,0, 0,99,1,0,0,0,0,0,0,0,1,0,0,0,9,0, @@ -1902,7 +1902,7 @@ 106,0,0,0,114,2,1,0,0,114,103,0,0,0,114,67, 0,0,0,114,5,1,0,0,41,1,114,177,0,0,0,114, 4,0,0,0,114,4,0,0,0,114,5,0,0,0,114,176, - 0,0,0,138,4,0,0,115,6,0,0,0,0,9,10,1, + 0,0,0,134,4,0,0,115,6,0,0,0,0,9,10,1, 16,1,114,176,0,0,0,99,4,0,0,0,0,0,0,0, 6,0,0,0,11,0,0,0,67,0,0,0,115,195,0,0, 0,124,0,0,106,0,0,100,1,0,131,1,0,125,4,0, @@ -1927,7 +1927,7 @@ 97,109,101,90,9,99,112,97,116,104,110,97,109,101,114,170, 0,0,0,114,177,0,0,0,114,4,0,0,0,114,4,0, 0,0,114,5,0,0,0,218,14,95,102,105,120,95,117,112, - 95,109,111,100,117,108,101,152,4,0,0,115,34,0,0,0, + 95,109,111,100,117,108,101,148,4,0,0,115,34,0,0,0, 0,2,15,1,15,1,6,1,6,1,12,1,12,1,18,2, 15,1,6,1,21,1,3,1,10,1,10,1,10,1,14,1, 13,2,114,8,1,0,0,99,0,0,0,0,0,0,0,0, @@ -1967,7 +1967,7 @@ 111,100,117,108,101,32,123,33,114,125,32,40,98,117,105,108, 116,45,105,110,41,62,41,2,114,47,0,0,0,114,57,0, 0,0,41,1,114,178,0,0,0,114,4,0,0,0,114,4, - 0,0,0,114,5,0,0,0,114,204,0,0,0,186,4,0, + 0,0,0,114,5,0,0,0,114,204,0,0,0,182,4,0, 0,115,2,0,0,0,0,7,122,27,66,117,105,108,116,105, 110,73,109,112,111,114,116,101,114,46,109,111,100,117,108,101, 95,114,101,112,114,78,99,4,0,0,0,0,0,0,0,4, @@ -1981,7 +1981,7 @@ 174,0,0,0,41,4,218,3,99,108,115,114,159,0,0,0, 114,35,0,0,0,218,6,116,97,114,103,101,116,114,4,0, 0,0,114,4,0,0,0,114,5,0,0,0,218,9,102,105, - 110,100,95,115,112,101,99,195,4,0,0,115,10,0,0,0, + 110,100,95,115,112,101,99,191,4,0,0,115,10,0,0,0, 0,2,12,1,4,1,15,1,19,2,122,25,66,117,105,108, 116,105,110,73,109,112,111,114,116,101,114,46,102,105,110,100, 95,115,112,101,99,99,3,0,0,0,0,0,0,0,4,0, @@ -2003,7 +2003,7 @@ 1,0,0,114,170,0,0,0,41,4,114,10,1,0,0,114, 159,0,0,0,114,35,0,0,0,114,177,0,0,0,114,4, 0,0,0,114,4,0,0,0,114,5,0,0,0,218,11,102, - 105,110,100,95,109,111,100,117,108,101,204,4,0,0,115,4, + 105,110,100,95,109,111,100,117,108,101,200,4,0,0,115,4, 0,0,0,0,9,18,1,122,27,66,117,105,108,116,105,110, 73,109,112,111,114,116,101,114,46,102,105,110,100,95,109,111, 100,117,108,101,99,2,0,0,0,0,0,0,0,3,0,0, @@ -2018,7 +2018,7 @@ 116,95,98,117,105,108,116,105,110,114,203,0,0,0,114,249, 0,0,0,41,3,114,10,1,0,0,114,159,0,0,0,114, 178,0,0,0,114,4,0,0,0,114,4,0,0,0,114,5, - 0,0,0,114,3,1,0,0,216,4,0,0,115,10,0,0, + 0,0,0,114,3,1,0,0,212,4,0,0,115,10,0,0, 0,0,6,13,1,24,1,9,1,9,1,122,27,66,117,105, 108,116,105,110,73,109,112,111,114,116,101,114,46,108,111,97, 100,95,109,111,100,117,108,101,99,2,0,0,0,0,0,0, @@ -2029,7 +2029,7 @@ 32,104,97,118,101,32,99,111,100,101,32,111,98,106,101,99, 116,115,46,78,114,4,0,0,0,41,2,114,10,1,0,0, 114,159,0,0,0,114,4,0,0,0,114,4,0,0,0,114, - 5,0,0,0,218,8,103,101,116,95,99,111,100,101,228,4, + 5,0,0,0,218,8,103,101,116,95,99,111,100,101,224,4, 0,0,115,2,0,0,0,0,4,122,24,66,117,105,108,116, 105,110,73,109,112,111,114,116,101,114,46,103,101,116,95,99, 111,100,101,99,2,0,0,0,0,0,0,0,2,0,0,0, @@ -2040,7 +2040,7 @@ 32,115,111,117,114,99,101,32,99,111,100,101,46,78,114,4, 0,0,0,41,2,114,10,1,0,0,114,159,0,0,0,114, 4,0,0,0,114,4,0,0,0,114,5,0,0,0,218,10, - 103,101,116,95,115,111,117,114,99,101,234,4,0,0,115,2, + 103,101,116,95,115,111,117,114,99,101,230,4,0,0,115,2, 0,0,0,0,4,122,26,66,117,105,108,116,105,110,73,109, 112,111,114,116,101,114,46,103,101,116,95,115,111,117,114,99, 101,99,2,0,0,0,0,0,0,0,2,0,0,0,1,0, @@ -2050,7 +2050,7 @@ 108,101,115,32,97,114,101,32,110,101,118,101,114,32,112,97, 99,107,97,103,101,115,46,70,114,4,0,0,0,41,2,114, 10,1,0,0,114,159,0,0,0,114,4,0,0,0,114,4, - 0,0,0,114,5,0,0,0,114,219,0,0,0,240,4,0, + 0,0,0,114,5,0,0,0,114,219,0,0,0,236,4,0, 0,115,2,0,0,0,0,4,122,26,66,117,105,108,116,105, 110,73,109,112,111,114,116,101,114,46,105,115,95,112,97,99, 107,97,103,101,41,14,114,57,0,0,0,114,56,0,0,0, @@ -2060,7 +2060,7 @@ 13,1,0,0,114,162,0,0,0,114,3,1,0,0,114,14, 1,0,0,114,15,1,0,0,114,219,0,0,0,114,4,0, 0,0,114,4,0,0,0,114,4,0,0,0,114,5,0,0, - 0,114,9,1,0,0,177,4,0,0,115,28,0,0,0,12, + 0,114,9,1,0,0,173,4,0,0,115,28,0,0,0,12, 7,6,2,18,9,3,1,21,8,3,1,18,11,3,1,21, 11,3,1,21,5,3,1,21,5,3,1,114,9,1,0,0, 99,0,0,0,0,0,0,0,0,0,0,0,0,5,0,0, @@ -2101,7 +2101,7 @@ 122,22,60,109,111,100,117,108,101,32,123,33,114,125,32,40, 102,114,111,122,101,110,41,62,41,2,114,47,0,0,0,114, 57,0,0,0,41,1,218,1,109,114,4,0,0,0,114,4, - 0,0,0,114,5,0,0,0,114,204,0,0,0,0,5,0, + 0,0,0,114,5,0,0,0,114,204,0,0,0,252,4,0, 0,115,2,0,0,0,0,7,122,26,70,114,111,122,101,110, 73,109,112,111,114,116,101,114,46,109,111,100,117,108,101,95, 114,101,112,114,78,99,4,0,0,0,0,0,0,0,4,0, @@ -2113,7 +2113,7 @@ 114,163,0,0,0,114,174,0,0,0,41,4,114,10,1,0, 0,114,159,0,0,0,114,35,0,0,0,114,11,1,0,0, 114,4,0,0,0,114,4,0,0,0,114,5,0,0,0,114, - 12,1,0,0,9,5,0,0,115,6,0,0,0,0,2,15, + 12,1,0,0,5,5,0,0,115,6,0,0,0,0,2,15, 1,19,2,122,24,70,114,111,122,101,110,73,109,112,111,114, 116,101,114,46,102,105,110,100,95,115,112,101,99,99,3,0, 0,0,0,0,0,0,3,0,0,0,2,0,0,0,67,0, @@ -2128,7 +2128,7 @@ 41,2,114,106,0,0,0,114,163,0,0,0,41,3,114,10, 1,0,0,114,159,0,0,0,114,35,0,0,0,114,4,0, 0,0,114,4,0,0,0,114,5,0,0,0,114,13,1,0, - 0,16,5,0,0,115,2,0,0,0,0,7,122,26,70,114, + 0,12,5,0,0,115,2,0,0,0,0,7,122,26,70,114, 111,122,101,110,73,109,112,111,114,116,101,114,46,102,105,110, 100,95,109,111,100,117,108,101,99,2,0,0,0,0,0,0, 0,2,0,0,0,1,0,0,0,67,0,0,0,115,4,0, @@ -2137,7 +2137,7 @@ 102,111,114,32,109,111,100,117,108,101,32,99,114,101,97,116, 105,111,110,46,78,114,4,0,0,0,41,2,114,10,1,0, 0,114,177,0,0,0,114,4,0,0,0,114,4,0,0,0, - 114,5,0,0,0,114,254,0,0,0,25,5,0,0,115,0, + 114,5,0,0,0,114,254,0,0,0,21,5,0,0,115,0, 0,0,0,122,28,70,114,111,122,101,110,73,109,112,111,114, 116,101,114,46,99,114,101,97,116,101,95,109,111,100,117,108, 101,99,1,0,0,0,0,0,0,0,3,0,0,0,4,0, @@ -2156,7 +2156,7 @@ 106,101,99,116,218,4,101,120,101,99,114,63,0,0,0,41, 3,114,178,0,0,0,114,67,0,0,0,114,193,0,0,0, 114,4,0,0,0,114,4,0,0,0,114,5,0,0,0,114, - 255,0,0,0,29,5,0,0,115,12,0,0,0,0,2,12, + 255,0,0,0,25,5,0,0,115,12,0,0,0,0,2,12, 1,15,1,18,1,9,1,18,1,122,26,70,114,111,122,101, 110,73,109,112,111,114,116,101,114,46,101,120,101,99,95,109, 111,100,117,108,101,99,2,0,0,0,0,0,0,0,2,0, @@ -2170,7 +2170,7 @@ 116,101,97,100,46,10,10,32,32,32,32,32,32,32,32,41, 1,114,179,0,0,0,41,2,114,10,1,0,0,114,159,0, 0,0,114,4,0,0,0,114,4,0,0,0,114,5,0,0, - 0,114,3,1,0,0,38,5,0,0,115,2,0,0,0,0, + 0,114,3,1,0,0,34,5,0,0,115,2,0,0,0,0, 7,122,26,70,114,111,122,101,110,73,109,112,111,114,116,101, 114,46,108,111,97,100,95,109,111,100,117,108,101,99,2,0, 0,0,0,0,0,0,2,0,0,0,2,0,0,0,67,0, @@ -2181,7 +2181,7 @@ 100,117,108,101,46,41,2,114,106,0,0,0,114,20,1,0, 0,41,2,114,10,1,0,0,114,159,0,0,0,114,4,0, 0,0,114,4,0,0,0,114,5,0,0,0,114,14,1,0, - 0,47,5,0,0,115,2,0,0,0,0,4,122,23,70,114, + 0,43,5,0,0,115,2,0,0,0,0,4,122,23,70,114, 111,122,101,110,73,109,112,111,114,116,101,114,46,103,101,116, 95,99,111,100,101,99,2,0,0,0,0,0,0,0,2,0, 0,0,1,0,0,0,67,0,0,0,115,4,0,0,0,100, @@ -2191,7 +2191,7 @@ 32,115,111,117,114,99,101,32,99,111,100,101,46,78,114,4, 0,0,0,41,2,114,10,1,0,0,114,159,0,0,0,114, 4,0,0,0,114,4,0,0,0,114,5,0,0,0,114,15, - 1,0,0,53,5,0,0,115,2,0,0,0,0,4,122,25, + 1,0,0,49,5,0,0,115,2,0,0,0,0,4,122,25, 70,114,111,122,101,110,73,109,112,111,114,116,101,114,46,103, 101,116,95,115,111,117,114,99,101,99,2,0,0,0,0,0, 0,0,2,0,0,0,2,0,0,0,67,0,0,0,115,13, @@ -2202,7 +2202,7 @@ 101,46,41,2,114,106,0,0,0,90,17,105,115,95,102,114, 111,122,101,110,95,112,97,99,107,97,103,101,41,2,114,10, 1,0,0,114,159,0,0,0,114,4,0,0,0,114,4,0, - 0,0,114,5,0,0,0,114,219,0,0,0,59,5,0,0, + 0,0,114,5,0,0,0,114,219,0,0,0,55,5,0,0, 115,2,0,0,0,0,4,122,25,70,114,111,122,101,110,73, 109,112,111,114,116,101,114,46,105,115,95,112,97,99,107,97, 103,101,41,16,114,57,0,0,0,114,56,0,0,0,114,58, @@ -2211,7 +2211,7 @@ 0,114,254,0,0,0,114,255,0,0,0,114,3,1,0,0, 114,165,0,0,0,114,14,1,0,0,114,15,1,0,0,114, 219,0,0,0,114,4,0,0,0,114,4,0,0,0,114,4, - 0,0,0,114,5,0,0,0,114,18,1,0,0,247,4,0, + 0,0,0,114,5,0,0,0,114,18,1,0,0,243,4,0, 0,115,30,0,0,0,12,7,6,2,18,9,3,1,21,6, 3,1,18,8,18,4,18,9,18,9,3,1,21,5,3,1, 21,5,3,1,114,18,1,0,0,99,0,0,0,0,0,0, @@ -2250,7 +2250,7 @@ 65,67,72,73,78,69,41,2,114,10,1,0,0,218,3,107, 101,121,114,4,0,0,0,114,4,0,0,0,114,5,0,0, 0,218,14,95,111,112,101,110,95,114,101,103,105,115,116,114, - 121,78,5,0,0,115,8,0,0,0,0,2,3,1,23,1, + 121,74,5,0,0,115,8,0,0,0,0,2,3,1,23,1, 13,1,122,36,87,105,110,100,111,119,115,82,101,103,105,115, 116,114,121,70,105,110,100,101,114,46,95,111,112,101,110,95, 114,101,103,105,115,116,114,121,99,2,0,0,0,0,0,0, @@ -2276,7 +2276,7 @@ 115,116,114,121,95,107,101,121,114,24,1,0,0,90,4,104, 107,101,121,218,8,102,105,108,101,112,97,116,104,114,4,0, 0,0,114,4,0,0,0,114,5,0,0,0,218,16,95,115, - 101,97,114,99,104,95,114,101,103,105,115,116,114,121,85,5, + 101,97,114,99,104,95,114,101,103,105,115,116,114,121,81,5, 0,0,115,22,0,0,0,0,2,9,1,12,2,9,1,15, 1,22,1,3,1,18,1,28,1,13,1,9,1,122,38,87, 105,110,100,111,119,115,82,101,103,105,115,116,114,121,70,105, @@ -2299,7 +2299,7 @@ 159,0,0,0,114,35,0,0,0,114,11,1,0,0,114,30, 1,0,0,114,170,0,0,0,114,126,0,0,0,114,177,0, 0,0,114,4,0,0,0,114,4,0,0,0,114,5,0,0, - 0,114,12,1,0,0,100,5,0,0,115,24,0,0,0,0, + 0,114,12,1,0,0,96,5,0,0,115,24,0,0,0,0, 2,15,1,12,1,4,1,3,1,14,1,13,1,9,1,22, 1,21,1,21,1,9,1,122,31,87,105,110,100,111,119,115, 82,101,103,105,115,116,114,121,70,105,110,100,101,114,46,102, @@ -2318,7 +2318,7 @@ 41,2,114,12,1,0,0,114,170,0,0,0,41,4,114,10, 1,0,0,114,159,0,0,0,114,35,0,0,0,114,177,0, 0,0,114,4,0,0,0,114,4,0,0,0,114,5,0,0, - 0,114,13,1,0,0,115,5,0,0,115,8,0,0,0,0, + 0,114,13,1,0,0,111,5,0,0,115,8,0,0,0,0, 7,18,1,12,1,7,2,122,33,87,105,110,100,111,119,115, 82,101,103,105,115,116,114,121,70,105,110,100,101,114,46,102, 105,110,100,95,109,111,100,117,108,101,41,12,114,57,0,0, @@ -2327,7 +2327,7 @@ 17,1,0,0,114,25,1,0,0,114,31,1,0,0,114,12, 1,0,0,114,13,1,0,0,114,4,0,0,0,114,4,0, 0,0,114,4,0,0,0,114,5,0,0,0,114,22,1,0, - 0,66,5,0,0,115,20,0,0,0,12,2,6,3,6,3, + 0,62,5,0,0,115,20,0,0,0,12,2,6,3,6,3, 6,2,6,2,18,7,18,15,3,1,21,14,3,1,114,22, 1,0,0,99,0,0,0,0,0,0,0,0,0,0,0,0, 2,0,0,0,64,0,0,0,115,64,0,0,0,101,0,0, @@ -2364,7 +2364,7 @@ 0,114,131,0,0,0,90,13,102,105,108,101,110,97,109,101, 95,98,97,115,101,90,9,116,97,105,108,95,110,97,109,101, 114,4,0,0,0,114,4,0,0,0,114,5,0,0,0,114, - 219,0,0,0,134,5,0,0,115,8,0,0,0,0,3,25, + 219,0,0,0,130,5,0,0,115,8,0,0,0,0,3,25, 1,22,1,19,1,122,24,95,76,111,97,100,101,114,66,97, 115,105,99,115,46,105,115,95,112,97,99,107,97,103,101,99, 2,0,0,0,0,0,0,0,2,0,0,0,1,0,0,0, @@ -2374,7 +2374,7 @@ 101,32,99,114,101,97,116,105,111,110,46,78,114,4,0,0, 0,41,2,114,71,0,0,0,114,177,0,0,0,114,4,0, 0,0,114,4,0,0,0,114,5,0,0,0,114,254,0,0, - 0,142,5,0,0,115,0,0,0,0,122,27,95,76,111,97, + 0,138,5,0,0,115,0,0,0,0,122,27,95,76,111,97, 100,101,114,66,97,115,105,99,115,46,99,114,101,97,116,101, 95,109,111,100,117,108,101,99,2,0,0,0,0,0,0,0, 3,0,0,0,4,0,0,0,67,0,0,0,115,77,0,0, @@ -2392,14 +2392,14 @@ 0,0,114,114,0,0,0,114,21,1,0,0,114,63,0,0, 0,41,3,114,71,0,0,0,114,178,0,0,0,114,193,0, 0,0,114,4,0,0,0,114,4,0,0,0,114,5,0,0, - 0,114,255,0,0,0,145,5,0,0,115,10,0,0,0,0, + 0,114,255,0,0,0,141,5,0,0,115,10,0,0,0,0, 2,18,1,12,1,9,1,15,1,122,25,95,76,111,97,100, 101,114,66,97,115,105,99,115,46,101,120,101,99,95,109,111, 100,117,108,101,78,41,9,114,57,0,0,0,114,56,0,0, 0,114,58,0,0,0,114,59,0,0,0,114,219,0,0,0, 114,254,0,0,0,114,255,0,0,0,114,179,0,0,0,114, 3,1,0,0,114,4,0,0,0,114,4,0,0,0,114,4, - 0,0,0,114,5,0,0,0,114,32,1,0,0,129,5,0, + 0,0,0,114,5,0,0,0,114,32,1,0,0,125,5,0, 0,115,10,0,0,0,12,3,6,2,12,8,12,3,12,8, 114,32,1,0,0,99,0,0,0,0,0,0,0,0,0,0, 0,0,4,0,0,0,64,0,0,0,115,106,0,0,0,101, @@ -2427,1868 +2427,1868 @@ 32,32,32,78,41,1,218,7,73,79,69,114,114,111,114,41, 2,114,71,0,0,0,114,35,0,0,0,114,4,0,0,0, 114,4,0,0,0,114,5,0,0,0,218,10,112,97,116,104, - 95,109,116,105,109,101,158,5,0,0,115,2,0,0,0,0, + 95,109,116,105,109,101,154,5,0,0,115,2,0,0,0,0, 6,122,23,83,111,117,114,99,101,76,111,97,100,101,114,46, 112,97,116,104,95,109,116,105,109,101,99,2,0,0,0,0, 0,0,0,2,0,0,0,3,0,0,0,67,0,0,0,115, - 20,0,0,0,105,1,0,124,0,0,106,0,0,124,1,0, - 131,1,0,100,1,0,54,83,41,2,97,170,1,0,0,79, - 112,116,105,111,110,97,108,32,109,101,116,104,111,100,32,114, - 101,116,117,114,110,105,110,103,32,97,32,109,101,116,97,100, - 97,116,97,32,100,105,99,116,32,102,111,114,32,116,104,101, - 32,115,112,101,99,105,102,105,101,100,32,112,97,116,104,10, - 32,32,32,32,32,32,32,32,116,111,32,98,121,32,116,104, - 101,32,112,97,116,104,32,40,115,116,114,41,46,10,32,32, - 32,32,32,32,32,32,80,111,115,115,105,98,108,101,32,107, - 101,121,115,58,10,32,32,32,32,32,32,32,32,45,32,39, - 109,116,105,109,101,39,32,40,109,97,110,100,97,116,111,114, - 121,41,32,105,115,32,116,104,101,32,110,117,109,101,114,105, - 99,32,116,105,109,101,115,116,97,109,112,32,111,102,32,108, - 97,115,116,32,115,111,117,114,99,101,10,32,32,32,32,32, - 32,32,32,32,32,99,111,100,101,32,109,111,100,105,102,105, - 99,97,116,105,111,110,59,10,32,32,32,32,32,32,32,32, - 45,32,39,115,105,122,101,39,32,40,111,112,116,105,111,110, - 97,108,41,32,105,115,32,116,104,101,32,115,105,122,101,32, - 105,110,32,98,121,116,101,115,32,111,102,32,116,104,101,32, - 115,111,117,114,99,101,32,99,111,100,101,46,10,10,32,32, - 32,32,32,32,32,32,73,109,112,108,101,109,101,110,116,105, - 110,103,32,116,104,105,115,32,109,101,116,104,111,100,32,97, - 108,108,111,119,115,32,116,104,101,32,108,111,97,100,101,114, - 32,116,111,32,114,101,97,100,32,98,121,116,101,99,111,100, - 101,32,102,105,108,101,115,46,10,32,32,32,32,32,32,32, - 32,82,97,105,115,101,115,32,73,79,69,114,114,111,114,32, - 119,104,101,110,32,116,104,101,32,112,97,116,104,32,99,97, - 110,110,111,116,32,98,101,32,104,97,110,100,108,101,100,46, - 10,32,32,32,32,32,32,32,32,114,182,0,0,0,41,1, - 114,35,1,0,0,41,2,114,71,0,0,0,114,35,0,0, - 0,114,4,0,0,0,114,4,0,0,0,114,5,0,0,0, - 218,10,112,97,116,104,95,115,116,97,116,115,166,5,0,0, - 115,2,0,0,0,0,11,122,23,83,111,117,114,99,101,76, - 111,97,100,101,114,46,112,97,116,104,95,115,116,97,116,115, - 99,4,0,0,0,0,0,0,0,4,0,0,0,3,0,0, - 0,67,0,0,0,115,16,0,0,0,124,0,0,106,0,0, - 124,2,0,124,3,0,131,2,0,83,41,1,122,228,79,112, - 116,105,111,110,97,108,32,109,101,116,104,111,100,32,119,104, - 105,99,104,32,119,114,105,116,101,115,32,100,97,116,97,32, - 40,98,121,116,101,115,41,32,116,111,32,97,32,102,105,108, - 101,32,112,97,116,104,32,40,97,32,115,116,114,41,46,10, - 10,32,32,32,32,32,32,32,32,73,109,112,108,101,109,101, - 110,116,105,110,103,32,116,104,105,115,32,109,101,116,104,111, - 100,32,97,108,108,111,119,115,32,102,111,114,32,116,104,101, - 32,119,114,105,116,105,110,103,32,111,102,32,98,121,116,101, - 99,111,100,101,32,102,105,108,101,115,46,10,10,32,32,32, - 32,32,32,32,32,84,104,101,32,115,111,117,114,99,101,32, - 112,97,116,104,32,105,115,32,110,101,101,100,101,100,32,105, - 110,32,111,114,100,101,114,32,116,111,32,99,111,114,114,101, - 99,116,108,121,32,116,114,97,110,115,102,101,114,32,112,101, - 114,109,105,115,115,105,111,110,115,10,32,32,32,32,32,32, - 32,32,41,1,218,8,115,101,116,95,100,97,116,97,41,4, - 114,71,0,0,0,114,142,0,0,0,90,10,99,97,99,104, - 101,95,112,97,116,104,114,53,0,0,0,114,4,0,0,0, - 114,4,0,0,0,114,5,0,0,0,218,15,95,99,97,99, - 104,101,95,98,121,116,101,99,111,100,101,179,5,0,0,115, - 2,0,0,0,0,8,122,28,83,111,117,114,99,101,76,111, - 97,100,101,114,46,95,99,97,99,104,101,95,98,121,116,101, - 99,111,100,101,99,3,0,0,0,0,0,0,0,3,0,0, - 0,1,0,0,0,67,0,0,0,115,4,0,0,0,100,1, - 0,83,41,2,122,150,79,112,116,105,111,110,97,108,32,109, - 101,116,104,111,100,32,119,104,105,99,104,32,119,114,105,116, - 101,115,32,100,97,116,97,32,40,98,121,116,101,115,41,32, - 116,111,32,97,32,102,105,108,101,32,112,97,116,104,32,40, - 97,32,115,116,114,41,46,10,10,32,32,32,32,32,32,32, - 32,73,109,112,108,101,109,101,110,116,105,110,103,32,116,104, - 105,115,32,109,101,116,104,111,100,32,97,108,108,111,119,115, - 32,102,111,114,32,116,104,101,32,119,114,105,116,105,110,103, - 32,111,102,32,98,121,116,101,99,111,100,101,32,102,105,108, - 101,115,46,10,32,32,32,32,32,32,32,32,78,114,4,0, - 0,0,41,3,114,71,0,0,0,114,35,0,0,0,114,53, + 19,0,0,0,124,0,0,106,0,0,124,1,0,131,1,0, + 100,1,0,105,1,0,83,41,2,97,170,1,0,0,79,112, + 116,105,111,110,97,108,32,109,101,116,104,111,100,32,114,101, + 116,117,114,110,105,110,103,32,97,32,109,101,116,97,100,97, + 116,97,32,100,105,99,116,32,102,111,114,32,116,104,101,32, + 115,112,101,99,105,102,105,101,100,32,112,97,116,104,10,32, + 32,32,32,32,32,32,32,116,111,32,98,121,32,116,104,101, + 32,112,97,116,104,32,40,115,116,114,41,46,10,32,32,32, + 32,32,32,32,32,80,111,115,115,105,98,108,101,32,107,101, + 121,115,58,10,32,32,32,32,32,32,32,32,45,32,39,109, + 116,105,109,101,39,32,40,109,97,110,100,97,116,111,114,121, + 41,32,105,115,32,116,104,101,32,110,117,109,101,114,105,99, + 32,116,105,109,101,115,116,97,109,112,32,111,102,32,108,97, + 115,116,32,115,111,117,114,99,101,10,32,32,32,32,32,32, + 32,32,32,32,99,111,100,101,32,109,111,100,105,102,105,99, + 97,116,105,111,110,59,10,32,32,32,32,32,32,32,32,45, + 32,39,115,105,122,101,39,32,40,111,112,116,105,111,110,97, + 108,41,32,105,115,32,116,104,101,32,115,105,122,101,32,105, + 110,32,98,121,116,101,115,32,111,102,32,116,104,101,32,115, + 111,117,114,99,101,32,99,111,100,101,46,10,10,32,32,32, + 32,32,32,32,32,73,109,112,108,101,109,101,110,116,105,110, + 103,32,116,104,105,115,32,109,101,116,104,111,100,32,97,108, + 108,111,119,115,32,116,104,101,32,108,111,97,100,101,114,32, + 116,111,32,114,101,97,100,32,98,121,116,101,99,111,100,101, + 32,102,105,108,101,115,46,10,32,32,32,32,32,32,32,32, + 82,97,105,115,101,115,32,73,79,69,114,114,111,114,32,119, + 104,101,110,32,116,104,101,32,112,97,116,104,32,99,97,110, + 110,111,116,32,98,101,32,104,97,110,100,108,101,100,46,10, + 32,32,32,32,32,32,32,32,114,182,0,0,0,41,1,114, + 35,1,0,0,41,2,114,71,0,0,0,114,35,0,0,0, + 114,4,0,0,0,114,4,0,0,0,114,5,0,0,0,218, + 10,112,97,116,104,95,115,116,97,116,115,162,5,0,0,115, + 2,0,0,0,0,11,122,23,83,111,117,114,99,101,76,111, + 97,100,101,114,46,112,97,116,104,95,115,116,97,116,115,99, + 4,0,0,0,0,0,0,0,4,0,0,0,3,0,0,0, + 67,0,0,0,115,16,0,0,0,124,0,0,106,0,0,124, + 2,0,124,3,0,131,2,0,83,41,1,122,228,79,112,116, + 105,111,110,97,108,32,109,101,116,104,111,100,32,119,104,105, + 99,104,32,119,114,105,116,101,115,32,100,97,116,97,32,40, + 98,121,116,101,115,41,32,116,111,32,97,32,102,105,108,101, + 32,112,97,116,104,32,40,97,32,115,116,114,41,46,10,10, + 32,32,32,32,32,32,32,32,73,109,112,108,101,109,101,110, + 116,105,110,103,32,116,104,105,115,32,109,101,116,104,111,100, + 32,97,108,108,111,119,115,32,102,111,114,32,116,104,101,32, + 119,114,105,116,105,110,103,32,111,102,32,98,121,116,101,99, + 111,100,101,32,102,105,108,101,115,46,10,10,32,32,32,32, + 32,32,32,32,84,104,101,32,115,111,117,114,99,101,32,112, + 97,116,104,32,105,115,32,110,101,101,100,101,100,32,105,110, + 32,111,114,100,101,114,32,116,111,32,99,111,114,114,101,99, + 116,108,121,32,116,114,97,110,115,102,101,114,32,112,101,114, + 109,105,115,115,105,111,110,115,10,32,32,32,32,32,32,32, + 32,41,1,218,8,115,101,116,95,100,97,116,97,41,4,114, + 71,0,0,0,114,142,0,0,0,90,10,99,97,99,104,101, + 95,112,97,116,104,114,53,0,0,0,114,4,0,0,0,114, + 4,0,0,0,114,5,0,0,0,218,15,95,99,97,99,104, + 101,95,98,121,116,101,99,111,100,101,175,5,0,0,115,2, + 0,0,0,0,8,122,28,83,111,117,114,99,101,76,111,97, + 100,101,114,46,95,99,97,99,104,101,95,98,121,116,101,99, + 111,100,101,99,3,0,0,0,0,0,0,0,3,0,0,0, + 1,0,0,0,67,0,0,0,115,4,0,0,0,100,1,0, + 83,41,2,122,150,79,112,116,105,111,110,97,108,32,109,101, + 116,104,111,100,32,119,104,105,99,104,32,119,114,105,116,101, + 115,32,100,97,116,97,32,40,98,121,116,101,115,41,32,116, + 111,32,97,32,102,105,108,101,32,112,97,116,104,32,40,97, + 32,115,116,114,41,46,10,10,32,32,32,32,32,32,32,32, + 73,109,112,108,101,109,101,110,116,105,110,103,32,116,104,105, + 115,32,109,101,116,104,111,100,32,97,108,108,111,119,115,32, + 102,111,114,32,116,104,101,32,119,114,105,116,105,110,103,32, + 111,102,32,98,121,116,101,99,111,100,101,32,102,105,108,101, + 115,46,10,32,32,32,32,32,32,32,32,78,114,4,0,0, + 0,41,3,114,71,0,0,0,114,35,0,0,0,114,53,0, + 0,0,114,4,0,0,0,114,4,0,0,0,114,5,0,0, + 0,114,37,1,0,0,185,5,0,0,115,0,0,0,0,122, + 21,83,111,117,114,99,101,76,111,97,100,101,114,46,115,101, + 116,95,100,97,116,97,99,2,0,0,0,0,0,0,0,5, + 0,0,0,16,0,0,0,67,0,0,0,115,105,0,0,0, + 124,0,0,106,0,0,124,1,0,131,1,0,125,2,0,121, + 19,0,124,0,0,106,1,0,124,2,0,131,1,0,125,3, + 0,87,110,58,0,4,116,2,0,107,10,0,114,94,0,1, + 125,4,0,1,122,26,0,116,3,0,100,1,0,100,2,0, + 124,1,0,131,1,1,124,4,0,130,2,0,87,89,100,3, + 0,100,3,0,125,4,0,126,4,0,88,110,1,0,88,116, + 4,0,124,3,0,131,1,0,83,41,4,122,52,67,111,110, + 99,114,101,116,101,32,105,109,112,108,101,109,101,110,116,97, + 116,105,111,110,32,111,102,32,73,110,115,112,101,99,116,76, + 111,97,100,101,114,46,103,101,116,95,115,111,117,114,99,101, + 46,122,39,115,111,117,114,99,101,32,110,111,116,32,97,118, + 97,105,108,97,98,108,101,32,116,104,114,111,117,103,104,32, + 103,101,116,95,100,97,116,97,40,41,114,67,0,0,0,78, + 41,5,114,238,0,0,0,218,8,103,101,116,95,100,97,116, + 97,114,40,0,0,0,114,154,0,0,0,114,202,0,0,0, + 41,5,114,71,0,0,0,114,159,0,0,0,114,35,0,0, + 0,114,200,0,0,0,218,3,101,120,99,114,4,0,0,0, + 114,4,0,0,0,114,5,0,0,0,114,15,1,0,0,192, + 5,0,0,115,14,0,0,0,0,2,15,1,3,1,19,1, + 18,1,9,1,31,1,122,23,83,111,117,114,99,101,76,111, + 97,100,101,114,46,103,101,116,95,115,111,117,114,99,101,218, + 9,95,111,112,116,105,109,105,122,101,114,29,0,0,0,99, + 3,0,0,0,1,0,0,0,4,0,0,0,9,0,0,0, + 67,0,0,0,115,31,0,0,0,116,0,0,116,1,0,124, + 1,0,124,2,0,100,1,0,100,2,0,100,3,0,100,4, + 0,124,3,0,131,4,2,83,41,5,122,130,82,101,116,117, + 114,110,32,116,104,101,32,99,111,100,101,32,111,98,106,101, + 99,116,32,99,111,109,112,105,108,101,100,32,102,114,111,109, + 32,115,111,117,114,99,101,46,10,10,32,32,32,32,32,32, + 32,32,84,104,101,32,39,100,97,116,97,39,32,97,114,103, + 117,109,101,110,116,32,99,97,110,32,98,101,32,97,110,121, + 32,111,98,106,101,99,116,32,116,121,112,101,32,116,104,97, + 116,32,99,111,109,112,105,108,101,40,41,32,115,117,112,112, + 111,114,116,115,46,10,32,32,32,32,32,32,32,32,114,21, + 1,0,0,218,12,100,111,110,116,95,105,110,104,101,114,105, + 116,84,114,118,0,0,0,41,2,114,114,0,0,0,218,7, + 99,111,109,112,105,108,101,41,4,114,71,0,0,0,114,53, + 0,0,0,114,35,0,0,0,114,41,1,0,0,114,4,0, + 0,0,114,4,0,0,0,114,5,0,0,0,218,14,115,111, + 117,114,99,101,95,116,111,95,99,111,100,101,202,5,0,0, + 115,4,0,0,0,0,5,18,1,122,27,83,111,117,114,99, + 101,76,111,97,100,101,114,46,115,111,117,114,99,101,95,116, + 111,95,99,111,100,101,99,2,0,0,0,0,0,0,0,10, + 0,0,0,43,0,0,0,67,0,0,0,115,174,1,0,0, + 124,0,0,106,0,0,124,1,0,131,1,0,125,2,0,100, + 1,0,125,3,0,121,16,0,116,1,0,124,2,0,131,1, + 0,125,4,0,87,110,24,0,4,116,2,0,107,10,0,114, + 63,0,1,1,1,100,1,0,125,4,0,89,110,202,0,88, + 121,19,0,124,0,0,106,3,0,124,2,0,131,1,0,125, + 5,0,87,110,18,0,4,116,4,0,107,10,0,114,103,0, + 1,1,1,89,110,162,0,88,116,5,0,124,5,0,100,2, + 0,25,131,1,0,125,3,0,121,19,0,124,0,0,106,6, + 0,124,4,0,131,1,0,125,6,0,87,110,18,0,4,116, + 7,0,107,10,0,114,159,0,1,1,1,89,110,106,0,88, + 121,34,0,116,8,0,124,6,0,100,3,0,124,5,0,100, + 4,0,124,1,0,100,5,0,124,4,0,131,1,3,125,7, + 0,87,110,24,0,4,116,9,0,116,10,0,102,2,0,107, + 10,0,114,220,0,1,1,1,89,110,45,0,88,116,11,0, + 100,6,0,124,4,0,124,2,0,131,3,0,1,116,12,0, + 124,7,0,100,4,0,124,1,0,100,7,0,124,4,0,100, + 8,0,124,2,0,131,1,3,83,124,0,0,106,6,0,124, + 2,0,131,1,0,125,8,0,124,0,0,106,13,0,124,8, + 0,124,2,0,131,2,0,125,9,0,116,11,0,100,9,0, + 124,2,0,131,2,0,1,116,14,0,106,15,0,12,114,170, + 1,124,4,0,100,1,0,107,9,0,114,170,1,124,3,0, + 100,1,0,107,9,0,114,170,1,116,16,0,124,9,0,124, + 3,0,116,17,0,124,8,0,131,1,0,131,3,0,125,6, + 0,121,36,0,124,0,0,106,18,0,124,2,0,124,4,0, + 124,6,0,131,3,0,1,116,11,0,100,10,0,124,4,0, + 131,2,0,1,87,110,18,0,4,116,2,0,107,10,0,114, + 169,1,1,1,1,89,110,1,0,88,124,9,0,83,41,11, + 122,190,67,111,110,99,114,101,116,101,32,105,109,112,108,101, + 109,101,110,116,97,116,105,111,110,32,111,102,32,73,110,115, + 112,101,99,116,76,111,97,100,101,114,46,103,101,116,95,99, + 111,100,101,46,10,10,32,32,32,32,32,32,32,32,82,101, + 97,100,105,110,103,32,111,102,32,98,121,116,101,99,111,100, + 101,32,114,101,113,117,105,114,101,115,32,112,97,116,104,95, + 115,116,97,116,115,32,116,111,32,98,101,32,105,109,112,108, + 101,109,101,110,116,101,100,46,32,84,111,32,119,114,105,116, + 101,10,32,32,32,32,32,32,32,32,98,121,116,101,99,111, + 100,101,44,32,115,101,116,95,100,97,116,97,32,109,117,115, + 116,32,97,108,115,111,32,98,101,32,105,109,112,108,101,109, + 101,110,116,101,100,46,10,10,32,32,32,32,32,32,32,32, + 78,114,182,0,0,0,114,186,0,0,0,114,67,0,0,0, + 114,35,0,0,0,122,13,123,125,32,109,97,116,99,104,101, + 115,32,123,125,114,141,0,0,0,114,142,0,0,0,122,19, + 99,111,100,101,32,111,98,106,101,99,116,32,102,114,111,109, + 32,123,125,122,10,119,114,111,116,101,32,123,33,114,125,41, + 19,114,238,0,0,0,114,132,0,0,0,114,123,0,0,0, + 114,36,1,0,0,114,34,1,0,0,114,14,0,0,0,114, + 39,1,0,0,114,40,0,0,0,114,189,0,0,0,114,154, + 0,0,0,114,185,0,0,0,114,153,0,0,0,114,194,0, + 0,0,114,44,1,0,0,114,7,0,0,0,218,19,100,111, + 110,116,95,119,114,105,116,101,95,98,121,116,101,99,111,100, + 101,114,197,0,0,0,114,31,0,0,0,114,38,1,0,0, + 41,10,114,71,0,0,0,114,159,0,0,0,114,142,0,0, + 0,114,187,0,0,0,114,141,0,0,0,218,2,115,116,114, + 53,0,0,0,218,10,98,121,116,101,115,95,100,97,116,97, + 114,200,0,0,0,90,11,99,111,100,101,95,111,98,106,101, + 99,116,114,4,0,0,0,114,4,0,0,0,114,5,0,0, + 0,114,14,1,0,0,210,5,0,0,115,78,0,0,0,0, + 7,15,1,6,1,3,1,16,1,13,1,11,2,3,1,19, + 1,13,1,5,2,16,1,3,1,19,1,13,1,5,2,3, + 1,9,1,12,1,13,1,19,1,5,2,9,1,7,1,15, + 1,6,1,7,1,15,1,18,1,13,1,22,1,12,1,9, + 1,15,1,3,1,19,1,17,1,13,1,5,1,122,21,83, + 111,117,114,99,101,76,111,97,100,101,114,46,103,101,116,95, + 99,111,100,101,78,114,139,0,0,0,41,10,114,57,0,0, + 0,114,56,0,0,0,114,58,0,0,0,114,35,1,0,0, + 114,36,1,0,0,114,38,1,0,0,114,37,1,0,0,114, + 15,1,0,0,114,44,1,0,0,114,14,1,0,0,114,4, 0,0,0,114,4,0,0,0,114,4,0,0,0,114,5,0, - 0,0,114,37,1,0,0,189,5,0,0,115,0,0,0,0, - 122,21,83,111,117,114,99,101,76,111,97,100,101,114,46,115, - 101,116,95,100,97,116,97,99,2,0,0,0,0,0,0,0, - 5,0,0,0,16,0,0,0,67,0,0,0,115,105,0,0, - 0,124,0,0,106,0,0,124,1,0,131,1,0,125,2,0, - 121,19,0,124,0,0,106,1,0,124,2,0,131,1,0,125, - 3,0,87,110,58,0,4,116,2,0,107,10,0,114,94,0, - 1,125,4,0,1,122,26,0,116,3,0,100,1,0,100,2, - 0,124,1,0,131,1,1,124,4,0,130,2,0,87,89,100, - 3,0,100,3,0,125,4,0,126,4,0,88,110,1,0,88, - 116,4,0,124,3,0,131,1,0,83,41,4,122,52,67,111, - 110,99,114,101,116,101,32,105,109,112,108,101,109,101,110,116, - 97,116,105,111,110,32,111,102,32,73,110,115,112,101,99,116, - 76,111,97,100,101,114,46,103,101,116,95,115,111,117,114,99, - 101,46,122,39,115,111,117,114,99,101,32,110,111,116,32,97, - 118,97,105,108,97,98,108,101,32,116,104,114,111,117,103,104, - 32,103,101,116,95,100,97,116,97,40,41,114,67,0,0,0, - 78,41,5,114,238,0,0,0,218,8,103,101,116,95,100,97, - 116,97,114,40,0,0,0,114,154,0,0,0,114,202,0,0, - 0,41,5,114,71,0,0,0,114,159,0,0,0,114,35,0, - 0,0,114,200,0,0,0,218,3,101,120,99,114,4,0,0, - 0,114,4,0,0,0,114,5,0,0,0,114,15,1,0,0, - 196,5,0,0,115,14,0,0,0,0,2,15,1,3,1,19, - 1,18,1,9,1,31,1,122,23,83,111,117,114,99,101,76, - 111,97,100,101,114,46,103,101,116,95,115,111,117,114,99,101, - 218,9,95,111,112,116,105,109,105,122,101,114,29,0,0,0, - 99,3,0,0,0,1,0,0,0,4,0,0,0,9,0,0, - 0,67,0,0,0,115,31,0,0,0,116,0,0,116,1,0, - 124,1,0,124,2,0,100,1,0,100,2,0,100,3,0,100, - 4,0,124,3,0,131,4,2,83,41,5,122,130,82,101,116, - 117,114,110,32,116,104,101,32,99,111,100,101,32,111,98,106, - 101,99,116,32,99,111,109,112,105,108,101,100,32,102,114,111, - 109,32,115,111,117,114,99,101,46,10,10,32,32,32,32,32, - 32,32,32,84,104,101,32,39,100,97,116,97,39,32,97,114, - 103,117,109,101,110,116,32,99,97,110,32,98,101,32,97,110, - 121,32,111,98,106,101,99,116,32,116,121,112,101,32,116,104, - 97,116,32,99,111,109,112,105,108,101,40,41,32,115,117,112, - 112,111,114,116,115,46,10,32,32,32,32,32,32,32,32,114, - 21,1,0,0,218,12,100,111,110,116,95,105,110,104,101,114, - 105,116,84,114,118,0,0,0,41,2,114,114,0,0,0,218, - 7,99,111,109,112,105,108,101,41,4,114,71,0,0,0,114, - 53,0,0,0,114,35,0,0,0,114,41,1,0,0,114,4, - 0,0,0,114,4,0,0,0,114,5,0,0,0,218,14,115, - 111,117,114,99,101,95,116,111,95,99,111,100,101,206,5,0, - 0,115,4,0,0,0,0,5,18,1,122,27,83,111,117,114, - 99,101,76,111,97,100,101,114,46,115,111,117,114,99,101,95, - 116,111,95,99,111,100,101,99,2,0,0,0,0,0,0,0, - 10,0,0,0,43,0,0,0,67,0,0,0,115,174,1,0, - 0,124,0,0,106,0,0,124,1,0,131,1,0,125,2,0, - 100,1,0,125,3,0,121,16,0,116,1,0,124,2,0,131, - 1,0,125,4,0,87,110,24,0,4,116,2,0,107,10,0, - 114,63,0,1,1,1,100,1,0,125,4,0,89,110,202,0, - 88,121,19,0,124,0,0,106,3,0,124,2,0,131,1,0, - 125,5,0,87,110,18,0,4,116,4,0,107,10,0,114,103, - 0,1,1,1,89,110,162,0,88,116,5,0,124,5,0,100, - 2,0,25,131,1,0,125,3,0,121,19,0,124,0,0,106, - 6,0,124,4,0,131,1,0,125,6,0,87,110,18,0,4, - 116,7,0,107,10,0,114,159,0,1,1,1,89,110,106,0, - 88,121,34,0,116,8,0,124,6,0,100,3,0,124,5,0, - 100,4,0,124,1,0,100,5,0,124,4,0,131,1,3,125, - 7,0,87,110,24,0,4,116,9,0,116,10,0,102,2,0, - 107,10,0,114,220,0,1,1,1,89,110,45,0,88,116,11, - 0,100,6,0,124,4,0,124,2,0,131,3,0,1,116,12, - 0,124,7,0,100,4,0,124,1,0,100,7,0,124,4,0, - 100,8,0,124,2,0,131,1,3,83,124,0,0,106,6,0, - 124,2,0,131,1,0,125,8,0,124,0,0,106,13,0,124, - 8,0,124,2,0,131,2,0,125,9,0,116,11,0,100,9, - 0,124,2,0,131,2,0,1,116,14,0,106,15,0,12,114, - 170,1,124,4,0,100,1,0,107,9,0,114,170,1,124,3, - 0,100,1,0,107,9,0,114,170,1,116,16,0,124,9,0, - 124,3,0,116,17,0,124,8,0,131,1,0,131,3,0,125, - 6,0,121,36,0,124,0,0,106,18,0,124,2,0,124,4, - 0,124,6,0,131,3,0,1,116,11,0,100,10,0,124,4, - 0,131,2,0,1,87,110,18,0,4,116,2,0,107,10,0, - 114,169,1,1,1,1,89,110,1,0,88,124,9,0,83,41, - 11,122,190,67,111,110,99,114,101,116,101,32,105,109,112,108, - 101,109,101,110,116,97,116,105,111,110,32,111,102,32,73,110, - 115,112,101,99,116,76,111,97,100,101,114,46,103,101,116,95, - 99,111,100,101,46,10,10,32,32,32,32,32,32,32,32,82, - 101,97,100,105,110,103,32,111,102,32,98,121,116,101,99,111, - 100,101,32,114,101,113,117,105,114,101,115,32,112,97,116,104, - 95,115,116,97,116,115,32,116,111,32,98,101,32,105,109,112, - 108,101,109,101,110,116,101,100,46,32,84,111,32,119,114,105, - 116,101,10,32,32,32,32,32,32,32,32,98,121,116,101,99, - 111,100,101,44,32,115,101,116,95,100,97,116,97,32,109,117, - 115,116,32,97,108,115,111,32,98,101,32,105,109,112,108,101, - 109,101,110,116,101,100,46,10,10,32,32,32,32,32,32,32, - 32,78,114,182,0,0,0,114,186,0,0,0,114,67,0,0, - 0,114,35,0,0,0,122,13,123,125,32,109,97,116,99,104, - 101,115,32,123,125,114,141,0,0,0,114,142,0,0,0,122, - 19,99,111,100,101,32,111,98,106,101,99,116,32,102,114,111, - 109,32,123,125,122,10,119,114,111,116,101,32,123,33,114,125, - 41,19,114,238,0,0,0,114,132,0,0,0,114,123,0,0, - 0,114,36,1,0,0,114,34,1,0,0,114,14,0,0,0, - 114,39,1,0,0,114,40,0,0,0,114,189,0,0,0,114, - 154,0,0,0,114,185,0,0,0,114,153,0,0,0,114,194, - 0,0,0,114,44,1,0,0,114,7,0,0,0,218,19,100, - 111,110,116,95,119,114,105,116,101,95,98,121,116,101,99,111, - 100,101,114,197,0,0,0,114,31,0,0,0,114,38,1,0, - 0,41,10,114,71,0,0,0,114,159,0,0,0,114,142,0, - 0,0,114,187,0,0,0,114,141,0,0,0,218,2,115,116, - 114,53,0,0,0,218,10,98,121,116,101,115,95,100,97,116, - 97,114,200,0,0,0,90,11,99,111,100,101,95,111,98,106, - 101,99,116,114,4,0,0,0,114,4,0,0,0,114,5,0, - 0,0,114,14,1,0,0,214,5,0,0,115,78,0,0,0, - 0,7,15,1,6,1,3,1,16,1,13,1,11,2,3,1, - 19,1,13,1,5,2,16,1,3,1,19,1,13,1,5,2, - 3,1,9,1,12,1,13,1,19,1,5,2,9,1,7,1, - 15,1,6,1,7,1,15,1,18,1,13,1,22,1,12,1, - 9,1,15,1,3,1,19,1,17,1,13,1,5,1,122,21, - 83,111,117,114,99,101,76,111,97,100,101,114,46,103,101,116, - 95,99,111,100,101,78,114,139,0,0,0,41,10,114,57,0, - 0,0,114,56,0,0,0,114,58,0,0,0,114,35,1,0, - 0,114,36,1,0,0,114,38,1,0,0,114,37,1,0,0, - 114,15,1,0,0,114,44,1,0,0,114,14,1,0,0,114, - 4,0,0,0,114,4,0,0,0,114,4,0,0,0,114,5, - 0,0,0,114,33,1,0,0,156,5,0,0,115,14,0,0, - 0,12,2,12,8,12,13,12,10,12,7,12,10,18,8,114, - 33,1,0,0,99,0,0,0,0,0,0,0,0,0,0,0, - 0,4,0,0,0,0,0,0,0,115,112,0,0,0,101,0, - 0,90,1,0,100,0,0,90,2,0,100,1,0,90,3,0, - 100,2,0,100,3,0,132,0,0,90,4,0,100,4,0,100, - 5,0,132,0,0,90,5,0,100,6,0,100,7,0,132,0, - 0,90,6,0,101,7,0,135,0,0,102,1,0,100,8,0, - 100,9,0,134,0,0,131,1,0,90,8,0,101,7,0,100, - 10,0,100,11,0,132,0,0,131,1,0,90,9,0,100,12, - 0,100,13,0,132,0,0,90,10,0,135,0,0,83,41,14, - 218,10,70,105,108,101,76,111,97,100,101,114,122,103,66,97, - 115,101,32,102,105,108,101,32,108,111,97,100,101,114,32,99, - 108,97,115,115,32,119,104,105,99,104,32,105,109,112,108,101, - 109,101,110,116,115,32,116,104,101,32,108,111,97,100,101,114, - 32,112,114,111,116,111,99,111,108,32,109,101,116,104,111,100, - 115,32,116,104,97,116,10,32,32,32,32,114,101,113,117,105, - 114,101,32,102,105,108,101,32,115,121,115,116,101,109,32,117, - 115,97,103,101,46,99,3,0,0,0,0,0,0,0,3,0, - 0,0,2,0,0,0,67,0,0,0,115,22,0,0,0,124, - 1,0,124,0,0,95,0,0,124,2,0,124,0,0,95,1, - 0,100,1,0,83,41,2,122,75,67,97,99,104,101,32,116, - 104,101,32,109,111,100,117,108,101,32,110,97,109,101,32,97, - 110,100,32,116,104,101,32,112,97,116,104,32,116,111,32,116, - 104,101,32,102,105,108,101,32,102,111,117,110,100,32,98,121, - 32,116,104,101,10,32,32,32,32,32,32,32,32,102,105,110, - 100,101,114,46,78,41,2,114,67,0,0,0,114,35,0,0, - 0,41,3,114,71,0,0,0,114,159,0,0,0,114,35,0, - 0,0,114,4,0,0,0,114,4,0,0,0,114,5,0,0, - 0,114,72,0,0,0,15,6,0,0,115,4,0,0,0,0, - 3,9,1,122,19,70,105,108,101,76,111,97,100,101,114,46, - 95,95,105,110,105,116,95,95,99,2,0,0,0,0,0,0, - 0,2,0,0,0,2,0,0,0,67,0,0,0,115,34,0, - 0,0,124,0,0,106,0,0,124,1,0,106,0,0,107,2, - 0,111,33,0,124,0,0,106,1,0,124,1,0,106,1,0, - 107,2,0,83,41,1,78,41,2,114,224,0,0,0,114,63, - 0,0,0,41,2,114,71,0,0,0,114,227,0,0,0,114, - 4,0,0,0,114,4,0,0,0,114,5,0,0,0,114,229, - 0,0,0,21,6,0,0,115,4,0,0,0,0,1,18,1, - 122,17,70,105,108,101,76,111,97,100,101,114,46,95,95,101, - 113,95,95,99,1,0,0,0,0,0,0,0,1,0,0,0, - 3,0,0,0,67,0,0,0,115,26,0,0,0,116,0,0, - 124,0,0,106,1,0,131,1,0,116,0,0,124,0,0,106, - 2,0,131,1,0,65,83,41,1,78,41,3,218,4,104,97, - 115,104,114,67,0,0,0,114,35,0,0,0,41,1,114,71, - 0,0,0,114,4,0,0,0,114,4,0,0,0,114,5,0, - 0,0,218,8,95,95,104,97,115,104,95,95,25,6,0,0, - 115,2,0,0,0,0,1,122,19,70,105,108,101,76,111,97, - 100,101,114,46,95,95,104,97,115,104,95,95,99,2,0,0, - 0,0,0,0,0,2,0,0,0,3,0,0,0,3,0,0, - 0,115,22,0,0,0,116,0,0,116,1,0,124,0,0,131, - 2,0,106,2,0,124,1,0,131,1,0,83,41,1,122,100, - 76,111,97,100,32,97,32,109,111,100,117,108,101,32,102,114, - 111,109,32,97,32,102,105,108,101,46,10,10,32,32,32,32, - 32,32,32,32,84,104,105,115,32,109,101,116,104,111,100,32, - 105,115,32,100,101,112,114,101,99,97,116,101,100,46,32,32, - 85,115,101,32,101,120,101,99,95,109,111,100,117,108,101,40, - 41,32,105,110,115,116,101,97,100,46,10,10,32,32,32,32, - 32,32,32,32,41,3,218,5,115,117,112,101,114,114,48,1, - 0,0,114,3,1,0,0,41,2,114,71,0,0,0,114,159, - 0,0,0,41,1,114,224,0,0,0,114,4,0,0,0,114, - 5,0,0,0,114,3,1,0,0,28,6,0,0,115,2,0, - 0,0,0,10,122,22,70,105,108,101,76,111,97,100,101,114, - 46,108,111,97,100,95,109,111,100,117,108,101,99,2,0,0, - 0,0,0,0,0,2,0,0,0,1,0,0,0,67,0,0, - 0,115,7,0,0,0,124,0,0,106,0,0,83,41,1,122, - 58,82,101,116,117,114,110,32,116,104,101,32,112,97,116,104, - 32,116,111,32,116,104,101,32,115,111,117,114,99,101,32,102, - 105,108,101,32,97,115,32,102,111,117,110,100,32,98,121,32, - 116,104,101,32,102,105,110,100,101,114,46,41,1,114,35,0, - 0,0,41,2,114,71,0,0,0,114,159,0,0,0,114,4, - 0,0,0,114,4,0,0,0,114,5,0,0,0,114,238,0, - 0,0,40,6,0,0,115,2,0,0,0,0,3,122,23,70, - 105,108,101,76,111,97,100,101,114,46,103,101,116,95,102,105, - 108,101,110,97,109,101,99,2,0,0,0,0,0,0,0,3, - 0,0,0,8,0,0,0,67,0,0,0,115,41,0,0,0, - 116,0,0,106,1,0,124,1,0,100,1,0,131,2,0,143, - 17,0,125,2,0,124,2,0,106,2,0,131,0,0,83,87, - 100,2,0,81,88,100,2,0,83,41,3,122,39,82,101,116, - 117,114,110,32,116,104,101,32,100,97,116,97,32,102,114,111, - 109,32,112,97,116,104,32,97,115,32,114,97,119,32,98,121, - 116,101,115,46,218,1,114,78,41,3,114,49,0,0,0,114, - 50,0,0,0,90,4,114,101,97,100,41,3,114,71,0,0, - 0,114,35,0,0,0,114,54,0,0,0,114,4,0,0,0, - 114,4,0,0,0,114,5,0,0,0,114,39,1,0,0,45, - 6,0,0,115,4,0,0,0,0,2,21,1,122,19,70,105, - 108,101,76,111,97,100,101,114,46,103,101,116,95,100,97,116, - 97,41,11,114,57,0,0,0,114,56,0,0,0,114,58,0, - 0,0,114,59,0,0,0,114,72,0,0,0,114,229,0,0, - 0,114,50,1,0,0,114,157,0,0,0,114,3,1,0,0, - 114,238,0,0,0,114,39,1,0,0,114,4,0,0,0,114, - 4,0,0,0,41,1,114,224,0,0,0,114,5,0,0,0, - 114,48,1,0,0,10,6,0,0,115,14,0,0,0,12,3, - 6,2,12,6,12,4,12,3,24,12,18,5,114,48,1,0, - 0,99,0,0,0,0,0,0,0,0,0,0,0,0,4,0, - 0,0,64,0,0,0,115,64,0,0,0,101,0,0,90,1, - 0,100,0,0,90,2,0,100,1,0,90,3,0,100,2,0, - 100,3,0,132,0,0,90,4,0,100,4,0,100,5,0,132, - 0,0,90,5,0,100,6,0,100,7,0,100,8,0,100,9, - 0,132,0,1,90,6,0,100,10,0,83,41,11,114,7,1, - 0,0,122,62,67,111,110,99,114,101,116,101,32,105,109,112, - 108,101,109,101,110,116,97,116,105,111,110,32,111,102,32,83, - 111,117,114,99,101,76,111,97,100,101,114,32,117,115,105,110, - 103,32,116,104,101,32,102,105,108,101,32,115,121,115,116,101, - 109,46,99,2,0,0,0,0,0,0,0,3,0,0,0,3, - 0,0,0,67,0,0,0,115,36,0,0,0,116,0,0,124, - 1,0,131,1,0,125,2,0,105,2,0,124,2,0,106,1, - 0,100,1,0,54,124,2,0,106,2,0,100,2,0,54,83, - 41,3,122,33,82,101,116,117,114,110,32,116,104,101,32,109, - 101,116,97,100,97,116,97,32,102,111,114,32,116,104,101,32, - 112,97,116,104,46,114,182,0,0,0,114,183,0,0,0,41, - 3,114,39,0,0,0,218,8,115,116,95,109,116,105,109,101, - 90,7,115,116,95,115,105,122,101,41,3,114,71,0,0,0, - 114,35,0,0,0,114,46,1,0,0,114,4,0,0,0,114, - 4,0,0,0,114,5,0,0,0,114,36,1,0,0,55,6, - 0,0,115,4,0,0,0,0,2,12,1,122,27,83,111,117, - 114,99,101,70,105,108,101,76,111,97,100,101,114,46,112,97, - 116,104,95,115,116,97,116,115,99,4,0,0,0,0,0,0, - 0,5,0,0,0,5,0,0,0,67,0,0,0,115,34,0, - 0,0,116,0,0,124,1,0,131,1,0,125,4,0,124,0, - 0,106,1,0,124,2,0,124,3,0,100,1,0,124,4,0, - 131,2,1,83,41,2,78,218,5,95,109,111,100,101,41,2, - 114,145,0,0,0,114,37,1,0,0,41,5,114,71,0,0, - 0,114,142,0,0,0,114,141,0,0,0,114,53,0,0,0, - 114,42,0,0,0,114,4,0,0,0,114,4,0,0,0,114, - 5,0,0,0,114,38,1,0,0,60,6,0,0,115,4,0, - 0,0,0,2,12,1,122,32,83,111,117,114,99,101,70,105, - 108,101,76,111,97,100,101,114,46,95,99,97,99,104,101,95, - 98,121,116,101,99,111,100,101,114,54,1,0,0,105,182,1, - 0,0,99,3,0,0,0,1,0,0,0,9,0,0,0,17, - 0,0,0,67,0,0,0,115,53,1,0,0,116,0,0,124, - 1,0,131,1,0,92,2,0,125,4,0,125,5,0,103,0, - 0,125,6,0,120,54,0,124,4,0,114,80,0,116,1,0, - 124,4,0,131,1,0,12,114,80,0,116,0,0,124,4,0, - 131,1,0,92,2,0,125,4,0,125,7,0,124,6,0,106, - 2,0,124,7,0,131,1,0,1,113,27,0,87,120,132,0, - 116,3,0,124,6,0,131,1,0,68,93,118,0,125,7,0, - 116,4,0,124,4,0,124,7,0,131,2,0,125,4,0,121, - 17,0,116,5,0,106,6,0,124,4,0,131,1,0,1,87, - 113,94,0,4,116,7,0,107,10,0,114,155,0,1,1,1, - 119,94,0,89,113,94,0,4,116,8,0,107,10,0,114,211, - 0,1,125,8,0,1,122,25,0,116,9,0,100,1,0,124, - 4,0,124,8,0,131,3,0,1,100,2,0,83,87,89,100, - 2,0,100,2,0,125,8,0,126,8,0,88,113,94,0,88, - 113,94,0,87,121,33,0,116,10,0,124,1,0,124,2,0, - 124,3,0,131,3,0,1,116,9,0,100,3,0,124,1,0, - 131,2,0,1,87,110,53,0,4,116,8,0,107,10,0,114, - 48,1,1,125,8,0,1,122,21,0,116,9,0,100,1,0, - 124,1,0,124,8,0,131,3,0,1,87,89,100,2,0,100, - 2,0,125,8,0,126,8,0,88,110,1,0,88,100,2,0, - 83,41,4,122,27,87,114,105,116,101,32,98,121,116,101,115, - 32,100,97,116,97,32,116,111,32,97,32,102,105,108,101,46, - 122,27,99,111,117,108,100,32,110,111,116,32,99,114,101,97, - 116,101,32,123,33,114,125,58,32,123,33,114,125,78,122,12, - 99,114,101,97,116,101,100,32,123,33,114,125,41,11,114,38, - 0,0,0,114,46,0,0,0,114,223,0,0,0,114,33,0, - 0,0,114,28,0,0,0,114,3,0,0,0,90,5,109,107, - 100,105,114,218,15,70,105,108,101,69,120,105,115,116,115,69, - 114,114,111,114,114,40,0,0,0,114,153,0,0,0,114,55, - 0,0,0,41,9,114,71,0,0,0,114,35,0,0,0,114, - 53,0,0,0,114,54,1,0,0,114,233,0,0,0,114,131, - 0,0,0,114,27,0,0,0,114,23,0,0,0,114,40,1, - 0,0,114,4,0,0,0,114,4,0,0,0,114,5,0,0, - 0,114,37,1,0,0,65,6,0,0,115,38,0,0,0,0, - 2,18,1,6,2,22,1,18,1,17,2,19,1,15,1,3, - 1,17,1,13,2,7,1,18,3,16,1,27,1,3,1,16, - 1,17,1,18,2,122,25,83,111,117,114,99,101,70,105,108, - 101,76,111,97,100,101,114,46,115,101,116,95,100,97,116,97, - 78,41,7,114,57,0,0,0,114,56,0,0,0,114,58,0, - 0,0,114,59,0,0,0,114,36,1,0,0,114,38,1,0, - 0,114,37,1,0,0,114,4,0,0,0,114,4,0,0,0, - 114,4,0,0,0,114,5,0,0,0,114,7,1,0,0,51, - 6,0,0,115,8,0,0,0,12,2,6,2,12,5,12,5, - 114,7,1,0,0,99,0,0,0,0,0,0,0,0,0,0, - 0,0,2,0,0,0,64,0,0,0,115,46,0,0,0,101, - 0,0,90,1,0,100,0,0,90,2,0,100,1,0,90,3, - 0,100,2,0,100,3,0,132,0,0,90,4,0,100,4,0, - 100,5,0,132,0,0,90,5,0,100,6,0,83,41,7,114, - 6,1,0,0,122,45,76,111,97,100,101,114,32,119,104,105, - 99,104,32,104,97,110,100,108,101,115,32,115,111,117,114,99, - 101,108,101,115,115,32,102,105,108,101,32,105,109,112,111,114, - 116,115,46,99,2,0,0,0,0,0,0,0,5,0,0,0, - 6,0,0,0,67,0,0,0,115,76,0,0,0,124,0,0, - 106,0,0,124,1,0,131,1,0,125,2,0,124,0,0,106, - 1,0,124,2,0,131,1,0,125,3,0,116,2,0,124,3, - 0,100,1,0,124,1,0,100,2,0,124,2,0,131,1,2, - 125,4,0,116,3,0,124,4,0,100,1,0,124,1,0,100, - 3,0,124,2,0,131,1,2,83,41,4,78,114,67,0,0, - 0,114,35,0,0,0,114,141,0,0,0,41,4,114,238,0, - 0,0,114,39,1,0,0,114,189,0,0,0,114,194,0,0, - 0,41,5,114,71,0,0,0,114,159,0,0,0,114,35,0, - 0,0,114,53,0,0,0,114,47,1,0,0,114,4,0,0, - 0,114,4,0,0,0,114,5,0,0,0,114,14,1,0,0, - 98,6,0,0,115,8,0,0,0,0,1,15,1,15,1,24, - 1,122,29,83,111,117,114,99,101,108,101,115,115,70,105,108, - 101,76,111,97,100,101,114,46,103,101,116,95,99,111,100,101, - 99,2,0,0,0,0,0,0,0,2,0,0,0,1,0,0, - 0,67,0,0,0,115,4,0,0,0,100,1,0,83,41,2, - 122,39,82,101,116,117,114,110,32,78,111,110,101,32,97,115, - 32,116,104,101,114,101,32,105,115,32,110,111,32,115,111,117, - 114,99,101,32,99,111,100,101,46,78,114,4,0,0,0,41, - 2,114,71,0,0,0,114,159,0,0,0,114,4,0,0,0, - 114,4,0,0,0,114,5,0,0,0,114,15,1,0,0,104, - 6,0,0,115,2,0,0,0,0,2,122,31,83,111,117,114, - 99,101,108,101,115,115,70,105,108,101,76,111,97,100,101,114, - 46,103,101,116,95,115,111,117,114,99,101,78,41,6,114,57, - 0,0,0,114,56,0,0,0,114,58,0,0,0,114,59,0, - 0,0,114,14,1,0,0,114,15,1,0,0,114,4,0,0, - 0,114,4,0,0,0,114,4,0,0,0,114,5,0,0,0, - 114,6,1,0,0,94,6,0,0,115,6,0,0,0,12,2, - 6,2,12,6,114,6,1,0,0,99,0,0,0,0,0,0, - 0,0,0,0,0,0,3,0,0,0,64,0,0,0,115,130, - 0,0,0,101,0,0,90,1,0,100,0,0,90,2,0,100, - 1,0,90,3,0,100,2,0,100,3,0,132,0,0,90,4, - 0,100,4,0,100,5,0,132,0,0,90,5,0,100,6,0, - 100,7,0,132,0,0,90,6,0,101,7,0,100,8,0,100, - 9,0,132,0,0,131,1,0,90,8,0,100,10,0,100,11, - 0,132,0,0,90,9,0,100,12,0,100,13,0,132,0,0, - 90,10,0,100,14,0,100,15,0,132,0,0,90,11,0,101, - 7,0,100,16,0,100,17,0,132,0,0,131,1,0,90,12, - 0,100,18,0,83,41,19,218,19,69,120,116,101,110,115,105, - 111,110,70,105,108,101,76,111,97,100,101,114,122,93,76,111, - 97,100,101,114,32,102,111,114,32,101,120,116,101,110,115,105, - 111,110,32,109,111,100,117,108,101,115,46,10,10,32,32,32, - 32,84,104,101,32,99,111,110,115,116,114,117,99,116,111,114, - 32,105,115,32,100,101,115,105,103,110,101,100,32,116,111,32, - 119,111,114,107,32,119,105,116,104,32,70,105,108,101,70,105, - 110,100,101,114,46,10,10,32,32,32,32,99,3,0,0,0, - 0,0,0,0,3,0,0,0,2,0,0,0,67,0,0,0, - 115,22,0,0,0,124,1,0,124,0,0,95,0,0,124,2, - 0,124,0,0,95,1,0,100,0,0,83,41,1,78,41,2, - 114,67,0,0,0,114,35,0,0,0,41,3,114,71,0,0, - 0,114,67,0,0,0,114,35,0,0,0,114,4,0,0,0, - 114,4,0,0,0,114,5,0,0,0,114,72,0,0,0,121, - 6,0,0,115,4,0,0,0,0,1,9,1,122,28,69,120, - 116,101,110,115,105,111,110,70,105,108,101,76,111,97,100,101, - 114,46,95,95,105,110,105,116,95,95,99,2,0,0,0,0, - 0,0,0,2,0,0,0,2,0,0,0,67,0,0,0,115, - 34,0,0,0,124,0,0,106,0,0,124,1,0,106,0,0, - 107,2,0,111,33,0,124,0,0,106,1,0,124,1,0,106, - 1,0,107,2,0,83,41,1,78,41,2,114,224,0,0,0, - 114,63,0,0,0,41,2,114,71,0,0,0,114,227,0,0, - 0,114,4,0,0,0,114,4,0,0,0,114,5,0,0,0, - 114,229,0,0,0,125,6,0,0,115,4,0,0,0,0,1, - 18,1,122,26,69,120,116,101,110,115,105,111,110,70,105,108, - 101,76,111,97,100,101,114,46,95,95,101,113,95,95,99,1, - 0,0,0,0,0,0,0,1,0,0,0,3,0,0,0,67, - 0,0,0,115,26,0,0,0,116,0,0,124,0,0,106,1, - 0,131,1,0,116,0,0,124,0,0,106,2,0,131,1,0, - 65,83,41,1,78,41,3,114,49,1,0,0,114,67,0,0, - 0,114,35,0,0,0,41,1,114,71,0,0,0,114,4,0, - 0,0,114,4,0,0,0,114,5,0,0,0,114,50,1,0, - 0,129,6,0,0,115,2,0,0,0,0,1,122,28,69,120, - 116,101,110,115,105,111,110,70,105,108,101,76,111,97,100,101, - 114,46,95,95,104,97,115,104,95,95,99,2,0,0,0,0, - 0,0,0,4,0,0,0,11,0,0,0,67,0,0,0,115, - 177,0,0,0,116,0,0,124,1,0,131,1,0,143,29,0, - 1,116,1,0,116,2,0,106,3,0,124,1,0,124,0,0, - 106,4,0,131,3,0,125,2,0,87,100,1,0,81,88,116, - 5,0,100,2,0,124,0,0,106,4,0,131,2,0,1,124, - 0,0,106,6,0,124,1,0,131,1,0,125,3,0,124,3, - 0,114,121,0,116,7,0,124,2,0,100,3,0,131,2,0, - 12,114,121,0,116,8,0,124,0,0,106,4,0,131,1,0, - 100,4,0,25,103,1,0,124,2,0,95,9,0,124,0,0, - 124,2,0,95,10,0,124,2,0,106,11,0,124,2,0,95, - 12,0,124,3,0,115,173,0,124,2,0,106,12,0,106,13, - 0,100,5,0,131,1,0,100,4,0,25,124,2,0,95,12, - 0,124,2,0,83,41,6,122,25,76,111,97,100,32,97,110, - 32,101,120,116,101,110,115,105,111,110,32,109,111,100,117,108, - 101,46,78,122,33,101,120,116,101,110,115,105,111,110,32,109, - 111,100,117,108,101,32,108,111,97,100,101,100,32,102,114,111, - 109,32,123,33,114,125,114,246,0,0,0,114,84,0,0,0, - 114,116,0,0,0,41,14,114,69,0,0,0,114,114,0,0, - 0,114,106,0,0,0,90,12,108,111,97,100,95,100,121,110, - 97,109,105,99,114,35,0,0,0,114,153,0,0,0,114,219, - 0,0,0,114,60,0,0,0,114,38,0,0,0,114,246,0, - 0,0,114,203,0,0,0,114,57,0,0,0,114,249,0,0, - 0,114,32,0,0,0,41,4,114,71,0,0,0,114,159,0, - 0,0,114,178,0,0,0,114,219,0,0,0,114,4,0,0, - 0,114,4,0,0,0,114,5,0,0,0,114,3,1,0,0, - 132,6,0,0,115,24,0,0,0,0,5,13,1,9,1,21, - 1,16,1,15,1,22,1,25,1,9,1,12,1,6,1,25, - 1,122,31,69,120,116,101,110,115,105,111,110,70,105,108,101, - 76,111,97,100,101,114,46,108,111,97,100,95,109,111,100,117, - 108,101,99,2,0,0,0,0,0,0,0,2,0,0,0,4, - 0,0,0,3,0,0,0,115,48,0,0,0,116,0,0,124, - 0,0,106,1,0,131,1,0,100,1,0,25,137,0,0,116, - 2,0,135,0,0,102,1,0,100,2,0,100,3,0,134,0, - 0,116,3,0,68,131,1,0,131,1,0,83,41,4,122,49, - 82,101,116,117,114,110,32,84,114,117,101,32,105,102,32,116, - 104,101,32,101,120,116,101,110,115,105,111,110,32,109,111,100, - 117,108,101,32,105,115,32,97,32,112,97,99,107,97,103,101, - 46,114,29,0,0,0,99,1,0,0,0,0,0,0,0,2, - 0,0,0,4,0,0,0,51,0,0,0,115,31,0,0,0, - 124,0,0,93,21,0,125,1,0,136,0,0,100,0,0,124, - 1,0,23,107,2,0,86,1,113,3,0,100,1,0,83,41, - 2,114,72,0,0,0,78,114,4,0,0,0,41,2,114,22, - 0,0,0,218,6,115,117,102,102,105,120,41,1,218,9,102, - 105,108,101,95,110,97,109,101,114,4,0,0,0,114,5,0, - 0,0,114,77,0,0,0,153,6,0,0,115,2,0,0,0, - 6,1,122,49,69,120,116,101,110,115,105,111,110,70,105,108, - 101,76,111,97,100,101,114,46,105,115,95,112,97,99,107,97, - 103,101,46,60,108,111,99,97,108,115,62,46,60,103,101,110, - 101,120,112,114,62,41,4,114,38,0,0,0,114,35,0,0, - 0,114,78,0,0,0,218,18,69,88,84,69,78,83,73,79, - 78,95,83,85,70,70,73,88,69,83,41,2,114,71,0,0, - 0,114,159,0,0,0,114,4,0,0,0,41,1,114,58,1, - 0,0,114,5,0,0,0,114,219,0,0,0,150,6,0,0, - 115,6,0,0,0,0,2,19,1,18,1,122,30,69,120,116, - 101,110,115,105,111,110,70,105,108,101,76,111,97,100,101,114, - 46,105,115,95,112,97,99,107,97,103,101,99,2,0,0,0, - 0,0,0,0,2,0,0,0,1,0,0,0,67,0,0,0, - 115,4,0,0,0,100,1,0,83,41,2,122,63,82,101,116, - 117,114,110,32,78,111,110,101,32,97,115,32,97,110,32,101, - 120,116,101,110,115,105,111,110,32,109,111,100,117,108,101,32, - 99,97,110,110,111,116,32,99,114,101,97,116,101,32,97,32, - 99,111,100,101,32,111,98,106,101,99,116,46,78,114,4,0, - 0,0,41,2,114,71,0,0,0,114,159,0,0,0,114,4, - 0,0,0,114,4,0,0,0,114,5,0,0,0,114,14,1, - 0,0,156,6,0,0,115,2,0,0,0,0,2,122,28,69, - 120,116,101,110,115,105,111,110,70,105,108,101,76,111,97,100, - 101,114,46,103,101,116,95,99,111,100,101,99,2,0,0,0, - 0,0,0,0,2,0,0,0,1,0,0,0,67,0,0,0, - 115,4,0,0,0,100,1,0,83,41,2,122,53,82,101,116, - 117,114,110,32,78,111,110,101,32,97,115,32,101,120,116,101, - 110,115,105,111,110,32,109,111,100,117,108,101,115,32,104,97, - 118,101,32,110,111,32,115,111,117,114,99,101,32,99,111,100, - 101,46,78,114,4,0,0,0,41,2,114,71,0,0,0,114, - 159,0,0,0,114,4,0,0,0,114,4,0,0,0,114,5, - 0,0,0,114,15,1,0,0,160,6,0,0,115,2,0,0, - 0,0,2,122,30,69,120,116,101,110,115,105,111,110,70,105, - 108,101,76,111,97,100,101,114,46,103,101,116,95,115,111,117, - 114,99,101,99,2,0,0,0,0,0,0,0,2,0,0,0, - 1,0,0,0,67,0,0,0,115,7,0,0,0,124,0,0, - 106,0,0,83,41,1,122,58,82,101,116,117,114,110,32,116, - 104,101,32,112,97,116,104,32,116,111,32,116,104,101,32,115, - 111,117,114,99,101,32,102,105,108,101,32,97,115,32,102,111, - 117,110,100,32,98,121,32,116,104,101,32,102,105,110,100,101, - 114,46,41,1,114,35,0,0,0,41,2,114,71,0,0,0, - 114,159,0,0,0,114,4,0,0,0,114,4,0,0,0,114, - 5,0,0,0,114,238,0,0,0,164,6,0,0,115,2,0, - 0,0,0,3,122,32,69,120,116,101,110,115,105,111,110,70, - 105,108,101,76,111,97,100,101,114,46,103,101,116,95,102,105, - 108,101,110,97,109,101,78,41,13,114,57,0,0,0,114,56, - 0,0,0,114,58,0,0,0,114,59,0,0,0,114,72,0, - 0,0,114,229,0,0,0,114,50,1,0,0,114,157,0,0, - 0,114,3,1,0,0,114,219,0,0,0,114,14,1,0,0, - 114,15,1,0,0,114,238,0,0,0,114,4,0,0,0,114, - 4,0,0,0,114,4,0,0,0,114,5,0,0,0,114,56, - 1,0,0,113,6,0,0,115,18,0,0,0,12,6,6,2, - 12,4,12,4,12,3,18,18,12,6,12,4,12,4,114,56, + 0,0,114,33,1,0,0,152,5,0,0,115,14,0,0,0, + 12,2,12,8,12,13,12,10,12,7,12,10,18,8,114,33, 1,0,0,99,0,0,0,0,0,0,0,0,0,0,0,0, - 2,0,0,0,64,0,0,0,115,130,0,0,0,101,0,0, + 4,0,0,0,0,0,0,0,115,112,0,0,0,101,0,0, 90,1,0,100,0,0,90,2,0,100,1,0,90,3,0,100, 2,0,100,3,0,132,0,0,90,4,0,100,4,0,100,5, 0,132,0,0,90,5,0,100,6,0,100,7,0,132,0,0, - 90,6,0,100,8,0,100,9,0,132,0,0,90,7,0,100, - 10,0,100,11,0,132,0,0,90,8,0,100,12,0,100,13, - 0,132,0,0,90,9,0,100,14,0,100,15,0,132,0,0, - 90,10,0,100,16,0,100,17,0,132,0,0,90,11,0,100, - 18,0,100,19,0,132,0,0,90,12,0,100,20,0,83,41, - 21,218,14,95,78,97,109,101,115,112,97,99,101,80,97,116, - 104,97,38,1,0,0,82,101,112,114,101,115,101,110,116,115, - 32,97,32,110,97,109,101,115,112,97,99,101,32,112,97,99, - 107,97,103,101,39,115,32,112,97,116,104,46,32,32,73,116, - 32,117,115,101,115,32,116,104,101,32,109,111,100,117,108,101, - 32,110,97,109,101,10,32,32,32,32,116,111,32,102,105,110, - 100,32,105,116,115,32,112,97,114,101,110,116,32,109,111,100, - 117,108,101,44,32,97,110,100,32,102,114,111,109,32,116,104, - 101,114,101,32,105,116,32,108,111,111,107,115,32,117,112,32, - 116,104,101,32,112,97,114,101,110,116,39,115,10,32,32,32, - 32,95,95,112,97,116,104,95,95,46,32,32,87,104,101,110, - 32,116,104,105,115,32,99,104,97,110,103,101,115,44,32,116, - 104,101,32,109,111,100,117,108,101,39,115,32,111,119,110,32, - 112,97,116,104,32,105,115,32,114,101,99,111,109,112,117,116, - 101,100,44,10,32,32,32,32,117,115,105,110,103,32,112,97, - 116,104,95,102,105,110,100,101,114,46,32,32,70,111,114,32, - 116,111,112,45,108,101,118,101,108,32,109,111,100,117,108,101, - 115,44,32,116,104,101,32,112,97,114,101,110,116,32,109,111, - 100,117,108,101,39,115,32,112,97,116,104,10,32,32,32,32, - 105,115,32,115,121,115,46,112,97,116,104,46,99,4,0,0, - 0,0,0,0,0,4,0,0,0,2,0,0,0,67,0,0, - 0,115,52,0,0,0,124,1,0,124,0,0,95,0,0,124, - 2,0,124,0,0,95,1,0,116,2,0,124,0,0,106,3, - 0,131,0,0,131,1,0,124,0,0,95,4,0,124,3,0, - 124,0,0,95,5,0,100,0,0,83,41,1,78,41,6,114, - 70,0,0,0,114,252,0,0,0,114,231,0,0,0,218,16, - 95,103,101,116,95,112,97,114,101,110,116,95,112,97,116,104, - 218,17,95,108,97,115,116,95,112,97,114,101,110,116,95,112, - 97,116,104,218,12,95,112,97,116,104,95,102,105,110,100,101, - 114,41,4,114,71,0,0,0,114,67,0,0,0,114,35,0, - 0,0,218,11,112,97,116,104,95,102,105,110,100,101,114,114, - 4,0,0,0,114,4,0,0,0,114,5,0,0,0,114,72, - 0,0,0,177,6,0,0,115,8,0,0,0,0,1,9,1, - 9,1,21,1,122,23,95,78,97,109,101,115,112,97,99,101, - 80,97,116,104,46,95,95,105,110,105,116,95,95,99,1,0, - 0,0,0,0,0,0,4,0,0,0,3,0,0,0,67,0, - 0,0,115,53,0,0,0,124,0,0,106,0,0,106,1,0, - 100,1,0,131,1,0,92,3,0,125,1,0,125,2,0,125, - 3,0,124,2,0,100,2,0,107,2,0,114,43,0,100,6, - 0,83,124,1,0,100,5,0,102,2,0,83,41,7,122,62, - 82,101,116,117,114,110,115,32,97,32,116,117,112,108,101,32, - 111,102,32,40,112,97,114,101,110,116,45,109,111,100,117,108, - 101,45,110,97,109,101,44,32,112,97,114,101,110,116,45,112, - 97,116,104,45,97,116,116,114,45,110,97,109,101,41,114,116, - 0,0,0,114,30,0,0,0,114,7,0,0,0,114,35,0, - 0,0,114,246,0,0,0,41,2,122,3,115,121,115,122,4, - 112,97,116,104,41,2,114,70,0,0,0,114,32,0,0,0, - 41,4,114,71,0,0,0,114,233,0,0,0,218,3,100,111, - 116,114,94,0,0,0,114,4,0,0,0,114,4,0,0,0, - 114,5,0,0,0,218,23,95,102,105,110,100,95,112,97,114, - 101,110,116,95,112,97,116,104,95,110,97,109,101,115,183,6, - 0,0,115,8,0,0,0,0,2,27,1,12,2,4,3,122, - 38,95,78,97,109,101,115,112,97,99,101,80,97,116,104,46, - 95,102,105,110,100,95,112,97,114,101,110,116,95,112,97,116, - 104,95,110,97,109,101,115,99,1,0,0,0,0,0,0,0, - 3,0,0,0,3,0,0,0,67,0,0,0,115,38,0,0, - 0,124,0,0,106,0,0,131,0,0,92,2,0,125,1,0, - 125,2,0,116,1,0,116,2,0,106,3,0,124,1,0,25, - 124,2,0,131,2,0,83,41,1,78,41,4,114,66,1,0, - 0,114,62,0,0,0,114,7,0,0,0,114,73,0,0,0, - 41,3,114,71,0,0,0,90,18,112,97,114,101,110,116,95, - 109,111,100,117,108,101,95,110,97,109,101,90,14,112,97,116, - 104,95,97,116,116,114,95,110,97,109,101,114,4,0,0,0, - 114,4,0,0,0,114,5,0,0,0,114,61,1,0,0,193, - 6,0,0,115,4,0,0,0,0,1,18,1,122,31,95,78, - 97,109,101,115,112,97,99,101,80,97,116,104,46,95,103,101, - 116,95,112,97,114,101,110,116,95,112,97,116,104,99,1,0, - 0,0,0,0,0,0,3,0,0,0,3,0,0,0,67,0, - 0,0,115,118,0,0,0,116,0,0,124,0,0,106,1,0, - 131,0,0,131,1,0,125,1,0,124,1,0,124,0,0,106, - 2,0,107,3,0,114,111,0,124,0,0,106,3,0,124,0, - 0,106,4,0,124,1,0,131,2,0,125,2,0,124,2,0, - 100,0,0,107,9,0,114,102,0,124,2,0,106,5,0,100, - 0,0,107,8,0,114,102,0,124,2,0,106,6,0,114,102, - 0,124,2,0,106,6,0,124,0,0,95,7,0,124,1,0, - 124,0,0,95,2,0,124,0,0,106,7,0,83,41,1,78, - 41,8,114,231,0,0,0,114,61,1,0,0,114,62,1,0, - 0,114,63,1,0,0,114,70,0,0,0,114,170,0,0,0, - 114,220,0,0,0,114,252,0,0,0,41,3,114,71,0,0, - 0,90,11,112,97,114,101,110,116,95,112,97,116,104,114,177, - 0,0,0,114,4,0,0,0,114,4,0,0,0,114,5,0, - 0,0,218,12,95,114,101,99,97,108,99,117,108,97,116,101, - 197,6,0,0,115,16,0,0,0,0,2,18,1,15,1,21, - 3,27,1,9,1,12,1,9,1,122,27,95,78,97,109,101, - 115,112,97,99,101,80,97,116,104,46,95,114,101,99,97,108, - 99,117,108,97,116,101,99,1,0,0,0,0,0,0,0,1, - 0,0,0,2,0,0,0,67,0,0,0,115,16,0,0,0, - 116,0,0,124,0,0,106,1,0,131,0,0,131,1,0,83, - 41,1,78,41,2,218,4,105,116,101,114,114,67,1,0,0, - 41,1,114,71,0,0,0,114,4,0,0,0,114,4,0,0, - 0,114,5,0,0,0,218,8,95,95,105,116,101,114,95,95, - 210,6,0,0,115,2,0,0,0,0,1,122,23,95,78,97, - 109,101,115,112,97,99,101,80,97,116,104,46,95,95,105,116, - 101,114,95,95,99,1,0,0,0,0,0,0,0,1,0,0, - 0,2,0,0,0,67,0,0,0,115,16,0,0,0,116,0, - 0,124,0,0,106,1,0,131,0,0,131,1,0,83,41,1, - 78,41,2,114,31,0,0,0,114,67,1,0,0,41,1,114, - 71,0,0,0,114,4,0,0,0,114,4,0,0,0,114,5, - 0,0,0,218,7,95,95,108,101,110,95,95,213,6,0,0, - 115,2,0,0,0,0,1,122,22,95,78,97,109,101,115,112, - 97,99,101,80,97,116,104,46,95,95,108,101,110,95,95,99, - 1,0,0,0,0,0,0,0,1,0,0,0,2,0,0,0, - 67,0,0,0,115,16,0,0,0,100,1,0,106,0,0,124, - 0,0,106,1,0,131,1,0,83,41,2,78,122,20,95,78, - 97,109,101,115,112,97,99,101,80,97,116,104,40,123,33,114, - 125,41,41,2,114,47,0,0,0,114,252,0,0,0,41,1, - 114,71,0,0,0,114,4,0,0,0,114,4,0,0,0,114, - 5,0,0,0,114,101,0,0,0,216,6,0,0,115,2,0, - 0,0,0,1,122,23,95,78,97,109,101,115,112,97,99,101, - 80,97,116,104,46,95,95,114,101,112,114,95,95,99,2,0, - 0,0,0,0,0,0,2,0,0,0,2,0,0,0,67,0, - 0,0,115,16,0,0,0,124,1,0,124,0,0,106,0,0, - 131,0,0,107,6,0,83,41,1,78,41,1,114,67,1,0, - 0,41,2,114,71,0,0,0,218,4,105,116,101,109,114,4, - 0,0,0,114,4,0,0,0,114,5,0,0,0,218,12,95, - 95,99,111,110,116,97,105,110,115,95,95,219,6,0,0,115, - 2,0,0,0,0,1,122,27,95,78,97,109,101,115,112,97, - 99,101,80,97,116,104,46,95,95,99,111,110,116,97,105,110, - 115,95,95,99,2,0,0,0,0,0,0,0,2,0,0,0, - 2,0,0,0,67,0,0,0,115,20,0,0,0,124,0,0, - 106,0,0,106,1,0,124,1,0,131,1,0,1,100,0,0, - 83,41,1,78,41,2,114,252,0,0,0,114,223,0,0,0, - 41,2,114,71,0,0,0,114,71,1,0,0,114,4,0,0, - 0,114,4,0,0,0,114,5,0,0,0,114,223,0,0,0, - 222,6,0,0,115,2,0,0,0,0,1,122,21,95,78,97, - 109,101,115,112,97,99,101,80,97,116,104,46,97,112,112,101, - 110,100,78,41,13,114,57,0,0,0,114,56,0,0,0,114, - 58,0,0,0,114,59,0,0,0,114,72,0,0,0,114,66, - 1,0,0,114,61,1,0,0,114,67,1,0,0,114,69,1, - 0,0,114,70,1,0,0,114,101,0,0,0,114,72,1,0, - 0,114,223,0,0,0,114,4,0,0,0,114,4,0,0,0, - 114,4,0,0,0,114,5,0,0,0,114,60,1,0,0,170, - 6,0,0,115,20,0,0,0,12,5,6,2,12,6,12,10, - 12,4,12,13,12,3,12,3,12,3,12,3,114,60,1,0, - 0,99,0,0,0,0,0,0,0,0,0,0,0,0,3,0, - 0,0,64,0,0,0,115,118,0,0,0,101,0,0,90,1, - 0,100,0,0,90,2,0,100,1,0,100,2,0,132,0,0, - 90,3,0,101,4,0,100,3,0,100,4,0,132,0,0,131, - 1,0,90,5,0,100,5,0,100,6,0,132,0,0,90,6, - 0,100,7,0,100,8,0,132,0,0,90,7,0,100,9,0, - 100,10,0,132,0,0,90,8,0,100,11,0,100,12,0,132, - 0,0,90,9,0,100,13,0,100,14,0,132,0,0,90,10, - 0,100,15,0,100,16,0,132,0,0,90,11,0,100,17,0, - 83,41,18,114,250,0,0,0,99,4,0,0,0,0,0,0, - 0,4,0,0,0,4,0,0,0,67,0,0,0,115,25,0, - 0,0,116,0,0,124,1,0,124,2,0,124,3,0,131,3, - 0,124,0,0,95,1,0,100,0,0,83,41,1,78,41,2, - 114,60,1,0,0,114,252,0,0,0,41,4,114,71,0,0, - 0,114,67,0,0,0,114,35,0,0,0,114,64,1,0,0, - 114,4,0,0,0,114,4,0,0,0,114,5,0,0,0,114, - 72,0,0,0,228,6,0,0,115,2,0,0,0,0,1,122, - 25,95,78,97,109,101,115,112,97,99,101,76,111,97,100,101, - 114,46,95,95,105,110,105,116,95,95,99,2,0,0,0,0, - 0,0,0,2,0,0,0,2,0,0,0,67,0,0,0,115, - 16,0,0,0,100,1,0,106,0,0,124,1,0,106,1,0, - 131,1,0,83,41,2,122,115,82,101,116,117,114,110,32,114, - 101,112,114,32,102,111,114,32,116,104,101,32,109,111,100,117, - 108,101,46,10,10,32,32,32,32,32,32,32,32,84,104,101, - 32,109,101,116,104,111,100,32,105,115,32,100,101,112,114,101, - 99,97,116,101,100,46,32,32,84,104,101,32,105,109,112,111, - 114,116,32,109,97,99,104,105,110,101,114,121,32,100,111,101, - 115,32,116,104,101,32,106,111,98,32,105,116,115,101,108,102, - 46,10,10,32,32,32,32,32,32,32,32,122,25,60,109,111, - 100,117,108,101,32,123,33,114,125,32,40,110,97,109,101,115, - 112,97,99,101,41,62,41,2,114,47,0,0,0,114,57,0, - 0,0,41,2,114,10,1,0,0,114,178,0,0,0,114,4, - 0,0,0,114,4,0,0,0,114,5,0,0,0,114,204,0, - 0,0,231,6,0,0,115,2,0,0,0,0,7,122,28,95, - 78,97,109,101,115,112,97,99,101,76,111,97,100,101,114,46, - 109,111,100,117,108,101,95,114,101,112,114,99,2,0,0,0, + 90,6,0,101,7,0,135,0,0,102,1,0,100,8,0,100, + 9,0,134,0,0,131,1,0,90,8,0,101,7,0,100,10, + 0,100,11,0,132,0,0,131,1,0,90,9,0,100,12,0, + 100,13,0,132,0,0,90,10,0,135,0,0,83,41,14,218, + 10,70,105,108,101,76,111,97,100,101,114,122,103,66,97,115, + 101,32,102,105,108,101,32,108,111,97,100,101,114,32,99,108, + 97,115,115,32,119,104,105,99,104,32,105,109,112,108,101,109, + 101,110,116,115,32,116,104,101,32,108,111,97,100,101,114,32, + 112,114,111,116,111,99,111,108,32,109,101,116,104,111,100,115, + 32,116,104,97,116,10,32,32,32,32,114,101,113,117,105,114, + 101,32,102,105,108,101,32,115,121,115,116,101,109,32,117,115, + 97,103,101,46,99,3,0,0,0,0,0,0,0,3,0,0, + 0,2,0,0,0,67,0,0,0,115,22,0,0,0,124,1, + 0,124,0,0,95,0,0,124,2,0,124,0,0,95,1,0, + 100,1,0,83,41,2,122,75,67,97,99,104,101,32,116,104, + 101,32,109,111,100,117,108,101,32,110,97,109,101,32,97,110, + 100,32,116,104,101,32,112,97,116,104,32,116,111,32,116,104, + 101,32,102,105,108,101,32,102,111,117,110,100,32,98,121,32, + 116,104,101,10,32,32,32,32,32,32,32,32,102,105,110,100, + 101,114,46,78,41,2,114,67,0,0,0,114,35,0,0,0, + 41,3,114,71,0,0,0,114,159,0,0,0,114,35,0,0, + 0,114,4,0,0,0,114,4,0,0,0,114,5,0,0,0, + 114,72,0,0,0,11,6,0,0,115,4,0,0,0,0,3, + 9,1,122,19,70,105,108,101,76,111,97,100,101,114,46,95, + 95,105,110,105,116,95,95,99,2,0,0,0,0,0,0,0, + 2,0,0,0,2,0,0,0,67,0,0,0,115,34,0,0, + 0,124,0,0,106,0,0,124,1,0,106,0,0,107,2,0, + 111,33,0,124,0,0,106,1,0,124,1,0,106,1,0,107, + 2,0,83,41,1,78,41,2,114,224,0,0,0,114,63,0, + 0,0,41,2,114,71,0,0,0,114,227,0,0,0,114,4, + 0,0,0,114,4,0,0,0,114,5,0,0,0,114,229,0, + 0,0,17,6,0,0,115,4,0,0,0,0,1,18,1,122, + 17,70,105,108,101,76,111,97,100,101,114,46,95,95,101,113, + 95,95,99,1,0,0,0,0,0,0,0,1,0,0,0,3, + 0,0,0,67,0,0,0,115,26,0,0,0,116,0,0,124, + 0,0,106,1,0,131,1,0,116,0,0,124,0,0,106,2, + 0,131,1,0,65,83,41,1,78,41,3,218,4,104,97,115, + 104,114,67,0,0,0,114,35,0,0,0,41,1,114,71,0, + 0,0,114,4,0,0,0,114,4,0,0,0,114,5,0,0, + 0,218,8,95,95,104,97,115,104,95,95,21,6,0,0,115, + 2,0,0,0,0,1,122,19,70,105,108,101,76,111,97,100, + 101,114,46,95,95,104,97,115,104,95,95,99,2,0,0,0, + 0,0,0,0,2,0,0,0,3,0,0,0,3,0,0,0, + 115,22,0,0,0,116,0,0,116,1,0,124,0,0,131,2, + 0,106,2,0,124,1,0,131,1,0,83,41,1,122,100,76, + 111,97,100,32,97,32,109,111,100,117,108,101,32,102,114,111, + 109,32,97,32,102,105,108,101,46,10,10,32,32,32,32,32, + 32,32,32,84,104,105,115,32,109,101,116,104,111,100,32,105, + 115,32,100,101,112,114,101,99,97,116,101,100,46,32,32,85, + 115,101,32,101,120,101,99,95,109,111,100,117,108,101,40,41, + 32,105,110,115,116,101,97,100,46,10,10,32,32,32,32,32, + 32,32,32,41,3,218,5,115,117,112,101,114,114,48,1,0, + 0,114,3,1,0,0,41,2,114,71,0,0,0,114,159,0, + 0,0,41,1,114,224,0,0,0,114,4,0,0,0,114,5, + 0,0,0,114,3,1,0,0,24,6,0,0,115,2,0,0, + 0,0,10,122,22,70,105,108,101,76,111,97,100,101,114,46, + 108,111,97,100,95,109,111,100,117,108,101,99,2,0,0,0, 0,0,0,0,2,0,0,0,1,0,0,0,67,0,0,0, - 115,4,0,0,0,100,1,0,83,41,2,78,84,114,4,0, - 0,0,41,2,114,71,0,0,0,114,159,0,0,0,114,4, - 0,0,0,114,4,0,0,0,114,5,0,0,0,114,219,0, - 0,0,240,6,0,0,115,2,0,0,0,0,1,122,27,95, - 78,97,109,101,115,112,97,99,101,76,111,97,100,101,114,46, - 105,115,95,112,97,99,107,97,103,101,99,2,0,0,0,0, - 0,0,0,2,0,0,0,1,0,0,0,67,0,0,0,115, - 4,0,0,0,100,1,0,83,41,2,78,114,30,0,0,0, + 115,7,0,0,0,124,0,0,106,0,0,83,41,1,122,58, + 82,101,116,117,114,110,32,116,104,101,32,112,97,116,104,32, + 116,111,32,116,104,101,32,115,111,117,114,99,101,32,102,105, + 108,101,32,97,115,32,102,111,117,110,100,32,98,121,32,116, + 104,101,32,102,105,110,100,101,114,46,41,1,114,35,0,0, + 0,41,2,114,71,0,0,0,114,159,0,0,0,114,4,0, + 0,0,114,4,0,0,0,114,5,0,0,0,114,238,0,0, + 0,36,6,0,0,115,2,0,0,0,0,3,122,23,70,105, + 108,101,76,111,97,100,101,114,46,103,101,116,95,102,105,108, + 101,110,97,109,101,99,2,0,0,0,0,0,0,0,3,0, + 0,0,8,0,0,0,67,0,0,0,115,41,0,0,0,116, + 0,0,106,1,0,124,1,0,100,1,0,131,2,0,143,17, + 0,125,2,0,124,2,0,106,2,0,131,0,0,83,87,100, + 2,0,81,88,100,2,0,83,41,3,122,39,82,101,116,117, + 114,110,32,116,104,101,32,100,97,116,97,32,102,114,111,109, + 32,112,97,116,104,32,97,115,32,114,97,119,32,98,121,116, + 101,115,46,218,1,114,78,41,3,114,49,0,0,0,114,50, + 0,0,0,90,4,114,101,97,100,41,3,114,71,0,0,0, + 114,35,0,0,0,114,54,0,0,0,114,4,0,0,0,114, + 4,0,0,0,114,5,0,0,0,114,39,1,0,0,41,6, + 0,0,115,4,0,0,0,0,2,21,1,122,19,70,105,108, + 101,76,111,97,100,101,114,46,103,101,116,95,100,97,116,97, + 41,11,114,57,0,0,0,114,56,0,0,0,114,58,0,0, + 0,114,59,0,0,0,114,72,0,0,0,114,229,0,0,0, + 114,50,1,0,0,114,157,0,0,0,114,3,1,0,0,114, + 238,0,0,0,114,39,1,0,0,114,4,0,0,0,114,4, + 0,0,0,41,1,114,224,0,0,0,114,5,0,0,0,114, + 48,1,0,0,6,6,0,0,115,14,0,0,0,12,3,6, + 2,12,6,12,4,12,3,24,12,18,5,114,48,1,0,0, + 99,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0, + 0,64,0,0,0,115,64,0,0,0,101,0,0,90,1,0, + 100,0,0,90,2,0,100,1,0,90,3,0,100,2,0,100, + 3,0,132,0,0,90,4,0,100,4,0,100,5,0,132,0, + 0,90,5,0,100,6,0,100,7,0,100,8,0,100,9,0, + 132,0,1,90,6,0,100,10,0,83,41,11,114,7,1,0, + 0,122,62,67,111,110,99,114,101,116,101,32,105,109,112,108, + 101,109,101,110,116,97,116,105,111,110,32,111,102,32,83,111, + 117,114,99,101,76,111,97,100,101,114,32,117,115,105,110,103, + 32,116,104,101,32,102,105,108,101,32,115,121,115,116,101,109, + 46,99,2,0,0,0,0,0,0,0,3,0,0,0,5,0, + 0,0,67,0,0,0,115,34,0,0,0,116,0,0,124,1, + 0,131,1,0,125,2,0,124,2,0,106,1,0,100,1,0, + 124,2,0,106,2,0,100,2,0,105,2,0,83,41,3,122, + 33,82,101,116,117,114,110,32,116,104,101,32,109,101,116,97, + 100,97,116,97,32,102,111,114,32,116,104,101,32,112,97,116, + 104,46,114,182,0,0,0,114,183,0,0,0,41,3,114,39, + 0,0,0,218,8,115,116,95,109,116,105,109,101,90,7,115, + 116,95,115,105,122,101,41,3,114,71,0,0,0,114,35,0, + 0,0,114,46,1,0,0,114,4,0,0,0,114,4,0,0, + 0,114,5,0,0,0,114,36,1,0,0,51,6,0,0,115, + 4,0,0,0,0,2,12,1,122,27,83,111,117,114,99,101, + 70,105,108,101,76,111,97,100,101,114,46,112,97,116,104,95, + 115,116,97,116,115,99,4,0,0,0,0,0,0,0,5,0, + 0,0,5,0,0,0,67,0,0,0,115,34,0,0,0,116, + 0,0,124,1,0,131,1,0,125,4,0,124,0,0,106,1, + 0,124,2,0,124,3,0,100,1,0,124,4,0,131,2,1, + 83,41,2,78,218,5,95,109,111,100,101,41,2,114,145,0, + 0,0,114,37,1,0,0,41,5,114,71,0,0,0,114,142, + 0,0,0,114,141,0,0,0,114,53,0,0,0,114,42,0, + 0,0,114,4,0,0,0,114,4,0,0,0,114,5,0,0, + 0,114,38,1,0,0,56,6,0,0,115,4,0,0,0,0, + 2,12,1,122,32,83,111,117,114,99,101,70,105,108,101,76, + 111,97,100,101,114,46,95,99,97,99,104,101,95,98,121,116, + 101,99,111,100,101,114,54,1,0,0,105,182,1,0,0,99, + 3,0,0,0,1,0,0,0,9,0,0,0,17,0,0,0, + 67,0,0,0,115,53,1,0,0,116,0,0,124,1,0,131, + 1,0,92,2,0,125,4,0,125,5,0,103,0,0,125,6, + 0,120,54,0,124,4,0,114,80,0,116,1,0,124,4,0, + 131,1,0,12,114,80,0,116,0,0,124,4,0,131,1,0, + 92,2,0,125,4,0,125,7,0,124,6,0,106,2,0,124, + 7,0,131,1,0,1,113,27,0,87,120,132,0,116,3,0, + 124,6,0,131,1,0,68,93,118,0,125,7,0,116,4,0, + 124,4,0,124,7,0,131,2,0,125,4,0,121,17,0,116, + 5,0,106,6,0,124,4,0,131,1,0,1,87,113,94,0, + 4,116,7,0,107,10,0,114,155,0,1,1,1,119,94,0, + 89,113,94,0,4,116,8,0,107,10,0,114,211,0,1,125, + 8,0,1,122,25,0,116,9,0,100,1,0,124,4,0,124, + 8,0,131,3,0,1,100,2,0,83,87,89,100,2,0,100, + 2,0,125,8,0,126,8,0,88,113,94,0,88,113,94,0, + 87,121,33,0,116,10,0,124,1,0,124,2,0,124,3,0, + 131,3,0,1,116,9,0,100,3,0,124,1,0,131,2,0, + 1,87,110,53,0,4,116,8,0,107,10,0,114,48,1,1, + 125,8,0,1,122,21,0,116,9,0,100,1,0,124,1,0, + 124,8,0,131,3,0,1,87,89,100,2,0,100,2,0,125, + 8,0,126,8,0,88,110,1,0,88,100,2,0,83,41,4, + 122,27,87,114,105,116,101,32,98,121,116,101,115,32,100,97, + 116,97,32,116,111,32,97,32,102,105,108,101,46,122,27,99, + 111,117,108,100,32,110,111,116,32,99,114,101,97,116,101,32, + 123,33,114,125,58,32,123,33,114,125,78,122,12,99,114,101, + 97,116,101,100,32,123,33,114,125,41,11,114,38,0,0,0, + 114,46,0,0,0,114,223,0,0,0,114,33,0,0,0,114, + 28,0,0,0,114,3,0,0,0,90,5,109,107,100,105,114, + 218,15,70,105,108,101,69,120,105,115,116,115,69,114,114,111, + 114,114,40,0,0,0,114,153,0,0,0,114,55,0,0,0, + 41,9,114,71,0,0,0,114,35,0,0,0,114,53,0,0, + 0,114,54,1,0,0,114,233,0,0,0,114,131,0,0,0, + 114,27,0,0,0,114,23,0,0,0,114,40,1,0,0,114, + 4,0,0,0,114,4,0,0,0,114,5,0,0,0,114,37, + 1,0,0,61,6,0,0,115,38,0,0,0,0,2,18,1, + 6,2,22,1,18,1,17,2,19,1,15,1,3,1,17,1, + 13,2,7,1,18,3,16,1,27,1,3,1,16,1,17,1, + 18,2,122,25,83,111,117,114,99,101,70,105,108,101,76,111, + 97,100,101,114,46,115,101,116,95,100,97,116,97,78,41,7, + 114,57,0,0,0,114,56,0,0,0,114,58,0,0,0,114, + 59,0,0,0,114,36,1,0,0,114,38,1,0,0,114,37, + 1,0,0,114,4,0,0,0,114,4,0,0,0,114,4,0, + 0,0,114,5,0,0,0,114,7,1,0,0,47,6,0,0, + 115,8,0,0,0,12,2,6,2,12,5,12,5,114,7,1, + 0,0,99,0,0,0,0,0,0,0,0,0,0,0,0,2, + 0,0,0,64,0,0,0,115,46,0,0,0,101,0,0,90, + 1,0,100,0,0,90,2,0,100,1,0,90,3,0,100,2, + 0,100,3,0,132,0,0,90,4,0,100,4,0,100,5,0, + 132,0,0,90,5,0,100,6,0,83,41,7,114,6,1,0, + 0,122,45,76,111,97,100,101,114,32,119,104,105,99,104,32, + 104,97,110,100,108,101,115,32,115,111,117,114,99,101,108,101, + 115,115,32,102,105,108,101,32,105,109,112,111,114,116,115,46, + 99,2,0,0,0,0,0,0,0,5,0,0,0,6,0,0, + 0,67,0,0,0,115,76,0,0,0,124,0,0,106,0,0, + 124,1,0,131,1,0,125,2,0,124,0,0,106,1,0,124, + 2,0,131,1,0,125,3,0,116,2,0,124,3,0,100,1, + 0,124,1,0,100,2,0,124,2,0,131,1,2,125,4,0, + 116,3,0,124,4,0,100,1,0,124,1,0,100,3,0,124, + 2,0,131,1,2,83,41,4,78,114,67,0,0,0,114,35, + 0,0,0,114,141,0,0,0,41,4,114,238,0,0,0,114, + 39,1,0,0,114,189,0,0,0,114,194,0,0,0,41,5, + 114,71,0,0,0,114,159,0,0,0,114,35,0,0,0,114, + 53,0,0,0,114,47,1,0,0,114,4,0,0,0,114,4, + 0,0,0,114,5,0,0,0,114,14,1,0,0,94,6,0, + 0,115,8,0,0,0,0,1,15,1,15,1,24,1,122,29, + 83,111,117,114,99,101,108,101,115,115,70,105,108,101,76,111, + 97,100,101,114,46,103,101,116,95,99,111,100,101,99,2,0, + 0,0,0,0,0,0,2,0,0,0,1,0,0,0,67,0, + 0,0,115,4,0,0,0,100,1,0,83,41,2,122,39,82, + 101,116,117,114,110,32,78,111,110,101,32,97,115,32,116,104, + 101,114,101,32,105,115,32,110,111,32,115,111,117,114,99,101, + 32,99,111,100,101,46,78,114,4,0,0,0,41,2,114,71, + 0,0,0,114,159,0,0,0,114,4,0,0,0,114,4,0, + 0,0,114,5,0,0,0,114,15,1,0,0,100,6,0,0, + 115,2,0,0,0,0,2,122,31,83,111,117,114,99,101,108, + 101,115,115,70,105,108,101,76,111,97,100,101,114,46,103,101, + 116,95,115,111,117,114,99,101,78,41,6,114,57,0,0,0, + 114,56,0,0,0,114,58,0,0,0,114,59,0,0,0,114, + 14,1,0,0,114,15,1,0,0,114,4,0,0,0,114,4, + 0,0,0,114,4,0,0,0,114,5,0,0,0,114,6,1, + 0,0,90,6,0,0,115,6,0,0,0,12,2,6,2,12, + 6,114,6,1,0,0,99,0,0,0,0,0,0,0,0,0, + 0,0,0,3,0,0,0,64,0,0,0,115,130,0,0,0, + 101,0,0,90,1,0,100,0,0,90,2,0,100,1,0,90, + 3,0,100,2,0,100,3,0,132,0,0,90,4,0,100,4, + 0,100,5,0,132,0,0,90,5,0,100,6,0,100,7,0, + 132,0,0,90,6,0,101,7,0,100,8,0,100,9,0,132, + 0,0,131,1,0,90,8,0,100,10,0,100,11,0,132,0, + 0,90,9,0,100,12,0,100,13,0,132,0,0,90,10,0, + 100,14,0,100,15,0,132,0,0,90,11,0,101,7,0,100, + 16,0,100,17,0,132,0,0,131,1,0,90,12,0,100,18, + 0,83,41,19,218,19,69,120,116,101,110,115,105,111,110,70, + 105,108,101,76,111,97,100,101,114,122,93,76,111,97,100,101, + 114,32,102,111,114,32,101,120,116,101,110,115,105,111,110,32, + 109,111,100,117,108,101,115,46,10,10,32,32,32,32,84,104, + 101,32,99,111,110,115,116,114,117,99,116,111,114,32,105,115, + 32,100,101,115,105,103,110,101,100,32,116,111,32,119,111,114, + 107,32,119,105,116,104,32,70,105,108,101,70,105,110,100,101, + 114,46,10,10,32,32,32,32,99,3,0,0,0,0,0,0, + 0,3,0,0,0,2,0,0,0,67,0,0,0,115,22,0, + 0,0,124,1,0,124,0,0,95,0,0,124,2,0,124,0, + 0,95,1,0,100,0,0,83,41,1,78,41,2,114,67,0, + 0,0,114,35,0,0,0,41,3,114,71,0,0,0,114,67, + 0,0,0,114,35,0,0,0,114,4,0,0,0,114,4,0, + 0,0,114,5,0,0,0,114,72,0,0,0,117,6,0,0, + 115,4,0,0,0,0,1,9,1,122,28,69,120,116,101,110, + 115,105,111,110,70,105,108,101,76,111,97,100,101,114,46,95, + 95,105,110,105,116,95,95,99,2,0,0,0,0,0,0,0, + 2,0,0,0,2,0,0,0,67,0,0,0,115,34,0,0, + 0,124,0,0,106,0,0,124,1,0,106,0,0,107,2,0, + 111,33,0,124,0,0,106,1,0,124,1,0,106,1,0,107, + 2,0,83,41,1,78,41,2,114,224,0,0,0,114,63,0, + 0,0,41,2,114,71,0,0,0,114,227,0,0,0,114,4, + 0,0,0,114,4,0,0,0,114,5,0,0,0,114,229,0, + 0,0,121,6,0,0,115,4,0,0,0,0,1,18,1,122, + 26,69,120,116,101,110,115,105,111,110,70,105,108,101,76,111, + 97,100,101,114,46,95,95,101,113,95,95,99,1,0,0,0, + 0,0,0,0,1,0,0,0,3,0,0,0,67,0,0,0, + 115,26,0,0,0,116,0,0,124,0,0,106,1,0,131,1, + 0,116,0,0,124,0,0,106,2,0,131,1,0,65,83,41, + 1,78,41,3,114,49,1,0,0,114,67,0,0,0,114,35, + 0,0,0,41,1,114,71,0,0,0,114,4,0,0,0,114, + 4,0,0,0,114,5,0,0,0,114,50,1,0,0,125,6, + 0,0,115,2,0,0,0,0,1,122,28,69,120,116,101,110, + 115,105,111,110,70,105,108,101,76,111,97,100,101,114,46,95, + 95,104,97,115,104,95,95,99,2,0,0,0,0,0,0,0, + 4,0,0,0,11,0,0,0,67,0,0,0,115,177,0,0, + 0,116,0,0,124,1,0,131,1,0,143,29,0,1,116,1, + 0,116,2,0,106,3,0,124,1,0,124,0,0,106,4,0, + 131,3,0,125,2,0,87,100,1,0,81,88,116,5,0,100, + 2,0,124,0,0,106,4,0,131,2,0,1,124,0,0,106, + 6,0,124,1,0,131,1,0,125,3,0,124,3,0,114,121, + 0,116,7,0,124,2,0,100,3,0,131,2,0,12,114,121, + 0,116,8,0,124,0,0,106,4,0,131,1,0,100,4,0, + 25,103,1,0,124,2,0,95,9,0,124,0,0,124,2,0, + 95,10,0,124,2,0,106,11,0,124,2,0,95,12,0,124, + 3,0,115,173,0,124,2,0,106,12,0,106,13,0,100,5, + 0,131,1,0,100,4,0,25,124,2,0,95,12,0,124,2, + 0,83,41,6,122,25,76,111,97,100,32,97,110,32,101,120, + 116,101,110,115,105,111,110,32,109,111,100,117,108,101,46,78, + 122,33,101,120,116,101,110,115,105,111,110,32,109,111,100,117, + 108,101,32,108,111,97,100,101,100,32,102,114,111,109,32,123, + 33,114,125,114,246,0,0,0,114,84,0,0,0,114,116,0, + 0,0,41,14,114,69,0,0,0,114,114,0,0,0,114,106, + 0,0,0,90,12,108,111,97,100,95,100,121,110,97,109,105, + 99,114,35,0,0,0,114,153,0,0,0,114,219,0,0,0, + 114,60,0,0,0,114,38,0,0,0,114,246,0,0,0,114, + 203,0,0,0,114,57,0,0,0,114,249,0,0,0,114,32, + 0,0,0,41,4,114,71,0,0,0,114,159,0,0,0,114, + 178,0,0,0,114,219,0,0,0,114,4,0,0,0,114,4, + 0,0,0,114,5,0,0,0,114,3,1,0,0,128,6,0, + 0,115,24,0,0,0,0,5,13,1,9,1,21,1,16,1, + 15,1,22,1,25,1,9,1,12,1,6,1,25,1,122,31, + 69,120,116,101,110,115,105,111,110,70,105,108,101,76,111,97, + 100,101,114,46,108,111,97,100,95,109,111,100,117,108,101,99, + 2,0,0,0,0,0,0,0,2,0,0,0,4,0,0,0, + 3,0,0,0,115,48,0,0,0,116,0,0,124,0,0,106, + 1,0,131,1,0,100,1,0,25,137,0,0,116,2,0,135, + 0,0,102,1,0,100,2,0,100,3,0,134,0,0,116,3, + 0,68,131,1,0,131,1,0,83,41,4,122,49,82,101,116, + 117,114,110,32,84,114,117,101,32,105,102,32,116,104,101,32, + 101,120,116,101,110,115,105,111,110,32,109,111,100,117,108,101, + 32,105,115,32,97,32,112,97,99,107,97,103,101,46,114,29, + 0,0,0,99,1,0,0,0,0,0,0,0,2,0,0,0, + 4,0,0,0,51,0,0,0,115,31,0,0,0,124,0,0, + 93,21,0,125,1,0,136,0,0,100,0,0,124,1,0,23, + 107,2,0,86,1,113,3,0,100,1,0,83,41,2,114,72, + 0,0,0,78,114,4,0,0,0,41,2,114,22,0,0,0, + 218,6,115,117,102,102,105,120,41,1,218,9,102,105,108,101, + 95,110,97,109,101,114,4,0,0,0,114,5,0,0,0,114, + 77,0,0,0,149,6,0,0,115,2,0,0,0,6,1,122, + 49,69,120,116,101,110,115,105,111,110,70,105,108,101,76,111, + 97,100,101,114,46,105,115,95,112,97,99,107,97,103,101,46, + 60,108,111,99,97,108,115,62,46,60,103,101,110,101,120,112, + 114,62,41,4,114,38,0,0,0,114,35,0,0,0,114,78, + 0,0,0,218,18,69,88,84,69,78,83,73,79,78,95,83, + 85,70,70,73,88,69,83,41,2,114,71,0,0,0,114,159, + 0,0,0,114,4,0,0,0,41,1,114,58,1,0,0,114, + 5,0,0,0,114,219,0,0,0,146,6,0,0,115,6,0, + 0,0,0,2,19,1,18,1,122,30,69,120,116,101,110,115, + 105,111,110,70,105,108,101,76,111,97,100,101,114,46,105,115, + 95,112,97,99,107,97,103,101,99,2,0,0,0,0,0,0, + 0,2,0,0,0,1,0,0,0,67,0,0,0,115,4,0, + 0,0,100,1,0,83,41,2,122,63,82,101,116,117,114,110, + 32,78,111,110,101,32,97,115,32,97,110,32,101,120,116,101, + 110,115,105,111,110,32,109,111,100,117,108,101,32,99,97,110, + 110,111,116,32,99,114,101,97,116,101,32,97,32,99,111,100, + 101,32,111,98,106,101,99,116,46,78,114,4,0,0,0,41, + 2,114,71,0,0,0,114,159,0,0,0,114,4,0,0,0, + 114,4,0,0,0,114,5,0,0,0,114,14,1,0,0,152, + 6,0,0,115,2,0,0,0,0,2,122,28,69,120,116,101, + 110,115,105,111,110,70,105,108,101,76,111,97,100,101,114,46, + 103,101,116,95,99,111,100,101,99,2,0,0,0,0,0,0, + 0,2,0,0,0,1,0,0,0,67,0,0,0,115,4,0, + 0,0,100,1,0,83,41,2,122,53,82,101,116,117,114,110, + 32,78,111,110,101,32,97,115,32,101,120,116,101,110,115,105, + 111,110,32,109,111,100,117,108,101,115,32,104,97,118,101,32, + 110,111,32,115,111,117,114,99,101,32,99,111,100,101,46,78, 114,4,0,0,0,41,2,114,71,0,0,0,114,159,0,0, 0,114,4,0,0,0,114,4,0,0,0,114,5,0,0,0, - 114,15,1,0,0,243,6,0,0,115,2,0,0,0,0,1, - 122,27,95,78,97,109,101,115,112,97,99,101,76,111,97,100, - 101,114,46,103,101,116,95,115,111,117,114,99,101,99,2,0, - 0,0,0,0,0,0,2,0,0,0,6,0,0,0,67,0, - 0,0,115,22,0,0,0,116,0,0,100,1,0,100,2,0, - 100,3,0,100,4,0,100,5,0,131,3,1,83,41,6,78, - 114,30,0,0,0,122,8,60,115,116,114,105,110,103,62,114, - 21,1,0,0,114,42,1,0,0,84,41,1,114,43,1,0, - 0,41,2,114,71,0,0,0,114,159,0,0,0,114,4,0, - 0,0,114,4,0,0,0,114,5,0,0,0,114,14,1,0, - 0,246,6,0,0,115,2,0,0,0,0,1,122,25,95,78, - 97,109,101,115,112,97,99,101,76,111,97,100,101,114,46,103, - 101,116,95,99,111,100,101,99,2,0,0,0,0,0,0,0, + 114,15,1,0,0,156,6,0,0,115,2,0,0,0,0,2, + 122,30,69,120,116,101,110,115,105,111,110,70,105,108,101,76, + 111,97,100,101,114,46,103,101,116,95,115,111,117,114,99,101, + 99,2,0,0,0,0,0,0,0,2,0,0,0,1,0,0, + 0,67,0,0,0,115,7,0,0,0,124,0,0,106,0,0, + 83,41,1,122,58,82,101,116,117,114,110,32,116,104,101,32, + 112,97,116,104,32,116,111,32,116,104,101,32,115,111,117,114, + 99,101,32,102,105,108,101,32,97,115,32,102,111,117,110,100, + 32,98,121,32,116,104,101,32,102,105,110,100,101,114,46,41, + 1,114,35,0,0,0,41,2,114,71,0,0,0,114,159,0, + 0,0,114,4,0,0,0,114,4,0,0,0,114,5,0,0, + 0,114,238,0,0,0,160,6,0,0,115,2,0,0,0,0, + 3,122,32,69,120,116,101,110,115,105,111,110,70,105,108,101, + 76,111,97,100,101,114,46,103,101,116,95,102,105,108,101,110, + 97,109,101,78,41,13,114,57,0,0,0,114,56,0,0,0, + 114,58,0,0,0,114,59,0,0,0,114,72,0,0,0,114, + 229,0,0,0,114,50,1,0,0,114,157,0,0,0,114,3, + 1,0,0,114,219,0,0,0,114,14,1,0,0,114,15,1, + 0,0,114,238,0,0,0,114,4,0,0,0,114,4,0,0, + 0,114,4,0,0,0,114,5,0,0,0,114,56,1,0,0, + 109,6,0,0,115,18,0,0,0,12,6,6,2,12,4,12, + 4,12,3,18,18,12,6,12,4,12,4,114,56,1,0,0, + 99,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0, + 0,64,0,0,0,115,130,0,0,0,101,0,0,90,1,0, + 100,0,0,90,2,0,100,1,0,90,3,0,100,2,0,100, + 3,0,132,0,0,90,4,0,100,4,0,100,5,0,132,0, + 0,90,5,0,100,6,0,100,7,0,132,0,0,90,6,0, + 100,8,0,100,9,0,132,0,0,90,7,0,100,10,0,100, + 11,0,132,0,0,90,8,0,100,12,0,100,13,0,132,0, + 0,90,9,0,100,14,0,100,15,0,132,0,0,90,10,0, + 100,16,0,100,17,0,132,0,0,90,11,0,100,18,0,100, + 19,0,132,0,0,90,12,0,100,20,0,83,41,21,218,14, + 95,78,97,109,101,115,112,97,99,101,80,97,116,104,97,38, + 1,0,0,82,101,112,114,101,115,101,110,116,115,32,97,32, + 110,97,109,101,115,112,97,99,101,32,112,97,99,107,97,103, + 101,39,115,32,112,97,116,104,46,32,32,73,116,32,117,115, + 101,115,32,116,104,101,32,109,111,100,117,108,101,32,110,97, + 109,101,10,32,32,32,32,116,111,32,102,105,110,100,32,105, + 116,115,32,112,97,114,101,110,116,32,109,111,100,117,108,101, + 44,32,97,110,100,32,102,114,111,109,32,116,104,101,114,101, + 32,105,116,32,108,111,111,107,115,32,117,112,32,116,104,101, + 32,112,97,114,101,110,116,39,115,10,32,32,32,32,95,95, + 112,97,116,104,95,95,46,32,32,87,104,101,110,32,116,104, + 105,115,32,99,104,97,110,103,101,115,44,32,116,104,101,32, + 109,111,100,117,108,101,39,115,32,111,119,110,32,112,97,116, + 104,32,105,115,32,114,101,99,111,109,112,117,116,101,100,44, + 10,32,32,32,32,117,115,105,110,103,32,112,97,116,104,95, + 102,105,110,100,101,114,46,32,32,70,111,114,32,116,111,112, + 45,108,101,118,101,108,32,109,111,100,117,108,101,115,44,32, + 116,104,101,32,112,97,114,101,110,116,32,109,111,100,117,108, + 101,39,115,32,112,97,116,104,10,32,32,32,32,105,115,32, + 115,121,115,46,112,97,116,104,46,99,4,0,0,0,0,0, + 0,0,4,0,0,0,2,0,0,0,67,0,0,0,115,52, + 0,0,0,124,1,0,124,0,0,95,0,0,124,2,0,124, + 0,0,95,1,0,116,2,0,124,0,0,106,3,0,131,0, + 0,131,1,0,124,0,0,95,4,0,124,3,0,124,0,0, + 95,5,0,100,0,0,83,41,1,78,41,6,114,70,0,0, + 0,114,252,0,0,0,114,231,0,0,0,218,16,95,103,101, + 116,95,112,97,114,101,110,116,95,112,97,116,104,218,17,95, + 108,97,115,116,95,112,97,114,101,110,116,95,112,97,116,104, + 218,12,95,112,97,116,104,95,102,105,110,100,101,114,41,4, + 114,71,0,0,0,114,67,0,0,0,114,35,0,0,0,218, + 11,112,97,116,104,95,102,105,110,100,101,114,114,4,0,0, + 0,114,4,0,0,0,114,5,0,0,0,114,72,0,0,0, + 173,6,0,0,115,8,0,0,0,0,1,9,1,9,1,21, + 1,122,23,95,78,97,109,101,115,112,97,99,101,80,97,116, + 104,46,95,95,105,110,105,116,95,95,99,1,0,0,0,0, + 0,0,0,4,0,0,0,3,0,0,0,67,0,0,0,115, + 53,0,0,0,124,0,0,106,0,0,106,1,0,100,1,0, + 131,1,0,92,3,0,125,1,0,125,2,0,125,3,0,124, + 2,0,100,2,0,107,2,0,114,43,0,100,6,0,83,124, + 1,0,100,5,0,102,2,0,83,41,7,122,62,82,101,116, + 117,114,110,115,32,97,32,116,117,112,108,101,32,111,102,32, + 40,112,97,114,101,110,116,45,109,111,100,117,108,101,45,110, + 97,109,101,44,32,112,97,114,101,110,116,45,112,97,116,104, + 45,97,116,116,114,45,110,97,109,101,41,114,116,0,0,0, + 114,30,0,0,0,114,7,0,0,0,114,35,0,0,0,114, + 246,0,0,0,41,2,122,3,115,121,115,122,4,112,97,116, + 104,41,2,114,70,0,0,0,114,32,0,0,0,41,4,114, + 71,0,0,0,114,233,0,0,0,218,3,100,111,116,114,94, + 0,0,0,114,4,0,0,0,114,4,0,0,0,114,5,0, + 0,0,218,23,95,102,105,110,100,95,112,97,114,101,110,116, + 95,112,97,116,104,95,110,97,109,101,115,179,6,0,0,115, + 8,0,0,0,0,2,27,1,12,2,4,3,122,38,95,78, + 97,109,101,115,112,97,99,101,80,97,116,104,46,95,102,105, + 110,100,95,112,97,114,101,110,116,95,112,97,116,104,95,110, + 97,109,101,115,99,1,0,0,0,0,0,0,0,3,0,0, + 0,3,0,0,0,67,0,0,0,115,38,0,0,0,124,0, + 0,106,0,0,131,0,0,92,2,0,125,1,0,125,2,0, + 116,1,0,116,2,0,106,3,0,124,1,0,25,124,2,0, + 131,2,0,83,41,1,78,41,4,114,66,1,0,0,114,62, + 0,0,0,114,7,0,0,0,114,73,0,0,0,41,3,114, + 71,0,0,0,90,18,112,97,114,101,110,116,95,109,111,100, + 117,108,101,95,110,97,109,101,90,14,112,97,116,104,95,97, + 116,116,114,95,110,97,109,101,114,4,0,0,0,114,4,0, + 0,0,114,5,0,0,0,114,61,1,0,0,189,6,0,0, + 115,4,0,0,0,0,1,18,1,122,31,95,78,97,109,101, + 115,112,97,99,101,80,97,116,104,46,95,103,101,116,95,112, + 97,114,101,110,116,95,112,97,116,104,99,1,0,0,0,0, + 0,0,0,3,0,0,0,3,0,0,0,67,0,0,0,115, + 118,0,0,0,116,0,0,124,0,0,106,1,0,131,0,0, + 131,1,0,125,1,0,124,1,0,124,0,0,106,2,0,107, + 3,0,114,111,0,124,0,0,106,3,0,124,0,0,106,4, + 0,124,1,0,131,2,0,125,2,0,124,2,0,100,0,0, + 107,9,0,114,102,0,124,2,0,106,5,0,100,0,0,107, + 8,0,114,102,0,124,2,0,106,6,0,114,102,0,124,2, + 0,106,6,0,124,0,0,95,7,0,124,1,0,124,0,0, + 95,2,0,124,0,0,106,7,0,83,41,1,78,41,8,114, + 231,0,0,0,114,61,1,0,0,114,62,1,0,0,114,63, + 1,0,0,114,70,0,0,0,114,170,0,0,0,114,220,0, + 0,0,114,252,0,0,0,41,3,114,71,0,0,0,90,11, + 112,97,114,101,110,116,95,112,97,116,104,114,177,0,0,0, + 114,4,0,0,0,114,4,0,0,0,114,5,0,0,0,218, + 12,95,114,101,99,97,108,99,117,108,97,116,101,193,6,0, + 0,115,16,0,0,0,0,2,18,1,15,1,21,3,27,1, + 9,1,12,1,9,1,122,27,95,78,97,109,101,115,112,97, + 99,101,80,97,116,104,46,95,114,101,99,97,108,99,117,108, + 97,116,101,99,1,0,0,0,0,0,0,0,1,0,0,0, + 2,0,0,0,67,0,0,0,115,16,0,0,0,116,0,0, + 124,0,0,106,1,0,131,0,0,131,1,0,83,41,1,78, + 41,2,218,4,105,116,101,114,114,67,1,0,0,41,1,114, + 71,0,0,0,114,4,0,0,0,114,4,0,0,0,114,5, + 0,0,0,218,8,95,95,105,116,101,114,95,95,206,6,0, + 0,115,2,0,0,0,0,1,122,23,95,78,97,109,101,115, + 112,97,99,101,80,97,116,104,46,95,95,105,116,101,114,95, + 95,99,1,0,0,0,0,0,0,0,1,0,0,0,2,0, + 0,0,67,0,0,0,115,16,0,0,0,116,0,0,124,0, + 0,106,1,0,131,0,0,131,1,0,83,41,1,78,41,2, + 114,31,0,0,0,114,67,1,0,0,41,1,114,71,0,0, + 0,114,4,0,0,0,114,4,0,0,0,114,5,0,0,0, + 218,7,95,95,108,101,110,95,95,209,6,0,0,115,2,0, + 0,0,0,1,122,22,95,78,97,109,101,115,112,97,99,101, + 80,97,116,104,46,95,95,108,101,110,95,95,99,1,0,0, + 0,0,0,0,0,1,0,0,0,2,0,0,0,67,0,0, + 0,115,16,0,0,0,100,1,0,106,0,0,124,0,0,106, + 1,0,131,1,0,83,41,2,78,122,20,95,78,97,109,101, + 115,112,97,99,101,80,97,116,104,40,123,33,114,125,41,41, + 2,114,47,0,0,0,114,252,0,0,0,41,1,114,71,0, + 0,0,114,4,0,0,0,114,4,0,0,0,114,5,0,0, + 0,114,101,0,0,0,212,6,0,0,115,2,0,0,0,0, + 1,122,23,95,78,97,109,101,115,112,97,99,101,80,97,116, + 104,46,95,95,114,101,112,114,95,95,99,2,0,0,0,0, + 0,0,0,2,0,0,0,2,0,0,0,67,0,0,0,115, + 16,0,0,0,124,1,0,124,0,0,106,0,0,131,0,0, + 107,6,0,83,41,1,78,41,1,114,67,1,0,0,41,2, + 114,71,0,0,0,218,4,105,116,101,109,114,4,0,0,0, + 114,4,0,0,0,114,5,0,0,0,218,12,95,95,99,111, + 110,116,97,105,110,115,95,95,215,6,0,0,115,2,0,0, + 0,0,1,122,27,95,78,97,109,101,115,112,97,99,101,80, + 97,116,104,46,95,95,99,111,110,116,97,105,110,115,95,95, + 99,2,0,0,0,0,0,0,0,2,0,0,0,2,0,0, + 0,67,0,0,0,115,20,0,0,0,124,0,0,106,0,0, + 106,1,0,124,1,0,131,1,0,1,100,0,0,83,41,1, + 78,41,2,114,252,0,0,0,114,223,0,0,0,41,2,114, + 71,0,0,0,114,71,1,0,0,114,4,0,0,0,114,4, + 0,0,0,114,5,0,0,0,114,223,0,0,0,218,6,0, + 0,115,2,0,0,0,0,1,122,21,95,78,97,109,101,115, + 112,97,99,101,80,97,116,104,46,97,112,112,101,110,100,78, + 41,13,114,57,0,0,0,114,56,0,0,0,114,58,0,0, + 0,114,59,0,0,0,114,72,0,0,0,114,66,1,0,0, + 114,61,1,0,0,114,67,1,0,0,114,69,1,0,0,114, + 70,1,0,0,114,101,0,0,0,114,72,1,0,0,114,223, + 0,0,0,114,4,0,0,0,114,4,0,0,0,114,4,0, + 0,0,114,5,0,0,0,114,60,1,0,0,166,6,0,0, + 115,20,0,0,0,12,5,6,2,12,6,12,10,12,4,12, + 13,12,3,12,3,12,3,12,3,114,60,1,0,0,99,0, + 0,0,0,0,0,0,0,0,0,0,0,3,0,0,0,64, + 0,0,0,115,118,0,0,0,101,0,0,90,1,0,100,0, + 0,90,2,0,100,1,0,100,2,0,132,0,0,90,3,0, + 101,4,0,100,3,0,100,4,0,132,0,0,131,1,0,90, + 5,0,100,5,0,100,6,0,132,0,0,90,6,0,100,7, + 0,100,8,0,132,0,0,90,7,0,100,9,0,100,10,0, + 132,0,0,90,8,0,100,11,0,100,12,0,132,0,0,90, + 9,0,100,13,0,100,14,0,132,0,0,90,10,0,100,15, + 0,100,16,0,132,0,0,90,11,0,100,17,0,83,41,18, + 114,250,0,0,0,99,4,0,0,0,0,0,0,0,4,0, + 0,0,4,0,0,0,67,0,0,0,115,25,0,0,0,116, + 0,0,124,1,0,124,2,0,124,3,0,131,3,0,124,0, + 0,95,1,0,100,0,0,83,41,1,78,41,2,114,60,1, + 0,0,114,252,0,0,0,41,4,114,71,0,0,0,114,67, + 0,0,0,114,35,0,0,0,114,64,1,0,0,114,4,0, + 0,0,114,4,0,0,0,114,5,0,0,0,114,72,0,0, + 0,224,6,0,0,115,2,0,0,0,0,1,122,25,95,78, + 97,109,101,115,112,97,99,101,76,111,97,100,101,114,46,95, + 95,105,110,105,116,95,95,99,2,0,0,0,0,0,0,0, + 2,0,0,0,2,0,0,0,67,0,0,0,115,16,0,0, + 0,100,1,0,106,0,0,124,1,0,106,1,0,131,1,0, + 83,41,2,122,115,82,101,116,117,114,110,32,114,101,112,114, + 32,102,111,114,32,116,104,101,32,109,111,100,117,108,101,46, + 10,10,32,32,32,32,32,32,32,32,84,104,101,32,109,101, + 116,104,111,100,32,105,115,32,100,101,112,114,101,99,97,116, + 101,100,46,32,32,84,104,101,32,105,109,112,111,114,116,32, + 109,97,99,104,105,110,101,114,121,32,100,111,101,115,32,116, + 104,101,32,106,111,98,32,105,116,115,101,108,102,46,10,10, + 32,32,32,32,32,32,32,32,122,25,60,109,111,100,117,108, + 101,32,123,33,114,125,32,40,110,97,109,101,115,112,97,99, + 101,41,62,41,2,114,47,0,0,0,114,57,0,0,0,41, + 2,114,10,1,0,0,114,178,0,0,0,114,4,0,0,0, + 114,4,0,0,0,114,5,0,0,0,114,204,0,0,0,227, + 6,0,0,115,2,0,0,0,0,7,122,28,95,78,97,109, + 101,115,112,97,99,101,76,111,97,100,101,114,46,109,111,100, + 117,108,101,95,114,101,112,114,99,2,0,0,0,0,0,0, + 0,2,0,0,0,1,0,0,0,67,0,0,0,115,4,0, + 0,0,100,1,0,83,41,2,78,84,114,4,0,0,0,41, + 2,114,71,0,0,0,114,159,0,0,0,114,4,0,0,0, + 114,4,0,0,0,114,5,0,0,0,114,219,0,0,0,236, + 6,0,0,115,2,0,0,0,0,1,122,27,95,78,97,109, + 101,115,112,97,99,101,76,111,97,100,101,114,46,105,115,95, + 112,97,99,107,97,103,101,99,2,0,0,0,0,0,0,0, 2,0,0,0,1,0,0,0,67,0,0,0,115,4,0,0, - 0,100,1,0,83,41,2,122,42,85,115,101,32,100,101,102, - 97,117,108,116,32,115,101,109,97,110,116,105,99,115,32,102, - 111,114,32,109,111,100,117,108,101,32,99,114,101,97,116,105, - 111,110,46,78,114,4,0,0,0,41,2,114,71,0,0,0, + 0,100,1,0,83,41,2,78,114,30,0,0,0,114,4,0, + 0,0,41,2,114,71,0,0,0,114,159,0,0,0,114,4, + 0,0,0,114,4,0,0,0,114,5,0,0,0,114,15,1, + 0,0,239,6,0,0,115,2,0,0,0,0,1,122,27,95, + 78,97,109,101,115,112,97,99,101,76,111,97,100,101,114,46, + 103,101,116,95,115,111,117,114,99,101,99,2,0,0,0,0, + 0,0,0,2,0,0,0,6,0,0,0,67,0,0,0,115, + 22,0,0,0,116,0,0,100,1,0,100,2,0,100,3,0, + 100,4,0,100,5,0,131,3,1,83,41,6,78,114,30,0, + 0,0,122,8,60,115,116,114,105,110,103,62,114,21,1,0, + 0,114,42,1,0,0,84,41,1,114,43,1,0,0,41,2, + 114,71,0,0,0,114,159,0,0,0,114,4,0,0,0,114, + 4,0,0,0,114,5,0,0,0,114,14,1,0,0,242,6, + 0,0,115,2,0,0,0,0,1,122,25,95,78,97,109,101, + 115,112,97,99,101,76,111,97,100,101,114,46,103,101,116,95, + 99,111,100,101,99,2,0,0,0,0,0,0,0,2,0,0, + 0,1,0,0,0,67,0,0,0,115,4,0,0,0,100,1, + 0,83,41,2,122,42,85,115,101,32,100,101,102,97,117,108, + 116,32,115,101,109,97,110,116,105,99,115,32,102,111,114,32, + 109,111,100,117,108,101,32,99,114,101,97,116,105,111,110,46, + 78,114,4,0,0,0,41,2,114,71,0,0,0,114,177,0, + 0,0,114,4,0,0,0,114,4,0,0,0,114,5,0,0, + 0,114,254,0,0,0,245,6,0,0,115,0,0,0,0,122, + 30,95,78,97,109,101,115,112,97,99,101,76,111,97,100,101, + 114,46,99,114,101,97,116,101,95,109,111,100,117,108,101,99, + 2,0,0,0,0,0,0,0,2,0,0,0,1,0,0,0, + 67,0,0,0,115,4,0,0,0,100,0,0,83,41,1,78, + 114,4,0,0,0,41,2,114,71,0,0,0,114,178,0,0, + 0,114,4,0,0,0,114,4,0,0,0,114,5,0,0,0, + 114,255,0,0,0,248,6,0,0,115,2,0,0,0,0,1, + 122,28,95,78,97,109,101,115,112,97,99,101,76,111,97,100, + 101,114,46,101,120,101,99,95,109,111,100,117,108,101,99,2, + 0,0,0,0,0,0,0,2,0,0,0,3,0,0,0,67, + 0,0,0,115,29,0,0,0,116,0,0,100,1,0,124,0, + 0,106,1,0,131,2,0,1,116,2,0,124,0,0,124,1, + 0,131,2,0,83,41,2,122,98,76,111,97,100,32,97,32, + 110,97,109,101,115,112,97,99,101,32,109,111,100,117,108,101, + 46,10,10,32,32,32,32,32,32,32,32,84,104,105,115,32, + 109,101,116,104,111,100,32,105,115,32,100,101,112,114,101,99, + 97,116,101,100,46,32,32,85,115,101,32,101,120,101,99,95, + 109,111,100,117,108,101,40,41,32,105,110,115,116,101,97,100, + 46,10,10,32,32,32,32,32,32,32,32,122,38,110,97,109, + 101,115,112,97,99,101,32,109,111,100,117,108,101,32,108,111, + 97,100,101,100,32,119,105,116,104,32,112,97,116,104,32,123, + 33,114,125,41,3,114,153,0,0,0,114,252,0,0,0,114, + 179,0,0,0,41,2,114,71,0,0,0,114,159,0,0,0, + 114,4,0,0,0,114,4,0,0,0,114,5,0,0,0,114, + 3,1,0,0,251,6,0,0,115,4,0,0,0,0,7,16, + 1,122,28,95,78,97,109,101,115,112,97,99,101,76,111,97, + 100,101,114,46,108,111,97,100,95,109,111,100,117,108,101,78, + 41,12,114,57,0,0,0,114,56,0,0,0,114,58,0,0, + 0,114,72,0,0,0,114,17,1,0,0,114,204,0,0,0, + 114,219,0,0,0,114,15,1,0,0,114,14,1,0,0,114, + 254,0,0,0,114,255,0,0,0,114,3,1,0,0,114,4, + 0,0,0,114,4,0,0,0,114,4,0,0,0,114,5,0, + 0,0,114,250,0,0,0,223,6,0,0,115,16,0,0,0, + 12,1,12,3,18,9,12,3,12,3,12,3,12,3,12,3, + 114,250,0,0,0,99,0,0,0,0,0,0,0,0,0,0, + 0,0,5,0,0,0,64,0,0,0,115,160,0,0,0,101, + 0,0,90,1,0,100,0,0,90,2,0,100,1,0,90,3, + 0,101,4,0,100,2,0,100,3,0,132,0,0,131,1,0, + 90,5,0,101,4,0,100,4,0,100,5,0,132,0,0,131, + 1,0,90,6,0,101,4,0,100,6,0,100,7,0,132,0, + 0,131,1,0,90,7,0,101,4,0,100,8,0,100,9,0, + 132,0,0,131,1,0,90,8,0,101,4,0,100,10,0,100, + 11,0,100,12,0,132,1,0,131,1,0,90,9,0,101,4, + 0,100,10,0,100,10,0,100,13,0,100,14,0,132,2,0, + 131,1,0,90,10,0,101,4,0,100,10,0,100,15,0,100, + 16,0,132,1,0,131,1,0,90,11,0,100,10,0,83,41, + 17,218,10,80,97,116,104,70,105,110,100,101,114,122,62,77, + 101,116,97,32,112,97,116,104,32,102,105,110,100,101,114,32, + 102,111,114,32,115,121,115,46,112,97,116,104,32,97,110,100, + 32,112,97,99,107,97,103,101,32,95,95,112,97,116,104,95, + 95,32,97,116,116,114,105,98,117,116,101,115,46,99,1,0, + 0,0,0,0,0,0,2,0,0,0,4,0,0,0,67,0, + 0,0,115,55,0,0,0,120,48,0,116,0,0,106,1,0, + 106,2,0,131,0,0,68,93,31,0,125,1,0,116,3,0, + 124,1,0,100,1,0,131,2,0,114,16,0,124,1,0,106, + 4,0,131,0,0,1,113,16,0,87,100,2,0,83,41,3, + 122,125,67,97,108,108,32,116,104,101,32,105,110,118,97,108, + 105,100,97,116,101,95,99,97,99,104,101,115,40,41,32,109, + 101,116,104,111,100,32,111,110,32,97,108,108,32,112,97,116, + 104,32,101,110,116,114,121,32,102,105,110,100,101,114,115,10, + 32,32,32,32,32,32,32,32,115,116,111,114,101,100,32,105, + 110,32,115,121,115,46,112,97,116,104,95,105,109,112,111,114, + 116,101,114,95,99,97,99,104,101,115,32,40,119,104,101,114, + 101,32,105,109,112,108,101,109,101,110,116,101,100,41,46,218, + 17,105,110,118,97,108,105,100,97,116,101,95,99,97,99,104, + 101,115,78,41,5,114,7,0,0,0,218,19,112,97,116,104, + 95,105,109,112,111,114,116,101,114,95,99,97,99,104,101,218, + 6,118,97,108,117,101,115,114,60,0,0,0,114,74,1,0, + 0,41,2,114,10,1,0,0,218,6,102,105,110,100,101,114, + 114,4,0,0,0,114,4,0,0,0,114,5,0,0,0,114, + 74,1,0,0,12,7,0,0,115,6,0,0,0,0,4,22, + 1,15,1,122,28,80,97,116,104,70,105,110,100,101,114,46, + 105,110,118,97,108,105,100,97,116,101,95,99,97,99,104,101, + 115,99,2,0,0,0,0,0,0,0,3,0,0,0,12,0, + 0,0,67,0,0,0,115,107,0,0,0,116,0,0,106,1, + 0,100,1,0,107,9,0,114,41,0,116,0,0,106,1,0, + 12,114,41,0,116,2,0,106,3,0,100,2,0,116,4,0, + 131,2,0,1,120,59,0,116,0,0,106,1,0,68,93,44, + 0,125,2,0,121,14,0,124,2,0,124,1,0,131,1,0, + 83,87,113,51,0,4,116,5,0,107,10,0,114,94,0,1, + 1,1,119,51,0,89,113,51,0,88,113,51,0,87,100,1, + 0,83,100,1,0,83,41,3,122,113,83,101,97,114,99,104, + 32,115,101,113,117,101,110,99,101,32,111,102,32,104,111,111, + 107,115,32,102,111,114,32,97,32,102,105,110,100,101,114,32, + 102,111,114,32,39,112,97,116,104,39,46,10,10,32,32,32, + 32,32,32,32,32,73,102,32,39,104,111,111,107,115,39,32, + 105,115,32,102,97,108,115,101,32,116,104,101,110,32,117,115, + 101,32,115,121,115,46,112,97,116,104,95,104,111,111,107,115, + 46,10,10,32,32,32,32,32,32,32,32,78,122,23,115,121, + 115,46,112,97,116,104,95,104,111,111,107,115,32,105,115,32, + 101,109,112,116,121,41,6,114,7,0,0,0,218,10,112,97, + 116,104,95,104,111,111,107,115,114,167,0,0,0,114,168,0, + 0,0,114,169,0,0,0,114,154,0,0,0,41,3,114,10, + 1,0,0,114,35,0,0,0,90,4,104,111,111,107,114,4, + 0,0,0,114,4,0,0,0,114,5,0,0,0,218,11,95, + 112,97,116,104,95,104,111,111,107,115,20,7,0,0,115,16, + 0,0,0,0,7,25,1,16,1,16,1,3,1,14,1,13, + 1,12,2,122,22,80,97,116,104,70,105,110,100,101,114,46, + 95,112,97,116,104,95,104,111,111,107,115,99,2,0,0,0, + 0,0,0,0,3,0,0,0,19,0,0,0,67,0,0,0, + 115,123,0,0,0,124,1,0,100,1,0,107,2,0,114,53, + 0,121,16,0,116,0,0,106,1,0,131,0,0,125,1,0, + 87,110,22,0,4,116,2,0,107,10,0,114,52,0,1,1, + 1,100,2,0,83,89,110,1,0,88,121,17,0,116,3,0, + 106,4,0,124,1,0,25,125,2,0,87,110,46,0,4,116, + 5,0,107,10,0,114,118,0,1,1,1,124,0,0,106,6, + 0,124,1,0,131,1,0,125,2,0,124,2,0,116,3,0, + 106,4,0,124,1,0,60,89,110,1,0,88,124,2,0,83, + 41,3,122,210,71,101,116,32,116,104,101,32,102,105,110,100, + 101,114,32,102,111,114,32,116,104,101,32,112,97,116,104,32, + 101,110,116,114,121,32,102,114,111,109,32,115,121,115,46,112, + 97,116,104,95,105,109,112,111,114,116,101,114,95,99,97,99, + 104,101,46,10,10,32,32,32,32,32,32,32,32,73,102,32, + 116,104,101,32,112,97,116,104,32,101,110,116,114,121,32,105, + 115,32,110,111,116,32,105,110,32,116,104,101,32,99,97,99, + 104,101,44,32,102,105,110,100,32,116,104,101,32,97,112,112, + 114,111,112,114,105,97,116,101,32,102,105,110,100,101,114,10, + 32,32,32,32,32,32,32,32,97,110,100,32,99,97,99,104, + 101,32,105,116,46,32,73,102,32,110,111,32,102,105,110,100, + 101,114,32,105,115,32,97,118,97,105,108,97,98,108,101,44, + 32,115,116,111,114,101,32,78,111,110,101,46,10,10,32,32, + 32,32,32,32,32,32,114,30,0,0,0,78,41,7,114,3, + 0,0,0,114,45,0,0,0,218,17,70,105,108,101,78,111, + 116,70,111,117,110,100,69,114,114,111,114,114,7,0,0,0, + 114,75,1,0,0,114,79,0,0,0,114,79,1,0,0,41, + 3,114,10,1,0,0,114,35,0,0,0,114,77,1,0,0, + 114,4,0,0,0,114,4,0,0,0,114,5,0,0,0,218, + 20,95,112,97,116,104,95,105,109,112,111,114,116,101,114,95, + 99,97,99,104,101,37,7,0,0,115,22,0,0,0,0,8, + 12,1,3,1,16,1,13,3,9,1,3,1,17,1,13,1, + 15,1,18,1,122,31,80,97,116,104,70,105,110,100,101,114, + 46,95,112,97,116,104,95,105,109,112,111,114,116,101,114,95, + 99,97,99,104,101,99,3,0,0,0,0,0,0,0,6,0, + 0,0,3,0,0,0,67,0,0,0,115,113,0,0,0,116, + 0,0,124,2,0,100,1,0,131,2,0,114,39,0,124,2, + 0,106,1,0,124,1,0,131,1,0,92,2,0,125,3,0, + 125,4,0,110,21,0,124,2,0,106,2,0,124,1,0,131, + 1,0,125,3,0,103,0,0,125,4,0,124,3,0,100,0, + 0,107,9,0,114,85,0,116,3,0,124,1,0,124,3,0, + 131,2,0,83,116,4,0,124,1,0,100,0,0,131,2,0, + 125,5,0,124,4,0,124,5,0,95,5,0,124,5,0,83, + 41,2,78,114,166,0,0,0,41,6,114,60,0,0,0,114, + 166,0,0,0,114,13,1,0,0,114,174,0,0,0,114,216, + 0,0,0,114,220,0,0,0,41,6,114,10,1,0,0,114, + 159,0,0,0,114,77,1,0,0,114,170,0,0,0,114,171, + 0,0,0,114,177,0,0,0,114,4,0,0,0,114,4,0, + 0,0,114,5,0,0,0,218,16,95,108,101,103,97,99,121, + 95,103,101,116,95,115,112,101,99,59,7,0,0,115,18,0, + 0,0,0,4,15,1,24,2,15,1,6,1,12,1,13,1, + 15,1,9,1,122,27,80,97,116,104,70,105,110,100,101,114, + 46,95,108,101,103,97,99,121,95,103,101,116,95,115,112,101, + 99,78,99,4,0,0,0,0,0,0,0,9,0,0,0,5, + 0,0,0,67,0,0,0,115,240,0,0,0,103,0,0,125, + 4,0,120,227,0,124,2,0,68,93,191,0,125,5,0,116, + 0,0,124,5,0,116,1,0,116,2,0,102,2,0,131,2, + 0,115,43,0,113,13,0,124,0,0,106,3,0,124,5,0, + 131,1,0,125,6,0,124,6,0,100,1,0,107,9,0,114, + 13,0,116,4,0,124,6,0,100,2,0,131,2,0,114,106, + 0,124,6,0,106,5,0,124,1,0,124,3,0,131,2,0, + 125,7,0,110,18,0,124,0,0,106,6,0,124,1,0,124, + 6,0,131,2,0,125,7,0,124,7,0,100,1,0,107,8, + 0,114,139,0,113,13,0,124,7,0,106,7,0,100,1,0, + 107,9,0,114,158,0,124,7,0,83,124,7,0,106,8,0, + 125,8,0,124,8,0,100,1,0,107,8,0,114,191,0,116, + 9,0,100,3,0,131,1,0,130,1,0,124,4,0,106,10, + 0,124,8,0,131,1,0,1,113,13,0,87,116,11,0,124, + 1,0,100,1,0,131,2,0,125,7,0,124,4,0,124,7, + 0,95,8,0,124,7,0,83,100,1,0,83,41,4,122,63, + 70,105,110,100,32,116,104,101,32,108,111,97,100,101,114,32, + 111,114,32,110,97,109,101,115,112,97,99,101,95,112,97,116, + 104,32,102,111,114,32,116,104,105,115,32,109,111,100,117,108, + 101,47,112,97,99,107,97,103,101,32,110,97,109,101,46,78, + 114,12,1,0,0,122,19,115,112,101,99,32,109,105,115,115, + 105,110,103,32,108,111,97,100,101,114,41,12,114,191,0,0, + 0,218,3,115,116,114,218,5,98,121,116,101,115,114,81,1, + 0,0,114,60,0,0,0,114,12,1,0,0,114,82,1,0, + 0,114,170,0,0,0,114,220,0,0,0,114,154,0,0,0, + 114,196,0,0,0,114,216,0,0,0,41,9,114,10,1,0, + 0,114,159,0,0,0,114,35,0,0,0,114,11,1,0,0, + 218,14,110,97,109,101,115,112,97,99,101,95,112,97,116,104, + 90,5,101,110,116,114,121,114,77,1,0,0,114,177,0,0, + 0,114,171,0,0,0,114,4,0,0,0,114,4,0,0,0, + 114,5,0,0,0,218,9,95,103,101,116,95,115,112,101,99, + 74,7,0,0,115,40,0,0,0,0,5,6,1,13,1,21, + 1,3,1,15,1,12,1,15,1,21,2,18,1,12,1,3, + 1,15,1,4,1,9,1,12,1,12,5,17,2,15,1,9, + 1,122,20,80,97,116,104,70,105,110,100,101,114,46,95,103, + 101,116,95,115,112,101,99,99,4,0,0,0,0,0,0,0, + 6,0,0,0,4,0,0,0,67,0,0,0,115,140,0,0, + 0,124,2,0,100,1,0,107,8,0,114,21,0,116,0,0, + 106,1,0,125,2,0,124,0,0,106,2,0,124,1,0,124, + 2,0,124,3,0,131,3,0,125,4,0,124,4,0,100,1, + 0,107,8,0,114,58,0,100,1,0,83,124,4,0,106,3, + 0,100,1,0,107,8,0,114,132,0,124,4,0,106,4,0, + 125,5,0,124,5,0,114,125,0,100,2,0,124,4,0,95, + 5,0,116,6,0,124,1,0,124,5,0,124,0,0,106,2, + 0,131,3,0,124,4,0,95,4,0,124,4,0,83,100,1, + 0,83,110,4,0,124,4,0,83,100,1,0,83,41,3,122, + 98,102,105,110,100,32,116,104,101,32,109,111,100,117,108,101, + 32,111,110,32,115,121,115,46,112,97,116,104,32,111,114,32, + 39,112,97,116,104,39,32,98,97,115,101,100,32,111,110,32, + 115,121,115,46,112,97,116,104,95,104,111,111,107,115,32,97, + 110,100,10,32,32,32,32,32,32,32,32,115,121,115,46,112, + 97,116,104,95,105,109,112,111,114,116,101,114,95,99,97,99, + 104,101,46,78,90,9,110,97,109,101,115,112,97,99,101,41, + 7,114,7,0,0,0,114,35,0,0,0,114,86,1,0,0, + 114,170,0,0,0,114,220,0,0,0,114,217,0,0,0,114, + 60,1,0,0,41,6,114,10,1,0,0,114,159,0,0,0, + 114,35,0,0,0,114,11,1,0,0,114,177,0,0,0,114, + 85,1,0,0,114,4,0,0,0,114,4,0,0,0,114,5, + 0,0,0,114,12,1,0,0,106,7,0,0,115,26,0,0, + 0,0,4,12,1,9,1,21,1,12,1,4,1,15,1,9, + 1,6,3,9,1,24,1,4,2,7,2,122,20,80,97,116, + 104,70,105,110,100,101,114,46,102,105,110,100,95,115,112,101, + 99,99,3,0,0,0,0,0,0,0,4,0,0,0,3,0, + 0,0,67,0,0,0,115,41,0,0,0,124,0,0,106,0, + 0,124,1,0,124,2,0,131,2,0,125,3,0,124,3,0, + 100,1,0,107,8,0,114,34,0,100,1,0,83,124,3,0, + 106,1,0,83,41,2,122,170,102,105,110,100,32,116,104,101, + 32,109,111,100,117,108,101,32,111,110,32,115,121,115,46,112, + 97,116,104,32,111,114,32,39,112,97,116,104,39,32,98,97, + 115,101,100,32,111,110,32,115,121,115,46,112,97,116,104,95, + 104,111,111,107,115,32,97,110,100,10,32,32,32,32,32,32, + 32,32,115,121,115,46,112,97,116,104,95,105,109,112,111,114, + 116,101,114,95,99,97,99,104,101,46,10,10,32,32,32,32, + 32,32,32,32,84,104,105,115,32,109,101,116,104,111,100,32, + 105,115,32,100,101,112,114,101,99,97,116,101,100,46,32,32, + 85,115,101,32,102,105,110,100,95,115,112,101,99,40,41,32, + 105,110,115,116,101,97,100,46,10,10,32,32,32,32,32,32, + 32,32,78,41,2,114,12,1,0,0,114,170,0,0,0,41, + 4,114,10,1,0,0,114,159,0,0,0,114,35,0,0,0, 114,177,0,0,0,114,4,0,0,0,114,4,0,0,0,114, - 5,0,0,0,114,254,0,0,0,249,6,0,0,115,0,0, - 0,0,122,30,95,78,97,109,101,115,112,97,99,101,76,111, - 97,100,101,114,46,99,114,101,97,116,101,95,109,111,100,117, - 108,101,99,2,0,0,0,0,0,0,0,2,0,0,0,1, - 0,0,0,67,0,0,0,115,4,0,0,0,100,0,0,83, - 41,1,78,114,4,0,0,0,41,2,114,71,0,0,0,114, - 178,0,0,0,114,4,0,0,0,114,4,0,0,0,114,5, - 0,0,0,114,255,0,0,0,252,6,0,0,115,2,0,0, - 0,0,1,122,28,95,78,97,109,101,115,112,97,99,101,76, - 111,97,100,101,114,46,101,120,101,99,95,109,111,100,117,108, - 101,99,2,0,0,0,0,0,0,0,2,0,0,0,3,0, - 0,0,67,0,0,0,115,29,0,0,0,116,0,0,100,1, - 0,124,0,0,106,1,0,131,2,0,1,116,2,0,124,0, - 0,124,1,0,131,2,0,83,41,2,122,98,76,111,97,100, - 32,97,32,110,97,109,101,115,112,97,99,101,32,109,111,100, - 117,108,101,46,10,10,32,32,32,32,32,32,32,32,84,104, - 105,115,32,109,101,116,104,111,100,32,105,115,32,100,101,112, - 114,101,99,97,116,101,100,46,32,32,85,115,101,32,101,120, - 101,99,95,109,111,100,117,108,101,40,41,32,105,110,115,116, - 101,97,100,46,10,10,32,32,32,32,32,32,32,32,122,38, - 110,97,109,101,115,112,97,99,101,32,109,111,100,117,108,101, - 32,108,111,97,100,101,100,32,119,105,116,104,32,112,97,116, - 104,32,123,33,114,125,41,3,114,153,0,0,0,114,252,0, - 0,0,114,179,0,0,0,41,2,114,71,0,0,0,114,159, - 0,0,0,114,4,0,0,0,114,4,0,0,0,114,5,0, - 0,0,114,3,1,0,0,255,6,0,0,115,4,0,0,0, - 0,7,16,1,122,28,95,78,97,109,101,115,112,97,99,101, - 76,111,97,100,101,114,46,108,111,97,100,95,109,111,100,117, - 108,101,78,41,12,114,57,0,0,0,114,56,0,0,0,114, - 58,0,0,0,114,72,0,0,0,114,17,1,0,0,114,204, - 0,0,0,114,219,0,0,0,114,15,1,0,0,114,14,1, - 0,0,114,254,0,0,0,114,255,0,0,0,114,3,1,0, - 0,114,4,0,0,0,114,4,0,0,0,114,4,0,0,0, - 114,5,0,0,0,114,250,0,0,0,227,6,0,0,115,16, - 0,0,0,12,1,12,3,18,9,12,3,12,3,12,3,12, - 3,12,3,114,250,0,0,0,99,0,0,0,0,0,0,0, - 0,0,0,0,0,5,0,0,0,64,0,0,0,115,160,0, - 0,0,101,0,0,90,1,0,100,0,0,90,2,0,100,1, - 0,90,3,0,101,4,0,100,2,0,100,3,0,132,0,0, - 131,1,0,90,5,0,101,4,0,100,4,0,100,5,0,132, - 0,0,131,1,0,90,6,0,101,4,0,100,6,0,100,7, - 0,132,0,0,131,1,0,90,7,0,101,4,0,100,8,0, - 100,9,0,132,0,0,131,1,0,90,8,0,101,4,0,100, - 10,0,100,11,0,100,12,0,132,1,0,131,1,0,90,9, - 0,101,4,0,100,10,0,100,10,0,100,13,0,100,14,0, - 132,2,0,131,1,0,90,10,0,101,4,0,100,10,0,100, - 15,0,100,16,0,132,1,0,131,1,0,90,11,0,100,10, - 0,83,41,17,218,10,80,97,116,104,70,105,110,100,101,114, - 122,62,77,101,116,97,32,112,97,116,104,32,102,105,110,100, - 101,114,32,102,111,114,32,115,121,115,46,112,97,116,104,32, - 97,110,100,32,112,97,99,107,97,103,101,32,95,95,112,97, - 116,104,95,95,32,97,116,116,114,105,98,117,116,101,115,46, - 99,1,0,0,0,0,0,0,0,2,0,0,0,4,0,0, - 0,67,0,0,0,115,55,0,0,0,120,48,0,116,0,0, - 106,1,0,106,2,0,131,0,0,68,93,31,0,125,1,0, - 116,3,0,124,1,0,100,1,0,131,2,0,114,16,0,124, - 1,0,106,4,0,131,0,0,1,113,16,0,87,100,2,0, - 83,41,3,122,125,67,97,108,108,32,116,104,101,32,105,110, - 118,97,108,105,100,97,116,101,95,99,97,99,104,101,115,40, - 41,32,109,101,116,104,111,100,32,111,110,32,97,108,108,32, - 112,97,116,104,32,101,110,116,114,121,32,102,105,110,100,101, - 114,115,10,32,32,32,32,32,32,32,32,115,116,111,114,101, - 100,32,105,110,32,115,121,115,46,112,97,116,104,95,105,109, - 112,111,114,116,101,114,95,99,97,99,104,101,115,32,40,119, - 104,101,114,101,32,105,109,112,108,101,109,101,110,116,101,100, - 41,46,218,17,105,110,118,97,108,105,100,97,116,101,95,99, - 97,99,104,101,115,78,41,5,114,7,0,0,0,218,19,112, - 97,116,104,95,105,109,112,111,114,116,101,114,95,99,97,99, - 104,101,218,6,118,97,108,117,101,115,114,60,0,0,0,114, - 74,1,0,0,41,2,114,10,1,0,0,218,6,102,105,110, - 100,101,114,114,4,0,0,0,114,4,0,0,0,114,5,0, - 0,0,114,74,1,0,0,16,7,0,0,115,6,0,0,0, - 0,4,22,1,15,1,122,28,80,97,116,104,70,105,110,100, + 5,0,0,0,114,13,1,0,0,128,7,0,0,115,8,0, + 0,0,0,8,18,1,12,1,4,1,122,22,80,97,116,104, + 70,105,110,100,101,114,46,102,105,110,100,95,109,111,100,117, + 108,101,41,12,114,57,0,0,0,114,56,0,0,0,114,58, + 0,0,0,114,59,0,0,0,114,17,1,0,0,114,74,1, + 0,0,114,79,1,0,0,114,81,1,0,0,114,82,1,0, + 0,114,86,1,0,0,114,12,1,0,0,114,13,1,0,0, + 114,4,0,0,0,114,4,0,0,0,114,4,0,0,0,114, + 5,0,0,0,114,73,1,0,0,8,7,0,0,115,22,0, + 0,0,12,2,6,2,18,8,18,17,18,22,18,15,3,1, + 18,31,3,1,21,21,3,1,114,73,1,0,0,99,0,0, + 0,0,0,0,0,0,0,0,0,0,3,0,0,0,64,0, + 0,0,115,133,0,0,0,101,0,0,90,1,0,100,0,0, + 90,2,0,100,1,0,90,3,0,100,2,0,100,3,0,132, + 0,0,90,4,0,100,4,0,100,5,0,132,0,0,90,5, + 0,101,6,0,90,7,0,100,6,0,100,7,0,132,0,0, + 90,8,0,100,8,0,100,9,0,132,0,0,90,9,0,100, + 10,0,100,11,0,100,12,0,132,1,0,90,10,0,100,13, + 0,100,14,0,132,0,0,90,11,0,101,12,0,100,15,0, + 100,16,0,132,0,0,131,1,0,90,13,0,100,17,0,100, + 18,0,132,0,0,90,14,0,100,10,0,83,41,19,218,10, + 70,105,108,101,70,105,110,100,101,114,122,172,70,105,108,101, + 45,98,97,115,101,100,32,102,105,110,100,101,114,46,10,10, + 32,32,32,32,73,110,116,101,114,97,99,116,105,111,110,115, + 32,119,105,116,104,32,116,104,101,32,102,105,108,101,32,115, + 121,115,116,101,109,32,97,114,101,32,99,97,99,104,101,100, + 32,102,111,114,32,112,101,114,102,111,114,109,97,110,99,101, + 44,32,98,101,105,110,103,10,32,32,32,32,114,101,102,114, + 101,115,104,101,100,32,119,104,101,110,32,116,104,101,32,100, + 105,114,101,99,116,111,114,121,32,116,104,101,32,102,105,110, + 100,101,114,32,105,115,32,104,97,110,100,108,105,110,103,32, + 104,97,115,32,98,101,101,110,32,109,111,100,105,102,105,101, + 100,46,10,10,32,32,32,32,99,2,0,0,0,0,0,0, + 0,5,0,0,0,5,0,0,0,7,0,0,0,115,122,0, + 0,0,103,0,0,125,3,0,120,52,0,124,2,0,68,93, + 44,0,92,2,0,137,0,0,125,4,0,124,3,0,106,0, + 0,135,0,0,102,1,0,100,1,0,100,2,0,134,0,0, + 124,4,0,68,131,1,0,131,1,0,1,113,13,0,87,124, + 3,0,124,0,0,95,1,0,124,1,0,112,79,0,100,3, + 0,124,0,0,95,2,0,100,6,0,124,0,0,95,3,0, + 116,4,0,131,0,0,124,0,0,95,5,0,116,4,0,131, + 0,0,124,0,0,95,6,0,100,5,0,83,41,7,122,154, + 73,110,105,116,105,97,108,105,122,101,32,119,105,116,104,32, + 116,104,101,32,112,97,116,104,32,116,111,32,115,101,97,114, + 99,104,32,111,110,32,97,110,100,32,97,32,118,97,114,105, + 97,98,108,101,32,110,117,109,98,101,114,32,111,102,10,32, + 32,32,32,32,32,32,32,50,45,116,117,112,108,101,115,32, + 99,111,110,116,97,105,110,105,110,103,32,116,104,101,32,108, + 111,97,100,101,114,32,97,110,100,32,116,104,101,32,102,105, + 108,101,32,115,117,102,102,105,120,101,115,32,116,104,101,32, + 108,111,97,100,101,114,10,32,32,32,32,32,32,32,32,114, + 101,99,111,103,110,105,122,101,115,46,99,1,0,0,0,0, + 0,0,0,2,0,0,0,3,0,0,0,51,0,0,0,115, + 27,0,0,0,124,0,0,93,17,0,125,1,0,124,1,0, + 136,0,0,102,2,0,86,1,113,3,0,100,0,0,83,41, + 1,78,114,4,0,0,0,41,2,114,22,0,0,0,114,57, + 1,0,0,41,1,114,170,0,0,0,114,4,0,0,0,114, + 5,0,0,0,114,77,0,0,0,157,7,0,0,115,2,0, + 0,0,6,0,122,38,70,105,108,101,70,105,110,100,101,114, + 46,95,95,105,110,105,116,95,95,46,60,108,111,99,97,108, + 115,62,46,60,103,101,110,101,120,112,114,62,114,116,0,0, + 0,114,29,0,0,0,78,114,139,0,0,0,41,7,114,196, + 0,0,0,218,8,95,108,111,97,100,101,114,115,114,35,0, + 0,0,218,11,95,112,97,116,104,95,109,116,105,109,101,218, + 3,115,101,116,218,11,95,112,97,116,104,95,99,97,99,104, + 101,218,19,95,114,101,108,97,120,101,100,95,112,97,116,104, + 95,99,97,99,104,101,41,5,114,71,0,0,0,114,35,0, + 0,0,218,14,108,111,97,100,101,114,95,100,101,116,97,105, + 108,115,90,7,108,111,97,100,101,114,115,114,126,0,0,0, + 114,4,0,0,0,41,1,114,170,0,0,0,114,5,0,0, + 0,114,72,0,0,0,151,7,0,0,115,16,0,0,0,0, + 4,6,1,19,1,36,1,9,2,15,1,9,1,12,1,122, + 19,70,105,108,101,70,105,110,100,101,114,46,95,95,105,110, + 105,116,95,95,99,1,0,0,0,0,0,0,0,1,0,0, + 0,2,0,0,0,67,0,0,0,115,13,0,0,0,100,3, + 0,124,0,0,95,0,0,100,2,0,83,41,4,122,31,73, + 110,118,97,108,105,100,97,116,101,32,116,104,101,32,100,105, + 114,101,99,116,111,114,121,32,109,116,105,109,101,46,114,29, + 0,0,0,78,114,139,0,0,0,41,1,114,89,1,0,0, + 41,1,114,71,0,0,0,114,4,0,0,0,114,4,0,0, + 0,114,5,0,0,0,114,74,1,0,0,165,7,0,0,115, + 2,0,0,0,0,2,122,28,70,105,108,101,70,105,110,100, 101,114,46,105,110,118,97,108,105,100,97,116,101,95,99,97, 99,104,101,115,99,2,0,0,0,0,0,0,0,3,0,0, - 0,12,0,0,0,67,0,0,0,115,107,0,0,0,116,0, - 0,106,1,0,100,1,0,107,9,0,114,41,0,116,0,0, - 106,1,0,12,114,41,0,116,2,0,106,3,0,100,2,0, - 116,4,0,131,2,0,1,120,59,0,116,0,0,106,1,0, - 68,93,44,0,125,2,0,121,14,0,124,2,0,124,1,0, - 131,1,0,83,87,113,51,0,4,116,5,0,107,10,0,114, - 94,0,1,1,1,119,51,0,89,113,51,0,88,113,51,0, - 87,100,1,0,83,100,1,0,83,41,3,122,113,83,101,97, - 114,99,104,32,115,101,113,117,101,110,99,101,32,111,102,32, - 104,111,111,107,115,32,102,111,114,32,97,32,102,105,110,100, - 101,114,32,102,111,114,32,39,112,97,116,104,39,46,10,10, - 32,32,32,32,32,32,32,32,73,102,32,39,104,111,111,107, - 115,39,32,105,115,32,102,97,108,115,101,32,116,104,101,110, - 32,117,115,101,32,115,121,115,46,112,97,116,104,95,104,111, - 111,107,115,46,10,10,32,32,32,32,32,32,32,32,78,122, - 23,115,121,115,46,112,97,116,104,95,104,111,111,107,115,32, - 105,115,32,101,109,112,116,121,41,6,114,7,0,0,0,218, - 10,112,97,116,104,95,104,111,111,107,115,114,167,0,0,0, - 114,168,0,0,0,114,169,0,0,0,114,154,0,0,0,41, - 3,114,10,1,0,0,114,35,0,0,0,90,4,104,111,111, - 107,114,4,0,0,0,114,4,0,0,0,114,5,0,0,0, - 218,11,95,112,97,116,104,95,104,111,111,107,115,24,7,0, - 0,115,16,0,0,0,0,7,25,1,16,1,16,1,3,1, - 14,1,13,1,12,2,122,22,80,97,116,104,70,105,110,100, - 101,114,46,95,112,97,116,104,95,104,111,111,107,115,99,2, - 0,0,0,0,0,0,0,3,0,0,0,19,0,0,0,67, - 0,0,0,115,123,0,0,0,124,1,0,100,1,0,107,2, - 0,114,53,0,121,16,0,116,0,0,106,1,0,131,0,0, - 125,1,0,87,110,22,0,4,116,2,0,107,10,0,114,52, - 0,1,1,1,100,2,0,83,89,110,1,0,88,121,17,0, - 116,3,0,106,4,0,124,1,0,25,125,2,0,87,110,46, - 0,4,116,5,0,107,10,0,114,118,0,1,1,1,124,0, - 0,106,6,0,124,1,0,131,1,0,125,2,0,124,2,0, - 116,3,0,106,4,0,124,1,0,60,89,110,1,0,88,124, - 2,0,83,41,3,122,210,71,101,116,32,116,104,101,32,102, - 105,110,100,101,114,32,102,111,114,32,116,104,101,32,112,97, - 116,104,32,101,110,116,114,121,32,102,114,111,109,32,115,121, - 115,46,112,97,116,104,95,105,109,112,111,114,116,101,114,95, - 99,97,99,104,101,46,10,10,32,32,32,32,32,32,32,32, - 73,102,32,116,104,101,32,112,97,116,104,32,101,110,116,114, - 121,32,105,115,32,110,111,116,32,105,110,32,116,104,101,32, - 99,97,99,104,101,44,32,102,105,110,100,32,116,104,101,32, - 97,112,112,114,111,112,114,105,97,116,101,32,102,105,110,100, - 101,114,10,32,32,32,32,32,32,32,32,97,110,100,32,99, - 97,99,104,101,32,105,116,46,32,73,102,32,110,111,32,102, - 105,110,100,101,114,32,105,115,32,97,118,97,105,108,97,98, - 108,101,44,32,115,116,111,114,101,32,78,111,110,101,46,10, - 10,32,32,32,32,32,32,32,32,114,30,0,0,0,78,41, - 7,114,3,0,0,0,114,45,0,0,0,218,17,70,105,108, - 101,78,111,116,70,111,117,110,100,69,114,114,111,114,114,7, - 0,0,0,114,75,1,0,0,114,79,0,0,0,114,79,1, - 0,0,41,3,114,10,1,0,0,114,35,0,0,0,114,77, - 1,0,0,114,4,0,0,0,114,4,0,0,0,114,5,0, - 0,0,218,20,95,112,97,116,104,95,105,109,112,111,114,116, - 101,114,95,99,97,99,104,101,41,7,0,0,115,22,0,0, - 0,0,8,12,1,3,1,16,1,13,3,9,1,3,1,17, - 1,13,1,15,1,18,1,122,31,80,97,116,104,70,105,110, - 100,101,114,46,95,112,97,116,104,95,105,109,112,111,114,116, - 101,114,95,99,97,99,104,101,99,3,0,0,0,0,0,0, - 0,6,0,0,0,3,0,0,0,67,0,0,0,115,113,0, - 0,0,116,0,0,124,2,0,100,1,0,131,2,0,114,39, - 0,124,2,0,106,1,0,124,1,0,131,1,0,92,2,0, - 125,3,0,125,4,0,110,21,0,124,2,0,106,2,0,124, - 1,0,131,1,0,125,3,0,103,0,0,125,4,0,124,3, - 0,100,0,0,107,9,0,114,85,0,116,3,0,124,1,0, - 124,3,0,131,2,0,83,116,4,0,124,1,0,100,0,0, - 131,2,0,125,5,0,124,4,0,124,5,0,95,5,0,124, - 5,0,83,41,2,78,114,166,0,0,0,41,6,114,60,0, - 0,0,114,166,0,0,0,114,13,1,0,0,114,174,0,0, - 0,114,216,0,0,0,114,220,0,0,0,41,6,114,10,1, - 0,0,114,159,0,0,0,114,77,1,0,0,114,170,0,0, - 0,114,171,0,0,0,114,177,0,0,0,114,4,0,0,0, - 114,4,0,0,0,114,5,0,0,0,218,16,95,108,101,103, - 97,99,121,95,103,101,116,95,115,112,101,99,63,7,0,0, - 115,18,0,0,0,0,4,15,1,24,2,15,1,6,1,12, - 1,13,1,15,1,9,1,122,27,80,97,116,104,70,105,110, - 100,101,114,46,95,108,101,103,97,99,121,95,103,101,116,95, - 115,112,101,99,78,99,4,0,0,0,0,0,0,0,9,0, - 0,0,5,0,0,0,67,0,0,0,115,240,0,0,0,103, - 0,0,125,4,0,120,227,0,124,2,0,68,93,191,0,125, - 5,0,116,0,0,124,5,0,116,1,0,116,2,0,102,2, - 0,131,2,0,115,43,0,113,13,0,124,0,0,106,3,0, - 124,5,0,131,1,0,125,6,0,124,6,0,100,1,0,107, - 9,0,114,13,0,116,4,0,124,6,0,100,2,0,131,2, - 0,114,106,0,124,6,0,106,5,0,124,1,0,124,3,0, - 131,2,0,125,7,0,110,18,0,124,0,0,106,6,0,124, - 1,0,124,6,0,131,2,0,125,7,0,124,7,0,100,1, - 0,107,8,0,114,139,0,113,13,0,124,7,0,106,7,0, - 100,1,0,107,9,0,114,158,0,124,7,0,83,124,7,0, - 106,8,0,125,8,0,124,8,0,100,1,0,107,8,0,114, - 191,0,116,9,0,100,3,0,131,1,0,130,1,0,124,4, - 0,106,10,0,124,8,0,131,1,0,1,113,13,0,87,116, - 11,0,124,1,0,100,1,0,131,2,0,125,7,0,124,4, - 0,124,7,0,95,8,0,124,7,0,83,100,1,0,83,41, - 4,122,63,70,105,110,100,32,116,104,101,32,108,111,97,100, - 101,114,32,111,114,32,110,97,109,101,115,112,97,99,101,95, - 112,97,116,104,32,102,111,114,32,116,104,105,115,32,109,111, - 100,117,108,101,47,112,97,99,107,97,103,101,32,110,97,109, - 101,46,78,114,12,1,0,0,122,19,115,112,101,99,32,109, - 105,115,115,105,110,103,32,108,111,97,100,101,114,41,12,114, - 191,0,0,0,218,3,115,116,114,218,5,98,121,116,101,115, - 114,81,1,0,0,114,60,0,0,0,114,12,1,0,0,114, - 82,1,0,0,114,170,0,0,0,114,220,0,0,0,114,154, - 0,0,0,114,196,0,0,0,114,216,0,0,0,41,9,114, - 10,1,0,0,114,159,0,0,0,114,35,0,0,0,114,11, - 1,0,0,218,14,110,97,109,101,115,112,97,99,101,95,112, - 97,116,104,90,5,101,110,116,114,121,114,77,1,0,0,114, - 177,0,0,0,114,171,0,0,0,114,4,0,0,0,114,4, - 0,0,0,114,5,0,0,0,218,9,95,103,101,116,95,115, - 112,101,99,78,7,0,0,115,40,0,0,0,0,5,6,1, - 13,1,21,1,3,1,15,1,12,1,15,1,21,2,18,1, - 12,1,3,1,15,1,4,1,9,1,12,1,12,5,17,2, - 15,1,9,1,122,20,80,97,116,104,70,105,110,100,101,114, - 46,95,103,101,116,95,115,112,101,99,99,4,0,0,0,0, - 0,0,0,6,0,0,0,4,0,0,0,67,0,0,0,115, - 140,0,0,0,124,2,0,100,1,0,107,8,0,114,21,0, - 116,0,0,106,1,0,125,2,0,124,0,0,106,2,0,124, - 1,0,124,2,0,124,3,0,131,3,0,125,4,0,124,4, - 0,100,1,0,107,8,0,114,58,0,100,1,0,83,124,4, - 0,106,3,0,100,1,0,107,8,0,114,132,0,124,4,0, - 106,4,0,125,5,0,124,5,0,114,125,0,100,2,0,124, - 4,0,95,5,0,116,6,0,124,1,0,124,5,0,124,0, - 0,106,2,0,131,3,0,124,4,0,95,4,0,124,4,0, - 83,100,1,0,83,110,4,0,124,4,0,83,100,1,0,83, - 41,3,122,98,102,105,110,100,32,116,104,101,32,109,111,100, - 117,108,101,32,111,110,32,115,121,115,46,112,97,116,104,32, - 111,114,32,39,112,97,116,104,39,32,98,97,115,101,100,32, - 111,110,32,115,121,115,46,112,97,116,104,95,104,111,111,107, - 115,32,97,110,100,10,32,32,32,32,32,32,32,32,115,121, - 115,46,112,97,116,104,95,105,109,112,111,114,116,101,114,95, - 99,97,99,104,101,46,78,90,9,110,97,109,101,115,112,97, - 99,101,41,7,114,7,0,0,0,114,35,0,0,0,114,86, - 1,0,0,114,170,0,0,0,114,220,0,0,0,114,217,0, - 0,0,114,60,1,0,0,41,6,114,10,1,0,0,114,159, - 0,0,0,114,35,0,0,0,114,11,1,0,0,114,177,0, - 0,0,114,85,1,0,0,114,4,0,0,0,114,4,0,0, - 0,114,5,0,0,0,114,12,1,0,0,110,7,0,0,115, - 26,0,0,0,0,4,12,1,9,1,21,1,12,1,4,1, - 15,1,9,1,6,3,9,1,24,1,4,2,7,2,122,20, - 80,97,116,104,70,105,110,100,101,114,46,102,105,110,100,95, - 115,112,101,99,99,3,0,0,0,0,0,0,0,4,0,0, - 0,3,0,0,0,67,0,0,0,115,41,0,0,0,124,0, - 0,106,0,0,124,1,0,124,2,0,131,2,0,125,3,0, - 124,3,0,100,1,0,107,8,0,114,34,0,100,1,0,83, - 124,3,0,106,1,0,83,41,2,122,170,102,105,110,100,32, - 116,104,101,32,109,111,100,117,108,101,32,111,110,32,115,121, - 115,46,112,97,116,104,32,111,114,32,39,112,97,116,104,39, - 32,98,97,115,101,100,32,111,110,32,115,121,115,46,112,97, - 116,104,95,104,111,111,107,115,32,97,110,100,10,32,32,32, - 32,32,32,32,32,115,121,115,46,112,97,116,104,95,105,109, - 112,111,114,116,101,114,95,99,97,99,104,101,46,10,10,32, - 32,32,32,32,32,32,32,84,104,105,115,32,109,101,116,104, - 111,100,32,105,115,32,100,101,112,114,101,99,97,116,101,100, - 46,32,32,85,115,101,32,102,105,110,100,95,115,112,101,99, - 40,41,32,105,110,115,116,101,97,100,46,10,10,32,32,32, - 32,32,32,32,32,78,41,2,114,12,1,0,0,114,170,0, - 0,0,41,4,114,10,1,0,0,114,159,0,0,0,114,35, - 0,0,0,114,177,0,0,0,114,4,0,0,0,114,4,0, - 0,0,114,5,0,0,0,114,13,1,0,0,132,7,0,0, - 115,8,0,0,0,0,8,18,1,12,1,4,1,122,22,80, - 97,116,104,70,105,110,100,101,114,46,102,105,110,100,95,109, - 111,100,117,108,101,41,12,114,57,0,0,0,114,56,0,0, - 0,114,58,0,0,0,114,59,0,0,0,114,17,1,0,0, - 114,74,1,0,0,114,79,1,0,0,114,81,1,0,0,114, - 82,1,0,0,114,86,1,0,0,114,12,1,0,0,114,13, - 1,0,0,114,4,0,0,0,114,4,0,0,0,114,4,0, - 0,0,114,5,0,0,0,114,73,1,0,0,12,7,0,0, - 115,22,0,0,0,12,2,6,2,18,8,18,17,18,22,18, - 15,3,1,18,31,3,1,21,21,3,1,114,73,1,0,0, - 99,0,0,0,0,0,0,0,0,0,0,0,0,3,0,0, - 0,64,0,0,0,115,133,0,0,0,101,0,0,90,1,0, - 100,0,0,90,2,0,100,1,0,90,3,0,100,2,0,100, - 3,0,132,0,0,90,4,0,100,4,0,100,5,0,132,0, - 0,90,5,0,101,6,0,90,7,0,100,6,0,100,7,0, - 132,0,0,90,8,0,100,8,0,100,9,0,132,0,0,90, - 9,0,100,10,0,100,11,0,100,12,0,132,1,0,90,10, - 0,100,13,0,100,14,0,132,0,0,90,11,0,101,12,0, - 100,15,0,100,16,0,132,0,0,131,1,0,90,13,0,100, - 17,0,100,18,0,132,0,0,90,14,0,100,10,0,83,41, - 19,218,10,70,105,108,101,70,105,110,100,101,114,122,172,70, - 105,108,101,45,98,97,115,101,100,32,102,105,110,100,101,114, - 46,10,10,32,32,32,32,73,110,116,101,114,97,99,116,105, - 111,110,115,32,119,105,116,104,32,116,104,101,32,102,105,108, - 101,32,115,121,115,116,101,109,32,97,114,101,32,99,97,99, - 104,101,100,32,102,111,114,32,112,101,114,102,111,114,109,97, - 110,99,101,44,32,98,101,105,110,103,10,32,32,32,32,114, - 101,102,114,101,115,104,101,100,32,119,104,101,110,32,116,104, - 101,32,100,105,114,101,99,116,111,114,121,32,116,104,101,32, - 102,105,110,100,101,114,32,105,115,32,104,97,110,100,108,105, - 110,103,32,104,97,115,32,98,101,101,110,32,109,111,100,105, - 102,105,101,100,46,10,10,32,32,32,32,99,2,0,0,0, - 0,0,0,0,5,0,0,0,5,0,0,0,7,0,0,0, - 115,122,0,0,0,103,0,0,125,3,0,120,52,0,124,2, - 0,68,93,44,0,92,2,0,137,0,0,125,4,0,124,3, - 0,106,0,0,135,0,0,102,1,0,100,1,0,100,2,0, - 134,0,0,124,4,0,68,131,1,0,131,1,0,1,113,13, - 0,87,124,3,0,124,0,0,95,1,0,124,1,0,112,79, - 0,100,3,0,124,0,0,95,2,0,100,6,0,124,0,0, - 95,3,0,116,4,0,131,0,0,124,0,0,95,5,0,116, - 4,0,131,0,0,124,0,0,95,6,0,100,5,0,83,41, - 7,122,154,73,110,105,116,105,97,108,105,122,101,32,119,105, - 116,104,32,116,104,101,32,112,97,116,104,32,116,111,32,115, - 101,97,114,99,104,32,111,110,32,97,110,100,32,97,32,118, - 97,114,105,97,98,108,101,32,110,117,109,98,101,114,32,111, - 102,10,32,32,32,32,32,32,32,32,50,45,116,117,112,108, - 101,115,32,99,111,110,116,97,105,110,105,110,103,32,116,104, - 101,32,108,111,97,100,101,114,32,97,110,100,32,116,104,101, - 32,102,105,108,101,32,115,117,102,102,105,120,101,115,32,116, - 104,101,32,108,111,97,100,101,114,10,32,32,32,32,32,32, - 32,32,114,101,99,111,103,110,105,122,101,115,46,99,1,0, - 0,0,0,0,0,0,2,0,0,0,3,0,0,0,51,0, - 0,0,115,27,0,0,0,124,0,0,93,17,0,125,1,0, - 124,1,0,136,0,0,102,2,0,86,1,113,3,0,100,0, - 0,83,41,1,78,114,4,0,0,0,41,2,114,22,0,0, - 0,114,57,1,0,0,41,1,114,170,0,0,0,114,4,0, - 0,0,114,5,0,0,0,114,77,0,0,0,161,7,0,0, - 115,2,0,0,0,6,0,122,38,70,105,108,101,70,105,110, - 100,101,114,46,95,95,105,110,105,116,95,95,46,60,108,111, - 99,97,108,115,62,46,60,103,101,110,101,120,112,114,62,114, - 116,0,0,0,114,29,0,0,0,78,114,139,0,0,0,41, - 7,114,196,0,0,0,218,8,95,108,111,97,100,101,114,115, - 114,35,0,0,0,218,11,95,112,97,116,104,95,109,116,105, - 109,101,218,3,115,101,116,218,11,95,112,97,116,104,95,99, - 97,99,104,101,218,19,95,114,101,108,97,120,101,100,95,112, - 97,116,104,95,99,97,99,104,101,41,5,114,71,0,0,0, - 114,35,0,0,0,218,14,108,111,97,100,101,114,95,100,101, - 116,97,105,108,115,90,7,108,111,97,100,101,114,115,114,126, - 0,0,0,114,4,0,0,0,41,1,114,170,0,0,0,114, - 5,0,0,0,114,72,0,0,0,155,7,0,0,115,16,0, - 0,0,0,4,6,1,19,1,36,1,9,2,15,1,9,1, - 12,1,122,19,70,105,108,101,70,105,110,100,101,114,46,95, - 95,105,110,105,116,95,95,99,1,0,0,0,0,0,0,0, - 1,0,0,0,2,0,0,0,67,0,0,0,115,13,0,0, - 0,100,3,0,124,0,0,95,0,0,100,2,0,83,41,4, - 122,31,73,110,118,97,108,105,100,97,116,101,32,116,104,101, - 32,100,105,114,101,99,116,111,114,121,32,109,116,105,109,101, - 46,114,29,0,0,0,78,114,139,0,0,0,41,1,114,89, - 1,0,0,41,1,114,71,0,0,0,114,4,0,0,0,114, - 4,0,0,0,114,5,0,0,0,114,74,1,0,0,169,7, - 0,0,115,2,0,0,0,0,2,122,28,70,105,108,101,70, - 105,110,100,101,114,46,105,110,118,97,108,105,100,97,116,101, - 95,99,97,99,104,101,115,99,2,0,0,0,0,0,0,0, - 3,0,0,0,2,0,0,0,67,0,0,0,115,59,0,0, - 0,124,0,0,106,0,0,124,1,0,131,1,0,125,2,0, - 124,2,0,100,1,0,107,8,0,114,37,0,100,1,0,103, - 0,0,102,2,0,83,124,2,0,106,1,0,124,2,0,106, - 2,0,112,55,0,103,0,0,102,2,0,83,41,2,122,197, - 84,114,121,32,116,111,32,102,105,110,100,32,97,32,108,111, - 97,100,101,114,32,102,111,114,32,116,104,101,32,115,112,101, - 99,105,102,105,101,100,32,109,111,100,117,108,101,44,32,111, - 114,32,116,104,101,32,110,97,109,101,115,112,97,99,101,10, - 32,32,32,32,32,32,32,32,112,97,99,107,97,103,101,32, - 112,111,114,116,105,111,110,115,46,32,82,101,116,117,114,110, - 115,32,40,108,111,97,100,101,114,44,32,108,105,115,116,45, - 111,102,45,112,111,114,116,105,111,110,115,41,46,10,10,32, - 32,32,32,32,32,32,32,84,104,105,115,32,109,101,116,104, - 111,100,32,105,115,32,100,101,112,114,101,99,97,116,101,100, - 46,32,32,85,115,101,32,102,105,110,100,95,115,112,101,99, - 40,41,32,105,110,115,116,101,97,100,46,10,10,32,32,32, - 32,32,32,32,32,78,41,3,114,12,1,0,0,114,170,0, - 0,0,114,220,0,0,0,41,3,114,71,0,0,0,114,159, - 0,0,0,114,177,0,0,0,114,4,0,0,0,114,4,0, - 0,0,114,5,0,0,0,114,166,0,0,0,175,7,0,0, - 115,8,0,0,0,0,7,15,1,12,1,10,1,122,22,70, - 105,108,101,70,105,110,100,101,114,46,102,105,110,100,95,108, - 111,97,100,101,114,99,6,0,0,0,0,0,0,0,7,0, - 0,0,7,0,0,0,67,0,0,0,115,40,0,0,0,124, - 1,0,124,2,0,124,3,0,131,2,0,125,6,0,116,0, - 0,124,2,0,124,3,0,100,1,0,124,6,0,100,2,0, - 124,4,0,131,2,2,83,41,3,78,114,170,0,0,0,114, - 220,0,0,0,41,1,114,239,0,0,0,41,7,114,71,0, - 0,0,114,243,0,0,0,114,159,0,0,0,114,35,0,0, - 0,114,228,0,0,0,114,11,1,0,0,114,170,0,0,0, + 0,2,0,0,0,67,0,0,0,115,59,0,0,0,124,0, + 0,106,0,0,124,1,0,131,1,0,125,2,0,124,2,0, + 100,1,0,107,8,0,114,37,0,100,1,0,103,0,0,102, + 2,0,83,124,2,0,106,1,0,124,2,0,106,2,0,112, + 55,0,103,0,0,102,2,0,83,41,2,122,197,84,114,121, + 32,116,111,32,102,105,110,100,32,97,32,108,111,97,100,101, + 114,32,102,111,114,32,116,104,101,32,115,112,101,99,105,102, + 105,101,100,32,109,111,100,117,108,101,44,32,111,114,32,116, + 104,101,32,110,97,109,101,115,112,97,99,101,10,32,32,32, + 32,32,32,32,32,112,97,99,107,97,103,101,32,112,111,114, + 116,105,111,110,115,46,32,82,101,116,117,114,110,115,32,40, + 108,111,97,100,101,114,44,32,108,105,115,116,45,111,102,45, + 112,111,114,116,105,111,110,115,41,46,10,10,32,32,32,32, + 32,32,32,32,84,104,105,115,32,109,101,116,104,111,100,32, + 105,115,32,100,101,112,114,101,99,97,116,101,100,46,32,32, + 85,115,101,32,102,105,110,100,95,115,112,101,99,40,41,32, + 105,110,115,116,101,97,100,46,10,10,32,32,32,32,32,32, + 32,32,78,41,3,114,12,1,0,0,114,170,0,0,0,114, + 220,0,0,0,41,3,114,71,0,0,0,114,159,0,0,0, + 114,177,0,0,0,114,4,0,0,0,114,4,0,0,0,114, + 5,0,0,0,114,166,0,0,0,171,7,0,0,115,8,0, + 0,0,0,7,15,1,12,1,10,1,122,22,70,105,108,101, + 70,105,110,100,101,114,46,102,105,110,100,95,108,111,97,100, + 101,114,99,6,0,0,0,0,0,0,0,7,0,0,0,7, + 0,0,0,67,0,0,0,115,40,0,0,0,124,1,0,124, + 2,0,124,3,0,131,2,0,125,6,0,116,0,0,124,2, + 0,124,3,0,100,1,0,124,6,0,100,2,0,124,4,0, + 131,2,2,83,41,3,78,114,170,0,0,0,114,220,0,0, + 0,41,1,114,239,0,0,0,41,7,114,71,0,0,0,114, + 243,0,0,0,114,159,0,0,0,114,35,0,0,0,114,228, + 0,0,0,114,11,1,0,0,114,170,0,0,0,114,4,0, + 0,0,114,4,0,0,0,114,5,0,0,0,114,86,1,0, + 0,183,7,0,0,115,6,0,0,0,0,1,15,1,18,1, + 122,20,70,105,108,101,70,105,110,100,101,114,46,95,103,101, + 116,95,115,112,101,99,78,99,3,0,0,0,0,0,0,0, + 14,0,0,0,15,0,0,0,67,0,0,0,115,231,1,0, + 0,100,1,0,125,3,0,124,1,0,106,0,0,100,2,0, + 131,1,0,100,3,0,25,125,4,0,121,34,0,116,1,0, + 124,0,0,106,2,0,112,49,0,116,3,0,106,4,0,131, + 0,0,131,1,0,106,5,0,125,5,0,87,110,24,0,4, + 116,6,0,107,10,0,114,85,0,1,1,1,100,10,0,125, + 5,0,89,110,1,0,88,124,5,0,124,0,0,106,7,0, + 107,3,0,114,120,0,124,0,0,106,8,0,131,0,0,1, + 124,5,0,124,0,0,95,7,0,116,9,0,131,0,0,114, + 153,0,124,0,0,106,10,0,125,6,0,124,4,0,106,11, + 0,131,0,0,125,7,0,110,15,0,124,0,0,106,12,0, + 125,6,0,124,4,0,125,7,0,124,7,0,124,6,0,107, + 6,0,114,45,1,116,13,0,124,0,0,106,2,0,124,4, + 0,131,2,0,125,8,0,120,100,0,124,0,0,106,14,0, + 68,93,77,0,92,2,0,125,9,0,125,10,0,100,5,0, + 124,9,0,23,125,11,0,116,13,0,124,8,0,124,11,0, + 131,2,0,125,12,0,116,15,0,124,12,0,131,1,0,114, + 208,0,124,0,0,106,16,0,124,10,0,124,1,0,124,12, + 0,124,8,0,103,1,0,124,2,0,131,5,0,83,113,208, + 0,87,116,17,0,124,8,0,131,1,0,125,3,0,120,123, + 0,124,0,0,106,14,0,68,93,112,0,92,2,0,125,9, + 0,125,10,0,116,13,0,124,0,0,106,2,0,124,4,0, + 124,9,0,23,131,2,0,125,12,0,116,18,0,100,6,0, + 106,19,0,124,12,0,131,1,0,100,7,0,100,3,0,131, + 1,1,1,124,7,0,124,9,0,23,124,6,0,107,6,0, + 114,55,1,116,15,0,124,12,0,131,1,0,114,55,1,124, + 0,0,106,16,0,124,10,0,124,1,0,124,12,0,100,8, + 0,124,2,0,131,5,0,83,113,55,1,87,124,3,0,114, + 227,1,116,18,0,100,9,0,106,19,0,124,8,0,131,1, + 0,131,1,0,1,116,20,0,124,1,0,100,8,0,131,2, + 0,125,13,0,124,8,0,103,1,0,124,13,0,95,21,0, + 124,13,0,83,100,8,0,83,41,11,122,125,84,114,121,32, + 116,111,32,102,105,110,100,32,97,32,108,111,97,100,101,114, + 32,102,111,114,32,116,104,101,32,115,112,101,99,105,102,105, + 101,100,32,109,111,100,117,108,101,44,32,111,114,32,116,104, + 101,32,110,97,109,101,115,112,97,99,101,10,32,32,32,32, + 32,32,32,32,112,97,99,107,97,103,101,32,112,111,114,116, + 105,111,110,115,46,32,82,101,116,117,114,110,115,32,40,108, + 111,97,100,101,114,44,32,108,105,115,116,45,111,102,45,112, + 111,114,116,105,111,110,115,41,46,70,114,116,0,0,0,114, + 115,0,0,0,114,29,0,0,0,114,72,0,0,0,122,9, + 116,114,121,105,110,103,32,123,125,114,146,0,0,0,78,122, + 25,112,111,115,115,105,98,108,101,32,110,97,109,101,115,112, + 97,99,101,32,102,111,114,32,123,125,114,139,0,0,0,41, + 22,114,32,0,0,0,114,39,0,0,0,114,35,0,0,0, + 114,3,0,0,0,114,45,0,0,0,114,53,1,0,0,114, + 40,0,0,0,114,89,1,0,0,218,11,95,102,105,108,108, + 95,99,97,99,104,101,114,6,0,0,0,114,92,1,0,0, + 114,140,0,0,0,114,91,1,0,0,114,28,0,0,0,114, + 88,1,0,0,114,44,0,0,0,114,86,1,0,0,114,46, + 0,0,0,114,153,0,0,0,114,47,0,0,0,114,216,0, + 0,0,114,220,0,0,0,41,14,114,71,0,0,0,114,159, + 0,0,0,114,11,1,0,0,90,12,105,115,95,110,97,109, + 101,115,112,97,99,101,90,11,116,97,105,108,95,109,111,100, + 117,108,101,114,182,0,0,0,90,5,99,97,99,104,101,90, + 12,99,97,99,104,101,95,109,111,100,117,108,101,90,9,98, + 97,115,101,95,112,97,116,104,114,57,1,0,0,114,243,0, + 0,0,90,13,105,110,105,116,95,102,105,108,101,110,97,109, + 101,90,9,102,117,108,108,95,112,97,116,104,114,177,0,0, + 0,114,4,0,0,0,114,4,0,0,0,114,5,0,0,0, + 114,12,1,0,0,188,7,0,0,115,68,0,0,0,0,3, + 6,1,19,1,3,1,34,1,13,1,11,1,15,1,10,1, + 9,2,9,1,9,1,15,2,9,1,6,2,12,1,18,1, + 22,1,10,1,15,1,12,1,32,4,12,2,22,1,22,1, + 25,1,16,1,12,1,29,1,6,1,19,1,15,1,12,1, + 4,1,122,20,70,105,108,101,70,105,110,100,101,114,46,102, + 105,110,100,95,115,112,101,99,99,1,0,0,0,0,0,0, + 0,9,0,0,0,13,0,0,0,67,0,0,0,115,11,1, + 0,0,124,0,0,106,0,0,125,1,0,121,31,0,116,1, + 0,106,2,0,124,1,0,112,33,0,116,1,0,106,3,0, + 131,0,0,131,1,0,125,2,0,87,110,33,0,4,116,4, + 0,116,5,0,116,6,0,102,3,0,107,10,0,114,75,0, + 1,1,1,103,0,0,125,2,0,89,110,1,0,88,116,7, + 0,106,8,0,106,9,0,100,1,0,131,1,0,115,112,0, + 116,10,0,124,2,0,131,1,0,124,0,0,95,11,0,110, + 111,0,116,10,0,131,0,0,125,3,0,120,90,0,124,2, + 0,68,93,82,0,125,4,0,124,4,0,106,12,0,100,2, + 0,131,1,0,92,3,0,125,5,0,125,6,0,125,7,0, + 124,6,0,114,191,0,100,3,0,106,13,0,124,5,0,124, + 7,0,106,14,0,131,0,0,131,2,0,125,8,0,110,6, + 0,124,5,0,125,8,0,124,3,0,106,15,0,124,8,0, + 131,1,0,1,113,128,0,87,124,3,0,124,0,0,95,11, + 0,116,7,0,106,8,0,106,9,0,116,16,0,131,1,0, + 114,7,1,100,4,0,100,5,0,132,0,0,124,2,0,68, + 131,1,0,124,0,0,95,17,0,100,6,0,83,41,7,122, + 68,70,105,108,108,32,116,104,101,32,99,97,99,104,101,32, + 111,102,32,112,111,116,101,110,116,105,97,108,32,109,111,100, + 117,108,101,115,32,97,110,100,32,112,97,99,107,97,103,101, + 115,32,102,111,114,32,116,104,105,115,32,100,105,114,101,99, + 116,111,114,121,46,114,0,0,0,0,114,116,0,0,0,122, + 5,123,125,46,123,125,99,1,0,0,0,0,0,0,0,2, + 0,0,0,3,0,0,0,83,0,0,0,115,28,0,0,0, + 104,0,0,124,0,0,93,18,0,125,1,0,124,1,0,106, + 0,0,131,0,0,146,2,0,113,6,0,83,114,4,0,0, + 0,41,1,114,140,0,0,0,41,2,114,22,0,0,0,90, + 2,102,110,114,4,0,0,0,114,4,0,0,0,114,5,0, + 0,0,250,9,60,115,101,116,99,111,109,112,62,6,8,0, + 0,115,2,0,0,0,9,0,122,41,70,105,108,101,70,105, + 110,100,101,114,46,95,102,105,108,108,95,99,97,99,104,101, + 46,60,108,111,99,97,108,115,62,46,60,115,101,116,99,111, + 109,112,62,78,41,18,114,35,0,0,0,114,3,0,0,0, + 90,7,108,105,115,116,100,105,114,114,45,0,0,0,114,80, + 1,0,0,218,15,80,101,114,109,105,115,115,105,111,110,69, + 114,114,111,114,218,18,78,111,116,65,68,105,114,101,99,116, + 111,114,121,69,114,114,111,114,114,7,0,0,0,114,8,0, + 0,0,114,9,0,0,0,114,90,1,0,0,114,91,1,0, + 0,114,134,0,0,0,114,47,0,0,0,114,140,0,0,0, + 218,3,97,100,100,114,10,0,0,0,114,92,1,0,0,41, + 9,114,71,0,0,0,114,35,0,0,0,90,8,99,111,110, + 116,101,110,116,115,90,21,108,111,119,101,114,95,115,117,102, + 102,105,120,95,99,111,110,116,101,110,116,115,114,71,1,0, + 0,114,67,0,0,0,114,65,1,0,0,114,57,1,0,0, + 90,8,110,101,119,95,110,97,109,101,114,4,0,0,0,114, + 4,0,0,0,114,5,0,0,0,114,94,1,0,0,233,7, + 0,0,115,34,0,0,0,0,2,9,1,3,1,31,1,22, + 3,11,3,18,1,18,7,9,1,13,1,24,1,6,1,27, + 2,6,1,17,1,9,1,18,1,122,22,70,105,108,101,70, + 105,110,100,101,114,46,95,102,105,108,108,95,99,97,99,104, + 101,99,1,0,0,0,0,0,0,0,3,0,0,0,3,0, + 0,0,7,0,0,0,115,25,0,0,0,135,0,0,135,1, + 0,102,2,0,100,1,0,100,2,0,134,0,0,125,2,0, + 124,2,0,83,41,3,97,20,1,0,0,65,32,99,108,97, + 115,115,32,109,101,116,104,111,100,32,119,104,105,99,104,32, + 114,101,116,117,114,110,115,32,97,32,99,108,111,115,117,114, + 101,32,116,111,32,117,115,101,32,111,110,32,115,121,115,46, + 112,97,116,104,95,104,111,111,107,10,32,32,32,32,32,32, + 32,32,119,104,105,99,104,32,119,105,108,108,32,114,101,116, + 117,114,110,32,97,110,32,105,110,115,116,97,110,99,101,32, + 117,115,105,110,103,32,116,104,101,32,115,112,101,99,105,102, + 105,101,100,32,108,111,97,100,101,114,115,32,97,110,100,32, + 116,104,101,32,112,97,116,104,10,32,32,32,32,32,32,32, + 32,99,97,108,108,101,100,32,111,110,32,116,104,101,32,99, + 108,111,115,117,114,101,46,10,10,32,32,32,32,32,32,32, + 32,73,102,32,116,104,101,32,112,97,116,104,32,99,97,108, + 108,101,100,32,111,110,32,116,104,101,32,99,108,111,115,117, + 114,101,32,105,115,32,110,111,116,32,97,32,100,105,114,101, + 99,116,111,114,121,44,32,73,109,112,111,114,116,69,114,114, + 111,114,32,105,115,10,32,32,32,32,32,32,32,32,114,97, + 105,115,101,100,46,10,10,32,32,32,32,32,32,32,32,99, + 1,0,0,0,0,0,0,0,1,0,0,0,4,0,0,0, + 19,0,0,0,115,43,0,0,0,116,0,0,124,0,0,131, + 1,0,115,30,0,116,1,0,100,1,0,100,2,0,124,0, + 0,131,1,1,130,1,0,136,0,0,124,0,0,136,1,0, + 140,1,0,83,41,3,122,45,80,97,116,104,32,104,111,111, + 107,32,102,111,114,32,105,109,112,111,114,116,108,105,98,46, + 109,97,99,104,105,110,101,114,121,46,70,105,108,101,70,105, + 110,100,101,114,46,122,30,111,110,108,121,32,100,105,114,101, + 99,116,111,114,105,101,115,32,97,114,101,32,115,117,112,112, + 111,114,116,101,100,114,35,0,0,0,41,2,114,46,0,0, + 0,114,154,0,0,0,41,1,114,35,0,0,0,41,2,114, + 10,1,0,0,114,93,1,0,0,114,4,0,0,0,114,5, + 0,0,0,218,24,112,97,116,104,95,104,111,111,107,95,102, + 111,114,95,70,105,108,101,70,105,110,100,101,114,18,8,0, + 0,115,6,0,0,0,0,2,12,1,18,1,122,54,70,105, + 108,101,70,105,110,100,101,114,46,112,97,116,104,95,104,111, + 111,107,46,60,108,111,99,97,108,115,62,46,112,97,116,104, + 95,104,111,111,107,95,102,111,114,95,70,105,108,101,70,105, + 110,100,101,114,114,4,0,0,0,41,3,114,10,1,0,0, + 114,93,1,0,0,114,99,1,0,0,114,4,0,0,0,41, + 2,114,10,1,0,0,114,93,1,0,0,114,5,0,0,0, + 218,9,112,97,116,104,95,104,111,111,107,8,8,0,0,115, + 4,0,0,0,0,10,21,6,122,20,70,105,108,101,70,105, + 110,100,101,114,46,112,97,116,104,95,104,111,111,107,99,1, + 0,0,0,0,0,0,0,1,0,0,0,2,0,0,0,67, + 0,0,0,115,16,0,0,0,100,1,0,106,0,0,124,0, + 0,106,1,0,131,1,0,83,41,2,78,122,16,70,105,108, + 101,70,105,110,100,101,114,40,123,33,114,125,41,41,2,114, + 47,0,0,0,114,35,0,0,0,41,1,114,71,0,0,0, 114,4,0,0,0,114,4,0,0,0,114,5,0,0,0,114, - 86,1,0,0,187,7,0,0,115,6,0,0,0,0,1,15, - 1,18,1,122,20,70,105,108,101,70,105,110,100,101,114,46, - 95,103,101,116,95,115,112,101,99,78,99,3,0,0,0,0, - 0,0,0,14,0,0,0,15,0,0,0,67,0,0,0,115, - 231,1,0,0,100,1,0,125,3,0,124,1,0,106,0,0, - 100,2,0,131,1,0,100,3,0,25,125,4,0,121,34,0, - 116,1,0,124,0,0,106,2,0,112,49,0,116,3,0,106, - 4,0,131,0,0,131,1,0,106,5,0,125,5,0,87,110, - 24,0,4,116,6,0,107,10,0,114,85,0,1,1,1,100, - 10,0,125,5,0,89,110,1,0,88,124,5,0,124,0,0, - 106,7,0,107,3,0,114,120,0,124,0,0,106,8,0,131, - 0,0,1,124,5,0,124,0,0,95,7,0,116,9,0,131, - 0,0,114,153,0,124,0,0,106,10,0,125,6,0,124,4, - 0,106,11,0,131,0,0,125,7,0,110,15,0,124,0,0, - 106,12,0,125,6,0,124,4,0,125,7,0,124,7,0,124, - 6,0,107,6,0,114,45,1,116,13,0,124,0,0,106,2, - 0,124,4,0,131,2,0,125,8,0,120,100,0,124,0,0, - 106,14,0,68,93,77,0,92,2,0,125,9,0,125,10,0, - 100,5,0,124,9,0,23,125,11,0,116,13,0,124,8,0, - 124,11,0,131,2,0,125,12,0,116,15,0,124,12,0,131, - 1,0,114,208,0,124,0,0,106,16,0,124,10,0,124,1, - 0,124,12,0,124,8,0,103,1,0,124,2,0,131,5,0, - 83,113,208,0,87,116,17,0,124,8,0,131,1,0,125,3, - 0,120,123,0,124,0,0,106,14,0,68,93,112,0,92,2, - 0,125,9,0,125,10,0,116,13,0,124,0,0,106,2,0, - 124,4,0,124,9,0,23,131,2,0,125,12,0,116,18,0, - 100,6,0,106,19,0,124,12,0,131,1,0,100,7,0,100, - 3,0,131,1,1,1,124,7,0,124,9,0,23,124,6,0, - 107,6,0,114,55,1,116,15,0,124,12,0,131,1,0,114, - 55,1,124,0,0,106,16,0,124,10,0,124,1,0,124,12, - 0,100,8,0,124,2,0,131,5,0,83,113,55,1,87,124, - 3,0,114,227,1,116,18,0,100,9,0,106,19,0,124,8, - 0,131,1,0,131,1,0,1,116,20,0,124,1,0,100,8, - 0,131,2,0,125,13,0,124,8,0,103,1,0,124,13,0, - 95,21,0,124,13,0,83,100,8,0,83,41,11,122,125,84, - 114,121,32,116,111,32,102,105,110,100,32,97,32,108,111,97, - 100,101,114,32,102,111,114,32,116,104,101,32,115,112,101,99, - 105,102,105,101,100,32,109,111,100,117,108,101,44,32,111,114, - 32,116,104,101,32,110,97,109,101,115,112,97,99,101,10,32, - 32,32,32,32,32,32,32,112,97,99,107,97,103,101,32,112, - 111,114,116,105,111,110,115,46,32,82,101,116,117,114,110,115, - 32,40,108,111,97,100,101,114,44,32,108,105,115,116,45,111, - 102,45,112,111,114,116,105,111,110,115,41,46,70,114,116,0, - 0,0,114,115,0,0,0,114,29,0,0,0,114,72,0,0, - 0,122,9,116,114,121,105,110,103,32,123,125,114,146,0,0, - 0,78,122,25,112,111,115,115,105,98,108,101,32,110,97,109, - 101,115,112,97,99,101,32,102,111,114,32,123,125,114,139,0, - 0,0,41,22,114,32,0,0,0,114,39,0,0,0,114,35, - 0,0,0,114,3,0,0,0,114,45,0,0,0,114,53,1, - 0,0,114,40,0,0,0,114,89,1,0,0,218,11,95,102, - 105,108,108,95,99,97,99,104,101,114,6,0,0,0,114,92, - 1,0,0,114,140,0,0,0,114,91,1,0,0,114,28,0, - 0,0,114,88,1,0,0,114,44,0,0,0,114,86,1,0, - 0,114,46,0,0,0,114,153,0,0,0,114,47,0,0,0, - 114,216,0,0,0,114,220,0,0,0,41,14,114,71,0,0, - 0,114,159,0,0,0,114,11,1,0,0,90,12,105,115,95, - 110,97,109,101,115,112,97,99,101,90,11,116,97,105,108,95, - 109,111,100,117,108,101,114,182,0,0,0,90,5,99,97,99, - 104,101,90,12,99,97,99,104,101,95,109,111,100,117,108,101, - 90,9,98,97,115,101,95,112,97,116,104,114,57,1,0,0, - 114,243,0,0,0,90,13,105,110,105,116,95,102,105,108,101, - 110,97,109,101,90,9,102,117,108,108,95,112,97,116,104,114, - 177,0,0,0,114,4,0,0,0,114,4,0,0,0,114,5, - 0,0,0,114,12,1,0,0,192,7,0,0,115,68,0,0, - 0,0,3,6,1,19,1,3,1,34,1,13,1,11,1,15, - 1,10,1,9,2,9,1,9,1,15,2,9,1,6,2,12, - 1,18,1,22,1,10,1,15,1,12,1,32,4,12,2,22, - 1,22,1,25,1,16,1,12,1,29,1,6,1,19,1,15, - 1,12,1,4,1,122,20,70,105,108,101,70,105,110,100,101, - 114,46,102,105,110,100,95,115,112,101,99,99,1,0,0,0, - 0,0,0,0,9,0,0,0,13,0,0,0,67,0,0,0, - 115,11,1,0,0,124,0,0,106,0,0,125,1,0,121,31, - 0,116,1,0,106,2,0,124,1,0,112,33,0,116,1,0, - 106,3,0,131,0,0,131,1,0,125,2,0,87,110,33,0, - 4,116,4,0,116,5,0,116,6,0,102,3,0,107,10,0, - 114,75,0,1,1,1,103,0,0,125,2,0,89,110,1,0, - 88,116,7,0,106,8,0,106,9,0,100,1,0,131,1,0, - 115,112,0,116,10,0,124,2,0,131,1,0,124,0,0,95, - 11,0,110,111,0,116,10,0,131,0,0,125,3,0,120,90, - 0,124,2,0,68,93,82,0,125,4,0,124,4,0,106,12, - 0,100,2,0,131,1,0,92,3,0,125,5,0,125,6,0, - 125,7,0,124,6,0,114,191,0,100,3,0,106,13,0,124, - 5,0,124,7,0,106,14,0,131,0,0,131,2,0,125,8, - 0,110,6,0,124,5,0,125,8,0,124,3,0,106,15,0, - 124,8,0,131,1,0,1,113,128,0,87,124,3,0,124,0, - 0,95,11,0,116,7,0,106,8,0,106,9,0,116,16,0, - 131,1,0,114,7,1,100,4,0,100,5,0,132,0,0,124, - 2,0,68,131,1,0,124,0,0,95,17,0,100,6,0,83, - 41,7,122,68,70,105,108,108,32,116,104,101,32,99,97,99, - 104,101,32,111,102,32,112,111,116,101,110,116,105,97,108,32, - 109,111,100,117,108,101,115,32,97,110,100,32,112,97,99,107, - 97,103,101,115,32,102,111,114,32,116,104,105,115,32,100,105, - 114,101,99,116,111,114,121,46,114,0,0,0,0,114,116,0, - 0,0,122,5,123,125,46,123,125,99,1,0,0,0,0,0, - 0,0,2,0,0,0,3,0,0,0,83,0,0,0,115,28, - 0,0,0,104,0,0,124,0,0,93,18,0,125,1,0,124, - 1,0,106,0,0,131,0,0,146,2,0,113,6,0,83,114, - 4,0,0,0,41,1,114,140,0,0,0,41,2,114,22,0, - 0,0,90,2,102,110,114,4,0,0,0,114,4,0,0,0, - 114,5,0,0,0,250,9,60,115,101,116,99,111,109,112,62, - 10,8,0,0,115,2,0,0,0,9,0,122,41,70,105,108, - 101,70,105,110,100,101,114,46,95,102,105,108,108,95,99,97, - 99,104,101,46,60,108,111,99,97,108,115,62,46,60,115,101, - 116,99,111,109,112,62,78,41,18,114,35,0,0,0,114,3, - 0,0,0,90,7,108,105,115,116,100,105,114,114,45,0,0, - 0,114,80,1,0,0,218,15,80,101,114,109,105,115,115,105, - 111,110,69,114,114,111,114,218,18,78,111,116,65,68,105,114, - 101,99,116,111,114,121,69,114,114,111,114,114,7,0,0,0, - 114,8,0,0,0,114,9,0,0,0,114,90,1,0,0,114, - 91,1,0,0,114,134,0,0,0,114,47,0,0,0,114,140, - 0,0,0,218,3,97,100,100,114,10,0,0,0,114,92,1, - 0,0,41,9,114,71,0,0,0,114,35,0,0,0,90,8, - 99,111,110,116,101,110,116,115,90,21,108,111,119,101,114,95, - 115,117,102,102,105,120,95,99,111,110,116,101,110,116,115,114, - 71,1,0,0,114,67,0,0,0,114,65,1,0,0,114,57, - 1,0,0,90,8,110,101,119,95,110,97,109,101,114,4,0, - 0,0,114,4,0,0,0,114,5,0,0,0,114,94,1,0, - 0,237,7,0,0,115,34,0,0,0,0,2,9,1,3,1, - 31,1,22,3,11,3,18,1,18,7,9,1,13,1,24,1, - 6,1,27,2,6,1,17,1,9,1,18,1,122,22,70,105, - 108,101,70,105,110,100,101,114,46,95,102,105,108,108,95,99, - 97,99,104,101,99,1,0,0,0,0,0,0,0,3,0,0, - 0,3,0,0,0,7,0,0,0,115,25,0,0,0,135,0, - 0,135,1,0,102,2,0,100,1,0,100,2,0,134,0,0, - 125,2,0,124,2,0,83,41,3,97,20,1,0,0,65,32, - 99,108,97,115,115,32,109,101,116,104,111,100,32,119,104,105, - 99,104,32,114,101,116,117,114,110,115,32,97,32,99,108,111, - 115,117,114,101,32,116,111,32,117,115,101,32,111,110,32,115, - 121,115,46,112,97,116,104,95,104,111,111,107,10,32,32,32, - 32,32,32,32,32,119,104,105,99,104,32,119,105,108,108,32, - 114,101,116,117,114,110,32,97,110,32,105,110,115,116,97,110, - 99,101,32,117,115,105,110,103,32,116,104,101,32,115,112,101, - 99,105,102,105,101,100,32,108,111,97,100,101,114,115,32,97, - 110,100,32,116,104,101,32,112,97,116,104,10,32,32,32,32, - 32,32,32,32,99,97,108,108,101,100,32,111,110,32,116,104, - 101,32,99,108,111,115,117,114,101,46,10,10,32,32,32,32, - 32,32,32,32,73,102,32,116,104,101,32,112,97,116,104,32, - 99,97,108,108,101,100,32,111,110,32,116,104,101,32,99,108, - 111,115,117,114,101,32,105,115,32,110,111,116,32,97,32,100, - 105,114,101,99,116,111,114,121,44,32,73,109,112,111,114,116, - 69,114,114,111,114,32,105,115,10,32,32,32,32,32,32,32, - 32,114,97,105,115,101,100,46,10,10,32,32,32,32,32,32, - 32,32,99,1,0,0,0,0,0,0,0,1,0,0,0,4, - 0,0,0,19,0,0,0,115,43,0,0,0,116,0,0,124, - 0,0,131,1,0,115,30,0,116,1,0,100,1,0,100,2, - 0,124,0,0,131,1,1,130,1,0,136,0,0,124,0,0, - 136,1,0,140,1,0,83,41,3,122,45,80,97,116,104,32, - 104,111,111,107,32,102,111,114,32,105,109,112,111,114,116,108, - 105,98,46,109,97,99,104,105,110,101,114,121,46,70,105,108, - 101,70,105,110,100,101,114,46,122,30,111,110,108,121,32,100, - 105,114,101,99,116,111,114,105,101,115,32,97,114,101,32,115, - 117,112,112,111,114,116,101,100,114,35,0,0,0,41,2,114, - 46,0,0,0,114,154,0,0,0,41,1,114,35,0,0,0, - 41,2,114,10,1,0,0,114,93,1,0,0,114,4,0,0, - 0,114,5,0,0,0,218,24,112,97,116,104,95,104,111,111, - 107,95,102,111,114,95,70,105,108,101,70,105,110,100,101,114, - 22,8,0,0,115,6,0,0,0,0,2,12,1,18,1,122, - 54,70,105,108,101,70,105,110,100,101,114,46,112,97,116,104, - 95,104,111,111,107,46,60,108,111,99,97,108,115,62,46,112, - 97,116,104,95,104,111,111,107,95,102,111,114,95,70,105,108, - 101,70,105,110,100,101,114,114,4,0,0,0,41,3,114,10, - 1,0,0,114,93,1,0,0,114,99,1,0,0,114,4,0, - 0,0,41,2,114,10,1,0,0,114,93,1,0,0,114,5, - 0,0,0,218,9,112,97,116,104,95,104,111,111,107,12,8, - 0,0,115,4,0,0,0,0,10,21,6,122,20,70,105,108, - 101,70,105,110,100,101,114,46,112,97,116,104,95,104,111,111, - 107,99,1,0,0,0,0,0,0,0,1,0,0,0,2,0, - 0,0,67,0,0,0,115,16,0,0,0,100,1,0,106,0, - 0,124,0,0,106,1,0,131,1,0,83,41,2,78,122,16, - 70,105,108,101,70,105,110,100,101,114,40,123,33,114,125,41, - 41,2,114,47,0,0,0,114,35,0,0,0,41,1,114,71, - 0,0,0,114,4,0,0,0,114,4,0,0,0,114,5,0, - 0,0,114,101,0,0,0,30,8,0,0,115,2,0,0,0, - 0,1,122,19,70,105,108,101,70,105,110,100,101,114,46,95, - 95,114,101,112,114,95,95,41,15,114,57,0,0,0,114,56, - 0,0,0,114,58,0,0,0,114,59,0,0,0,114,72,0, - 0,0,114,74,1,0,0,114,173,0,0,0,114,13,1,0, - 0,114,166,0,0,0,114,86,1,0,0,114,12,1,0,0, - 114,94,1,0,0,114,17,1,0,0,114,100,1,0,0,114, - 101,0,0,0,114,4,0,0,0,114,4,0,0,0,114,4, - 0,0,0,114,5,0,0,0,114,87,1,0,0,146,7,0, - 0,115,20,0,0,0,12,7,6,2,12,14,12,4,6,2, - 12,12,12,5,15,45,12,31,18,18,114,87,1,0,0,99, - 0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0, - 64,0,0,0,115,46,0,0,0,101,0,0,90,1,0,100, - 0,0,90,2,0,100,1,0,90,3,0,100,2,0,100,3, - 0,132,0,0,90,4,0,100,4,0,100,5,0,132,0,0, - 90,5,0,100,6,0,83,41,7,218,18,95,73,109,112,111, - 114,116,76,111,99,107,67,111,110,116,101,120,116,122,36,67, - 111,110,116,101,120,116,32,109,97,110,97,103,101,114,32,102, - 111,114,32,116,104,101,32,105,109,112,111,114,116,32,108,111, - 99,107,46,99,1,0,0,0,0,0,0,0,1,0,0,0, - 1,0,0,0,67,0,0,0,115,14,0,0,0,116,0,0, - 106,1,0,131,0,0,1,100,1,0,83,41,2,122,24,65, - 99,113,117,105,114,101,32,116,104,101,32,105,109,112,111,114, - 116,32,108,111,99,107,46,78,41,2,114,106,0,0,0,114, - 2,1,0,0,41,1,114,71,0,0,0,114,4,0,0,0, - 114,4,0,0,0,114,5,0,0,0,114,75,0,0,0,40, - 8,0,0,115,2,0,0,0,0,2,122,28,95,73,109,112, - 111,114,116,76,111,99,107,67,111,110,116,101,120,116,46,95, - 95,101,110,116,101,114,95,95,99,4,0,0,0,0,0,0, - 0,4,0,0,0,1,0,0,0,67,0,0,0,115,14,0, - 0,0,116,0,0,106,1,0,131,0,0,1,100,1,0,83, - 41,2,122,60,82,101,108,101,97,115,101,32,116,104,101,32, - 105,109,112,111,114,116,32,108,111,99,107,32,114,101,103,97, - 114,100,108,101,115,115,32,111,102,32,97,110,121,32,114,97, - 105,115,101,100,32,101,120,99,101,112,116,105,111,110,115,46, - 78,41,2,114,106,0,0,0,114,107,0,0,0,41,4,114, - 71,0,0,0,90,8,101,120,99,95,116,121,112,101,90,9, - 101,120,99,95,118,97,108,117,101,90,13,101,120,99,95,116, - 114,97,99,101,98,97,99,107,114,4,0,0,0,114,4,0, - 0,0,114,5,0,0,0,114,81,0,0,0,44,8,0,0, - 115,2,0,0,0,0,2,122,27,95,73,109,112,111,114,116, - 76,111,99,107,67,111,110,116,101,120,116,46,95,95,101,120, - 105,116,95,95,78,41,6,114,57,0,0,0,114,56,0,0, - 0,114,58,0,0,0,114,59,0,0,0,114,75,0,0,0, - 114,81,0,0,0,114,4,0,0,0,114,4,0,0,0,114, - 4,0,0,0,114,5,0,0,0,114,101,1,0,0,36,8, - 0,0,115,6,0,0,0,12,2,6,2,12,4,114,101,1, + 101,0,0,0,26,8,0,0,115,2,0,0,0,0,1,122, + 19,70,105,108,101,70,105,110,100,101,114,46,95,95,114,101, + 112,114,95,95,41,15,114,57,0,0,0,114,56,0,0,0, + 114,58,0,0,0,114,59,0,0,0,114,72,0,0,0,114, + 74,1,0,0,114,173,0,0,0,114,13,1,0,0,114,166, + 0,0,0,114,86,1,0,0,114,12,1,0,0,114,94,1, + 0,0,114,17,1,0,0,114,100,1,0,0,114,101,0,0, + 0,114,4,0,0,0,114,4,0,0,0,114,4,0,0,0, + 114,5,0,0,0,114,87,1,0,0,142,7,0,0,115,20, + 0,0,0,12,7,6,2,12,14,12,4,6,2,12,12,12, + 5,15,45,12,31,18,18,114,87,1,0,0,99,0,0,0, + 0,0,0,0,0,0,0,0,0,2,0,0,0,64,0,0, + 0,115,46,0,0,0,101,0,0,90,1,0,100,0,0,90, + 2,0,100,1,0,90,3,0,100,2,0,100,3,0,132,0, + 0,90,4,0,100,4,0,100,5,0,132,0,0,90,5,0, + 100,6,0,83,41,7,218,18,95,73,109,112,111,114,116,76, + 111,99,107,67,111,110,116,101,120,116,122,36,67,111,110,116, + 101,120,116,32,109,97,110,97,103,101,114,32,102,111,114,32, + 116,104,101,32,105,109,112,111,114,116,32,108,111,99,107,46, + 99,1,0,0,0,0,0,0,0,1,0,0,0,1,0,0, + 0,67,0,0,0,115,14,0,0,0,116,0,0,106,1,0, + 131,0,0,1,100,1,0,83,41,2,122,24,65,99,113,117, + 105,114,101,32,116,104,101,32,105,109,112,111,114,116,32,108, + 111,99,107,46,78,41,2,114,106,0,0,0,114,2,1,0, + 0,41,1,114,71,0,0,0,114,4,0,0,0,114,4,0, + 0,0,114,5,0,0,0,114,75,0,0,0,36,8,0,0, + 115,2,0,0,0,0,2,122,28,95,73,109,112,111,114,116, + 76,111,99,107,67,111,110,116,101,120,116,46,95,95,101,110, + 116,101,114,95,95,99,4,0,0,0,0,0,0,0,4,0, + 0,0,1,0,0,0,67,0,0,0,115,14,0,0,0,116, + 0,0,106,1,0,131,0,0,1,100,1,0,83,41,2,122, + 60,82,101,108,101,97,115,101,32,116,104,101,32,105,109,112, + 111,114,116,32,108,111,99,107,32,114,101,103,97,114,100,108, + 101,115,115,32,111,102,32,97,110,121,32,114,97,105,115,101, + 100,32,101,120,99,101,112,116,105,111,110,115,46,78,41,2, + 114,106,0,0,0,114,107,0,0,0,41,4,114,71,0,0, + 0,90,8,101,120,99,95,116,121,112,101,90,9,101,120,99, + 95,118,97,108,117,101,90,13,101,120,99,95,116,114,97,99, + 101,98,97,99,107,114,4,0,0,0,114,4,0,0,0,114, + 5,0,0,0,114,81,0,0,0,40,8,0,0,115,2,0, + 0,0,0,2,122,27,95,73,109,112,111,114,116,76,111,99, + 107,67,111,110,116,101,120,116,46,95,95,101,120,105,116,95, + 95,78,41,6,114,57,0,0,0,114,56,0,0,0,114,58, + 0,0,0,114,59,0,0,0,114,75,0,0,0,114,81,0, + 0,0,114,4,0,0,0,114,4,0,0,0,114,4,0,0, + 0,114,5,0,0,0,114,101,1,0,0,32,8,0,0,115, + 6,0,0,0,12,2,6,2,12,4,114,101,1,0,0,99, + 3,0,0,0,0,0,0,0,5,0,0,0,4,0,0,0, + 67,0,0,0,115,88,0,0,0,124,1,0,106,0,0,100, + 1,0,124,2,0,100,2,0,24,131,2,0,125,3,0,116, + 1,0,124,3,0,131,1,0,124,2,0,107,0,0,114,52, + 0,116,2,0,100,3,0,131,1,0,130,1,0,124,3,0, + 100,4,0,25,125,4,0,124,0,0,114,84,0,100,5,0, + 106,3,0,124,4,0,124,0,0,131,2,0,83,124,4,0, + 83,41,6,122,50,82,101,115,111,108,118,101,32,97,32,114, + 101,108,97,116,105,118,101,32,109,111,100,117,108,101,32,110, + 97,109,101,32,116,111,32,97,110,32,97,98,115,111,108,117, + 116,101,32,111,110,101,46,114,116,0,0,0,114,29,0,0, + 0,122,50,97,116,116,101,109,112,116,101,100,32,114,101,108, + 97,116,105,118,101,32,105,109,112,111,114,116,32,98,101,121, + 111,110,100,32,116,111,112,45,108,101,118,101,108,32,112,97, + 99,107,97,103,101,114,84,0,0,0,122,5,123,125,46,123, + 125,41,4,114,34,0,0,0,114,31,0,0,0,114,133,0, + 0,0,114,47,0,0,0,41,5,114,67,0,0,0,218,7, + 112,97,99,107,97,103,101,218,5,108,101,118,101,108,90,4, + 98,105,116,115,114,128,0,0,0,114,4,0,0,0,114,4, + 0,0,0,114,5,0,0,0,218,13,95,114,101,115,111,108, + 118,101,95,110,97,109,101,45,8,0,0,115,10,0,0,0, + 0,2,22,1,18,1,12,1,10,1,114,104,1,0,0,99, + 3,0,0,0,0,0,0,0,4,0,0,0,3,0,0,0, + 67,0,0,0,115,47,0,0,0,124,0,0,106,0,0,124, + 1,0,124,2,0,131,2,0,125,3,0,124,3,0,100,0, + 0,107,8,0,114,34,0,100,0,0,83,116,1,0,124,1, + 0,124,3,0,131,2,0,83,41,1,78,41,2,114,13,1, + 0,0,114,174,0,0,0,41,4,114,77,1,0,0,114,67, + 0,0,0,114,35,0,0,0,114,170,0,0,0,114,4,0, + 0,0,114,4,0,0,0,114,5,0,0,0,218,17,95,102, + 105,110,100,95,115,112,101,99,95,108,101,103,97,99,121,54, + 8,0,0,115,8,0,0,0,0,3,18,1,12,1,4,1, + 114,105,1,0,0,99,3,0,0,0,0,0,0,0,9,0, + 0,0,26,0,0,0,67,0,0,0,115,41,1,0,0,116, + 0,0,106,1,0,100,1,0,107,9,0,114,41,0,116,0, + 0,106,1,0,12,114,41,0,116,2,0,106,3,0,100,2, + 0,116,4,0,131,2,0,1,124,0,0,116,0,0,106,5, + 0,107,6,0,125,3,0,120,234,0,116,0,0,106,1,0, + 68,93,219,0,125,4,0,116,6,0,131,0,0,143,90,0, + 1,121,13,0,124,4,0,106,7,0,125,5,0,87,110,51, + 0,4,116,8,0,107,10,0,114,148,0,1,1,1,116,9, + 0,124,4,0,124,0,0,124,1,0,131,3,0,125,6,0, + 124,6,0,100,1,0,107,8,0,114,144,0,119,66,0,89, + 110,19,0,88,124,5,0,124,0,0,124,1,0,124,2,0, + 131,3,0,125,6,0,87,100,1,0,81,88,124,6,0,100, + 1,0,107,9,0,114,66,0,124,3,0,12,114,25,1,124, + 0,0,116,0,0,106,5,0,107,6,0,114,25,1,116,0, + 0,106,5,0,124,0,0,25,125,7,0,121,13,0,124,7, + 0,106,10,0,125,8,0,87,110,22,0,4,116,8,0,107, + 10,0,114,1,1,1,1,1,124,6,0,83,89,113,29,1, + 88,124,8,0,100,1,0,107,8,0,114,18,1,124,6,0, + 83,124,8,0,83,113,66,0,124,6,0,83,113,66,0,87, + 100,1,0,83,100,1,0,83,41,3,122,23,70,105,110,100, + 32,97,32,109,111,100,117,108,101,39,115,32,108,111,97,100, + 101,114,46,78,122,22,115,121,115,46,109,101,116,97,95,112, + 97,116,104,32,105,115,32,101,109,112,116,121,41,11,114,7, + 0,0,0,218,9,109,101,116,97,95,112,97,116,104,114,167, + 0,0,0,114,168,0,0,0,114,169,0,0,0,114,73,0, + 0,0,114,101,1,0,0,114,12,1,0,0,114,208,0,0, + 0,114,105,1,0,0,114,207,0,0,0,41,9,114,67,0, + 0,0,114,35,0,0,0,114,11,1,0,0,90,9,105,115, + 95,114,101,108,111,97,100,114,77,1,0,0,114,12,1,0, + 0,114,177,0,0,0,114,178,0,0,0,114,207,0,0,0, + 114,4,0,0,0,114,4,0,0,0,114,5,0,0,0,218, + 10,95,102,105,110,100,95,115,112,101,99,63,8,0,0,115, + 48,0,0,0,0,2,25,1,16,4,15,1,16,1,10,1, + 3,1,13,1,13,1,18,1,12,1,8,2,24,1,12,2, + 22,1,13,1,3,1,13,1,13,4,9,2,12,1,4,2, + 7,2,8,2,114,107,1,0,0,99,3,0,0,0,0,0, + 0,0,4,0,0,0,4,0,0,0,67,0,0,0,115,179, + 0,0,0,116,0,0,124,0,0,116,1,0,131,2,0,115, + 42,0,116,2,0,100,1,0,106,3,0,116,4,0,124,0, + 0,131,1,0,131,1,0,131,1,0,130,1,0,124,2,0, + 100,2,0,107,0,0,114,66,0,116,5,0,100,3,0,131, + 1,0,130,1,0,124,1,0,114,144,0,116,0,0,124,1, + 0,116,1,0,131,2,0,115,102,0,116,2,0,100,4,0, + 131,1,0,130,1,0,110,42,0,124,1,0,116,6,0,106, + 7,0,107,7,0,114,144,0,100,5,0,125,3,0,116,8, + 0,124,3,0,106,3,0,124,1,0,131,1,0,131,1,0, + 130,1,0,124,0,0,12,114,175,0,124,2,0,100,2,0, + 107,2,0,114,175,0,116,5,0,100,6,0,131,1,0,130, + 1,0,100,7,0,83,41,8,122,28,86,101,114,105,102,121, + 32,97,114,103,117,109,101,110,116,115,32,97,114,101,32,34, + 115,97,110,101,34,46,122,31,109,111,100,117,108,101,32,110, + 97,109,101,32,109,117,115,116,32,98,101,32,115,116,114,44, + 32,110,111,116,32,123,125,114,84,0,0,0,122,18,108,101, + 118,101,108,32,109,117,115,116,32,98,101,32,62,61,32,48, + 122,31,95,95,112,97,99,107,97,103,101,95,95,32,110,111, + 116,32,115,101,116,32,116,111,32,97,32,115,116,114,105,110, + 103,122,61,80,97,114,101,110,116,32,109,111,100,117,108,101, + 32,123,33,114,125,32,110,111,116,32,108,111,97,100,101,100, + 44,32,99,97,110,110,111,116,32,112,101,114,102,111,114,109, + 32,114,101,108,97,116,105,118,101,32,105,109,112,111,114,116, + 122,17,69,109,112,116,121,32,109,111,100,117,108,101,32,110, + 97,109,101,78,41,9,114,191,0,0,0,114,83,1,0,0, + 218,9,84,121,112,101,69,114,114,111,114,114,47,0,0,0, + 114,66,0,0,0,114,133,0,0,0,114,7,0,0,0,114, + 73,0,0,0,218,11,83,121,115,116,101,109,69,114,114,111, + 114,41,4,114,67,0,0,0,114,102,1,0,0,114,103,1, + 0,0,114,172,0,0,0,114,4,0,0,0,114,4,0,0, + 0,114,5,0,0,0,218,13,95,115,97,110,105,116,121,95, + 99,104,101,99,107,103,8,0,0,115,24,0,0,0,0,2, + 15,1,27,1,12,1,12,1,6,1,15,1,15,1,15,1, + 6,2,21,1,19,1,114,110,1,0,0,122,16,78,111,32, + 109,111,100,117,108,101,32,110,97,109,101,100,32,122,4,123, + 33,114,125,99,2,0,0,0,0,0,0,0,8,0,0,0, + 12,0,0,0,67,0,0,0,115,40,1,0,0,100,0,0, + 125,2,0,124,0,0,106,0,0,100,1,0,131,1,0,100, + 2,0,25,125,3,0,124,3,0,114,175,0,124,3,0,116, + 1,0,106,2,0,107,7,0,114,59,0,116,3,0,124,1, + 0,124,3,0,131,2,0,1,124,0,0,116,1,0,106,2, + 0,107,6,0,114,85,0,116,1,0,106,2,0,124,0,0, + 25,83,116,1,0,106,2,0,124,3,0,25,125,4,0,121, + 13,0,124,4,0,106,4,0,125,2,0,87,110,61,0,4, + 116,5,0,107,10,0,114,174,0,1,1,1,116,6,0,100, + 3,0,23,106,7,0,124,0,0,124,3,0,131,2,0,125, + 5,0,116,8,0,124,5,0,100,4,0,124,0,0,131,1, + 1,100,0,0,130,2,0,89,110,1,0,88,116,9,0,124, + 0,0,124,2,0,131,2,0,125,6,0,124,6,0,100,0, + 0,107,8,0,114,232,0,116,8,0,116,6,0,106,7,0, + 124,0,0,131,1,0,100,4,0,124,0,0,131,1,1,130, + 1,0,110,12,0,116,10,0,124,6,0,131,1,0,125,7, + 0,124,3,0,114,36,1,116,1,0,106,2,0,124,3,0, + 25,125,4,0,116,11,0,124,4,0,124,0,0,106,0,0, + 100,1,0,131,1,0,100,5,0,25,124,7,0,131,3,0, + 1,124,7,0,83,41,6,78,114,116,0,0,0,114,84,0, + 0,0,122,23,59,32,123,33,114,125,32,105,115,32,110,111, + 116,32,97,32,112,97,99,107,97,103,101,114,67,0,0,0, + 114,115,0,0,0,41,12,114,32,0,0,0,114,7,0,0, + 0,114,73,0,0,0,114,114,0,0,0,114,246,0,0,0, + 114,208,0,0,0,218,8,95,69,82,82,95,77,83,71,114, + 47,0,0,0,114,154,0,0,0,114,107,1,0,0,114,5, + 1,0,0,114,61,0,0,0,41,8,114,67,0,0,0,218, + 7,105,109,112,111,114,116,95,114,35,0,0,0,114,233,0, + 0,0,90,13,112,97,114,101,110,116,95,109,111,100,117,108, + 101,114,172,0,0,0,114,177,0,0,0,114,178,0,0,0, + 114,4,0,0,0,114,4,0,0,0,114,5,0,0,0,218, + 23,95,102,105,110,100,95,97,110,100,95,108,111,97,100,95, + 117,110,108,111,99,107,101,100,123,8,0,0,115,42,0,0, + 0,0,1,6,1,19,1,6,1,15,1,13,2,15,1,11, + 1,13,1,3,1,13,1,13,1,22,1,26,1,15,1,12, + 1,30,2,12,1,6,2,13,1,29,1,114,113,1,0,0, + 99,2,0,0,0,0,0,0,0,2,0,0,0,10,0,0, + 0,67,0,0,0,115,36,0,0,0,116,0,0,124,0,0, + 131,1,0,143,18,0,1,116,1,0,124,0,0,124,1,0, + 131,2,0,83,87,100,1,0,81,88,100,1,0,83,41,2, + 122,54,70,105,110,100,32,97,110,100,32,108,111,97,100,32, + 116,104,101,32,109,111,100,117,108,101,44,32,97,110,100,32, + 114,101,108,101,97,115,101,32,116,104,101,32,105,109,112,111, + 114,116,32,108,111,99,107,46,78,41,2,114,103,0,0,0, + 114,113,1,0,0,41,2,114,67,0,0,0,114,112,1,0, + 0,114,4,0,0,0,114,4,0,0,0,114,5,0,0,0, + 218,14,95,102,105,110,100,95,97,110,100,95,108,111,97,100, + 150,8,0,0,115,4,0,0,0,0,2,13,1,114,114,1, 0,0,99,3,0,0,0,0,0,0,0,5,0,0,0,4, - 0,0,0,67,0,0,0,115,88,0,0,0,124,1,0,106, - 0,0,100,1,0,124,2,0,100,2,0,24,131,2,0,125, - 3,0,116,1,0,124,3,0,131,1,0,124,2,0,107,0, - 0,114,52,0,116,2,0,100,3,0,131,1,0,130,1,0, - 124,3,0,100,4,0,25,125,4,0,124,0,0,114,84,0, - 100,5,0,106,3,0,124,4,0,124,0,0,131,2,0,83, - 124,4,0,83,41,6,122,50,82,101,115,111,108,118,101,32, - 97,32,114,101,108,97,116,105,118,101,32,109,111,100,117,108, - 101,32,110,97,109,101,32,116,111,32,97,110,32,97,98,115, - 111,108,117,116,101,32,111,110,101,46,114,116,0,0,0,114, - 29,0,0,0,122,50,97,116,116,101,109,112,116,101,100,32, - 114,101,108,97,116,105,118,101,32,105,109,112,111,114,116,32, - 98,101,121,111,110,100,32,116,111,112,45,108,101,118,101,108, - 32,112,97,99,107,97,103,101,114,84,0,0,0,122,5,123, - 125,46,123,125,41,4,114,34,0,0,0,114,31,0,0,0, - 114,133,0,0,0,114,47,0,0,0,41,5,114,67,0,0, - 0,218,7,112,97,99,107,97,103,101,218,5,108,101,118,101, - 108,90,4,98,105,116,115,114,128,0,0,0,114,4,0,0, - 0,114,4,0,0,0,114,5,0,0,0,218,13,95,114,101, - 115,111,108,118,101,95,110,97,109,101,49,8,0,0,115,10, - 0,0,0,0,2,22,1,18,1,12,1,10,1,114,104,1, - 0,0,99,3,0,0,0,0,0,0,0,4,0,0,0,3, - 0,0,0,67,0,0,0,115,47,0,0,0,124,0,0,106, - 0,0,124,1,0,124,2,0,131,2,0,125,3,0,124,3, - 0,100,0,0,107,8,0,114,34,0,100,0,0,83,116,1, - 0,124,1,0,124,3,0,131,2,0,83,41,1,78,41,2, - 114,13,1,0,0,114,174,0,0,0,41,4,114,77,1,0, - 0,114,67,0,0,0,114,35,0,0,0,114,170,0,0,0, + 0,0,0,67,0,0,0,115,166,0,0,0,116,0,0,124, + 0,0,124,1,0,124,2,0,131,3,0,1,124,2,0,100, + 1,0,107,4,0,114,46,0,116,1,0,124,0,0,124,1, + 0,124,2,0,131,3,0,125,0,0,116,2,0,106,3,0, + 131,0,0,1,124,0,0,116,4,0,106,5,0,107,7,0, + 114,84,0,116,6,0,124,0,0,116,7,0,131,2,0,83, + 116,4,0,106,5,0,124,0,0,25,125,3,0,124,3,0, + 100,2,0,107,8,0,114,152,0,116,2,0,106,8,0,131, + 0,0,1,100,3,0,106,9,0,124,0,0,131,1,0,125, + 4,0,116,10,0,124,4,0,100,4,0,124,0,0,131,1, + 1,130,1,0,116,11,0,124,0,0,131,1,0,1,124,3, + 0,83,41,5,97,50,1,0,0,73,109,112,111,114,116,32, + 97,110,100,32,114,101,116,117,114,110,32,116,104,101,32,109, + 111,100,117,108,101,32,98,97,115,101,100,32,111,110,32,105, + 116,115,32,110,97,109,101,44,32,116,104,101,32,112,97,99, + 107,97,103,101,32,116,104,101,32,99,97,108,108,32,105,115, + 10,32,32,32,32,98,101,105,110,103,32,109,97,100,101,32, + 102,114,111,109,44,32,97,110,100,32,116,104,101,32,108,101, + 118,101,108,32,97,100,106,117,115,116,109,101,110,116,46,10, + 10,32,32,32,32,84,104,105,115,32,102,117,110,99,116,105, + 111,110,32,114,101,112,114,101,115,101,110,116,115,32,116,104, + 101,32,103,114,101,97,116,101,115,116,32,99,111,109,109,111, + 110,32,100,101,110,111,109,105,110,97,116,111,114,32,111,102, + 32,102,117,110,99,116,105,111,110,97,108,105,116,121,10,32, + 32,32,32,98,101,116,119,101,101,110,32,105,109,112,111,114, + 116,95,109,111,100,117,108,101,32,97,110,100,32,95,95,105, + 109,112,111,114,116,95,95,46,32,84,104,105,115,32,105,110, + 99,108,117,100,101,115,32,115,101,116,116,105,110,103,32,95, + 95,112,97,99,107,97,103,101,95,95,32,105,102,10,32,32, + 32,32,116,104,101,32,108,111,97,100,101,114,32,100,105,100, + 32,110,111,116,46,10,10,32,32,32,32,114,84,0,0,0, + 78,122,40,105,109,112,111,114,116,32,111,102,32,123,125,32, + 104,97,108,116,101,100,59,32,78,111,110,101,32,105,110,32, + 115,121,115,46,109,111,100,117,108,101,115,114,67,0,0,0, + 41,12,114,110,1,0,0,114,104,1,0,0,114,106,0,0, + 0,114,2,1,0,0,114,7,0,0,0,114,73,0,0,0, + 114,114,1,0,0,218,11,95,103,99,100,95,105,109,112,111, + 114,116,114,107,0,0,0,114,47,0,0,0,114,154,0,0, + 0,114,112,0,0,0,41,5,114,67,0,0,0,114,102,1, + 0,0,114,103,1,0,0,114,178,0,0,0,114,152,0,0, + 0,114,4,0,0,0,114,4,0,0,0,114,5,0,0,0, + 114,115,1,0,0,156,8,0,0,115,28,0,0,0,0,9, + 16,1,12,1,18,1,10,1,15,1,13,1,13,1,12,1, + 10,1,6,1,9,1,18,1,10,1,114,115,1,0,0,99, + 3,0,0,0,0,0,0,0,6,0,0,0,17,0,0,0, + 67,0,0,0,115,239,0,0,0,116,0,0,124,0,0,100, + 1,0,131,2,0,114,235,0,100,2,0,124,1,0,107,6, + 0,114,83,0,116,1,0,124,1,0,131,1,0,125,1,0, + 124,1,0,106,2,0,100,2,0,131,1,0,1,116,0,0, + 124,0,0,100,3,0,131,2,0,114,83,0,124,1,0,106, + 3,0,124,0,0,106,4,0,131,1,0,1,120,149,0,124, + 1,0,68,93,141,0,125,3,0,116,0,0,124,0,0,124, + 3,0,131,2,0,115,90,0,100,4,0,106,5,0,124,0, + 0,106,6,0,124,3,0,131,2,0,125,4,0,121,17,0, + 116,7,0,124,2,0,124,4,0,131,2,0,1,87,113,90, + 0,4,116,8,0,107,10,0,114,230,0,1,125,5,0,1, + 122,47,0,116,9,0,124,5,0,131,1,0,106,10,0,116, + 11,0,131,1,0,114,209,0,124,5,0,106,12,0,124,4, + 0,107,2,0,114,209,0,119,90,0,130,0,0,87,89,100, + 5,0,100,5,0,125,5,0,126,5,0,88,113,90,0,88, + 113,90,0,87,124,0,0,83,41,6,122,238,70,105,103,117, + 114,101,32,111,117,116,32,119,104,97,116,32,95,95,105,109, + 112,111,114,116,95,95,32,115,104,111,117,108,100,32,114,101, + 116,117,114,110,46,10,10,32,32,32,32,84,104,101,32,105, + 109,112,111,114,116,95,32,112,97,114,97,109,101,116,101,114, + 32,105,115,32,97,32,99,97,108,108,97,98,108,101,32,119, + 104,105,99,104,32,116,97,107,101,115,32,116,104,101,32,110, + 97,109,101,32,111,102,32,109,111,100,117,108,101,32,116,111, + 10,32,32,32,32,105,109,112,111,114,116,46,32,73,116,32, + 105,115,32,114,101,113,117,105,114,101,100,32,116,111,32,100, + 101,99,111,117,112,108,101,32,116,104,101,32,102,117,110,99, + 116,105,111,110,32,102,114,111,109,32,97,115,115,117,109,105, + 110,103,32,105,109,112,111,114,116,108,105,98,39,115,10,32, + 32,32,32,105,109,112,111,114,116,32,105,109,112,108,101,109, + 101,110,116,97,116,105,111,110,32,105,115,32,100,101,115,105, + 114,101,100,46,10,10,32,32,32,32,114,246,0,0,0,250, + 1,42,218,7,95,95,97,108,108,95,95,122,5,123,125,46, + 123,125,78,41,13,114,60,0,0,0,114,245,0,0,0,218, + 6,114,101,109,111,118,101,114,196,0,0,0,114,117,1,0, + 0,114,47,0,0,0,114,57,0,0,0,114,114,0,0,0, + 114,154,0,0,0,114,83,1,0,0,114,9,0,0,0,218, + 15,95,69,82,82,95,77,83,71,95,80,82,69,70,73,88, + 114,67,0,0,0,41,6,114,178,0,0,0,218,8,102,114, + 111,109,108,105,115,116,114,112,1,0,0,114,16,0,0,0, + 90,9,102,114,111,109,95,110,97,109,101,114,40,1,0,0, 114,4,0,0,0,114,4,0,0,0,114,5,0,0,0,218, - 17,95,102,105,110,100,95,115,112,101,99,95,108,101,103,97, - 99,121,58,8,0,0,115,8,0,0,0,0,3,18,1,12, - 1,4,1,114,105,1,0,0,99,3,0,0,0,0,0,0, - 0,9,0,0,0,26,0,0,0,67,0,0,0,115,41,1, - 0,0,116,0,0,106,1,0,100,1,0,107,9,0,114,41, - 0,116,0,0,106,1,0,12,114,41,0,116,2,0,106,3, - 0,100,2,0,116,4,0,131,2,0,1,124,0,0,116,0, - 0,106,5,0,107,6,0,125,3,0,120,234,0,116,0,0, - 106,1,0,68,93,219,0,125,4,0,116,6,0,131,0,0, - 143,90,0,1,121,13,0,124,4,0,106,7,0,125,5,0, - 87,110,51,0,4,116,8,0,107,10,0,114,148,0,1,1, - 1,116,9,0,124,4,0,124,0,0,124,1,0,131,3,0, - 125,6,0,124,6,0,100,1,0,107,8,0,114,144,0,119, - 66,0,89,110,19,0,88,124,5,0,124,0,0,124,1,0, - 124,2,0,131,3,0,125,6,0,87,100,1,0,81,88,124, - 6,0,100,1,0,107,9,0,114,66,0,124,3,0,12,114, - 25,1,124,0,0,116,0,0,106,5,0,107,6,0,114,25, - 1,116,0,0,106,5,0,124,0,0,25,125,7,0,121,13, - 0,124,7,0,106,10,0,125,8,0,87,110,22,0,4,116, - 8,0,107,10,0,114,1,1,1,1,1,124,6,0,83,89, - 113,29,1,88,124,8,0,100,1,0,107,8,0,114,18,1, - 124,6,0,83,124,8,0,83,113,66,0,124,6,0,83,113, - 66,0,87,100,1,0,83,100,1,0,83,41,3,122,23,70, - 105,110,100,32,97,32,109,111,100,117,108,101,39,115,32,108, - 111,97,100,101,114,46,78,122,22,115,121,115,46,109,101,116, - 97,95,112,97,116,104,32,105,115,32,101,109,112,116,121,41, - 11,114,7,0,0,0,218,9,109,101,116,97,95,112,97,116, - 104,114,167,0,0,0,114,168,0,0,0,114,169,0,0,0, - 114,73,0,0,0,114,101,1,0,0,114,12,1,0,0,114, - 208,0,0,0,114,105,1,0,0,114,207,0,0,0,41,9, - 114,67,0,0,0,114,35,0,0,0,114,11,1,0,0,90, - 9,105,115,95,114,101,108,111,97,100,114,77,1,0,0,114, - 12,1,0,0,114,177,0,0,0,114,178,0,0,0,114,207, - 0,0,0,114,4,0,0,0,114,4,0,0,0,114,5,0, - 0,0,218,10,95,102,105,110,100,95,115,112,101,99,67,8, - 0,0,115,48,0,0,0,0,2,25,1,16,4,15,1,16, - 1,10,1,3,1,13,1,13,1,18,1,12,1,8,2,24, - 1,12,2,22,1,13,1,3,1,13,1,13,4,9,2,12, - 1,4,2,7,2,8,2,114,107,1,0,0,99,3,0,0, - 0,0,0,0,0,4,0,0,0,4,0,0,0,67,0,0, - 0,115,179,0,0,0,116,0,0,124,0,0,116,1,0,131, - 2,0,115,42,0,116,2,0,100,1,0,106,3,0,116,4, - 0,124,0,0,131,1,0,131,1,0,131,1,0,130,1,0, - 124,2,0,100,2,0,107,0,0,114,66,0,116,5,0,100, - 3,0,131,1,0,130,1,0,124,1,0,114,144,0,116,0, - 0,124,1,0,116,1,0,131,2,0,115,102,0,116,2,0, - 100,4,0,131,1,0,130,1,0,110,42,0,124,1,0,116, - 6,0,106,7,0,107,7,0,114,144,0,100,5,0,125,3, - 0,116,8,0,124,3,0,106,3,0,124,1,0,131,1,0, - 131,1,0,130,1,0,124,0,0,12,114,175,0,124,2,0, - 100,2,0,107,2,0,114,175,0,116,5,0,100,6,0,131, - 1,0,130,1,0,100,7,0,83,41,8,122,28,86,101,114, - 105,102,121,32,97,114,103,117,109,101,110,116,115,32,97,114, - 101,32,34,115,97,110,101,34,46,122,31,109,111,100,117,108, - 101,32,110,97,109,101,32,109,117,115,116,32,98,101,32,115, - 116,114,44,32,110,111,116,32,123,125,114,84,0,0,0,122, - 18,108,101,118,101,108,32,109,117,115,116,32,98,101,32,62, - 61,32,48,122,31,95,95,112,97,99,107,97,103,101,95,95, - 32,110,111,116,32,115,101,116,32,116,111,32,97,32,115,116, - 114,105,110,103,122,61,80,97,114,101,110,116,32,109,111,100, - 117,108,101,32,123,33,114,125,32,110,111,116,32,108,111,97, - 100,101,100,44,32,99,97,110,110,111,116,32,112,101,114,102, - 111,114,109,32,114,101,108,97,116,105,118,101,32,105,109,112, - 111,114,116,122,17,69,109,112,116,121,32,109,111,100,117,108, - 101,32,110,97,109,101,78,41,9,114,191,0,0,0,114,83, - 1,0,0,218,9,84,121,112,101,69,114,114,111,114,114,47, - 0,0,0,114,66,0,0,0,114,133,0,0,0,114,7,0, - 0,0,114,73,0,0,0,218,11,83,121,115,116,101,109,69, - 114,114,111,114,41,4,114,67,0,0,0,114,102,1,0,0, - 114,103,1,0,0,114,172,0,0,0,114,4,0,0,0,114, - 4,0,0,0,114,5,0,0,0,218,13,95,115,97,110,105, - 116,121,95,99,104,101,99,107,107,8,0,0,115,24,0,0, - 0,0,2,15,1,27,1,12,1,12,1,6,1,15,1,15, - 1,15,1,6,2,21,1,19,1,114,110,1,0,0,122,16, - 78,111,32,109,111,100,117,108,101,32,110,97,109,101,100,32, - 122,4,123,33,114,125,99,2,0,0,0,0,0,0,0,8, - 0,0,0,12,0,0,0,67,0,0,0,115,40,1,0,0, - 100,0,0,125,2,0,124,0,0,106,0,0,100,1,0,131, - 1,0,100,2,0,25,125,3,0,124,3,0,114,175,0,124, - 3,0,116,1,0,106,2,0,107,7,0,114,59,0,116,3, - 0,124,1,0,124,3,0,131,2,0,1,124,0,0,116,1, - 0,106,2,0,107,6,0,114,85,0,116,1,0,106,2,0, - 124,0,0,25,83,116,1,0,106,2,0,124,3,0,25,125, - 4,0,121,13,0,124,4,0,106,4,0,125,2,0,87,110, - 61,0,4,116,5,0,107,10,0,114,174,0,1,1,1,116, - 6,0,100,3,0,23,106,7,0,124,0,0,124,3,0,131, - 2,0,125,5,0,116,8,0,124,5,0,100,4,0,124,0, - 0,131,1,1,100,0,0,130,2,0,89,110,1,0,88,116, - 9,0,124,0,0,124,2,0,131,2,0,125,6,0,124,6, - 0,100,0,0,107,8,0,114,232,0,116,8,0,116,6,0, - 106,7,0,124,0,0,131,1,0,100,4,0,124,0,0,131, - 1,1,130,1,0,110,12,0,116,10,0,124,6,0,131,1, - 0,125,7,0,124,3,0,114,36,1,116,1,0,106,2,0, - 124,3,0,25,125,4,0,116,11,0,124,4,0,124,0,0, - 106,0,0,100,1,0,131,1,0,100,5,0,25,124,7,0, - 131,3,0,1,124,7,0,83,41,6,78,114,116,0,0,0, - 114,84,0,0,0,122,23,59,32,123,33,114,125,32,105,115, - 32,110,111,116,32,97,32,112,97,99,107,97,103,101,114,67, - 0,0,0,114,115,0,0,0,41,12,114,32,0,0,0,114, - 7,0,0,0,114,73,0,0,0,114,114,0,0,0,114,246, - 0,0,0,114,208,0,0,0,218,8,95,69,82,82,95,77, - 83,71,114,47,0,0,0,114,154,0,0,0,114,107,1,0, - 0,114,5,1,0,0,114,61,0,0,0,41,8,114,67,0, - 0,0,218,7,105,109,112,111,114,116,95,114,35,0,0,0, - 114,233,0,0,0,90,13,112,97,114,101,110,116,95,109,111, - 100,117,108,101,114,172,0,0,0,114,177,0,0,0,114,178, - 0,0,0,114,4,0,0,0,114,4,0,0,0,114,5,0, - 0,0,218,23,95,102,105,110,100,95,97,110,100,95,108,111, - 97,100,95,117,110,108,111,99,107,101,100,127,8,0,0,115, - 42,0,0,0,0,1,6,1,19,1,6,1,15,1,13,2, - 15,1,11,1,13,1,3,1,13,1,13,1,22,1,26,1, - 15,1,12,1,30,2,12,1,6,2,13,1,29,1,114,113, - 1,0,0,99,2,0,0,0,0,0,0,0,2,0,0,0, - 10,0,0,0,67,0,0,0,115,36,0,0,0,116,0,0, - 124,0,0,131,1,0,143,18,0,1,116,1,0,124,0,0, - 124,1,0,131,2,0,83,87,100,1,0,81,88,100,1,0, - 83,41,2,122,54,70,105,110,100,32,97,110,100,32,108,111, - 97,100,32,116,104,101,32,109,111,100,117,108,101,44,32,97, - 110,100,32,114,101,108,101,97,115,101,32,116,104,101,32,105, - 109,112,111,114,116,32,108,111,99,107,46,78,41,2,114,103, - 0,0,0,114,113,1,0,0,41,2,114,67,0,0,0,114, - 112,1,0,0,114,4,0,0,0,114,4,0,0,0,114,5, - 0,0,0,218,14,95,102,105,110,100,95,97,110,100,95,108, - 111,97,100,154,8,0,0,115,4,0,0,0,0,2,13,1, - 114,114,1,0,0,99,3,0,0,0,0,0,0,0,5,0, - 0,0,4,0,0,0,67,0,0,0,115,166,0,0,0,116, - 0,0,124,0,0,124,1,0,124,2,0,131,3,0,1,124, - 2,0,100,1,0,107,4,0,114,46,0,116,1,0,124,0, - 0,124,1,0,124,2,0,131,3,0,125,0,0,116,2,0, - 106,3,0,131,0,0,1,124,0,0,116,4,0,106,5,0, - 107,7,0,114,84,0,116,6,0,124,0,0,116,7,0,131, - 2,0,83,116,4,0,106,5,0,124,0,0,25,125,3,0, - 124,3,0,100,2,0,107,8,0,114,152,0,116,2,0,106, - 8,0,131,0,0,1,100,3,0,106,9,0,124,0,0,131, - 1,0,125,4,0,116,10,0,124,4,0,100,4,0,124,0, - 0,131,1,1,130,1,0,116,11,0,124,0,0,131,1,0, - 1,124,3,0,83,41,5,97,50,1,0,0,73,109,112,111, - 114,116,32,97,110,100,32,114,101,116,117,114,110,32,116,104, - 101,32,109,111,100,117,108,101,32,98,97,115,101,100,32,111, - 110,32,105,116,115,32,110,97,109,101,44,32,116,104,101,32, - 112,97,99,107,97,103,101,32,116,104,101,32,99,97,108,108, - 32,105,115,10,32,32,32,32,98,101,105,110,103,32,109,97, - 100,101,32,102,114,111,109,44,32,97,110,100,32,116,104,101, - 32,108,101,118,101,108,32,97,100,106,117,115,116,109,101,110, - 116,46,10,10,32,32,32,32,84,104,105,115,32,102,117,110, - 99,116,105,111,110,32,114,101,112,114,101,115,101,110,116,115, - 32,116,104,101,32,103,114,101,97,116,101,115,116,32,99,111, - 109,109,111,110,32,100,101,110,111,109,105,110,97,116,111,114, - 32,111,102,32,102,117,110,99,116,105,111,110,97,108,105,116, - 121,10,32,32,32,32,98,101,116,119,101,101,110,32,105,109, - 112,111,114,116,95,109,111,100,117,108,101,32,97,110,100,32, - 95,95,105,109,112,111,114,116,95,95,46,32,84,104,105,115, - 32,105,110,99,108,117,100,101,115,32,115,101,116,116,105,110, - 103,32,95,95,112,97,99,107,97,103,101,95,95,32,105,102, - 10,32,32,32,32,116,104,101,32,108,111,97,100,101,114,32, - 100,105,100,32,110,111,116,46,10,10,32,32,32,32,114,84, - 0,0,0,78,122,40,105,109,112,111,114,116,32,111,102,32, - 123,125,32,104,97,108,116,101,100,59,32,78,111,110,101,32, - 105,110,32,115,121,115,46,109,111,100,117,108,101,115,114,67, - 0,0,0,41,12,114,110,1,0,0,114,104,1,0,0,114, - 106,0,0,0,114,2,1,0,0,114,7,0,0,0,114,73, - 0,0,0,114,114,1,0,0,218,11,95,103,99,100,95,105, - 109,112,111,114,116,114,107,0,0,0,114,47,0,0,0,114, - 154,0,0,0,114,112,0,0,0,41,5,114,67,0,0,0, - 114,102,1,0,0,114,103,1,0,0,114,178,0,0,0,114, - 152,0,0,0,114,4,0,0,0,114,4,0,0,0,114,5, - 0,0,0,114,115,1,0,0,160,8,0,0,115,28,0,0, - 0,0,9,16,1,12,1,18,1,10,1,15,1,13,1,13, - 1,12,1,10,1,6,1,9,1,18,1,10,1,114,115,1, - 0,0,99,3,0,0,0,0,0,0,0,6,0,0,0,17, - 0,0,0,67,0,0,0,115,239,0,0,0,116,0,0,124, - 0,0,100,1,0,131,2,0,114,235,0,100,2,0,124,1, - 0,107,6,0,114,83,0,116,1,0,124,1,0,131,1,0, - 125,1,0,124,1,0,106,2,0,100,2,0,131,1,0,1, - 116,0,0,124,0,0,100,3,0,131,2,0,114,83,0,124, - 1,0,106,3,0,124,0,0,106,4,0,131,1,0,1,120, - 149,0,124,1,0,68,93,141,0,125,3,0,116,0,0,124, - 0,0,124,3,0,131,2,0,115,90,0,100,4,0,106,5, - 0,124,0,0,106,6,0,124,3,0,131,2,0,125,4,0, - 121,17,0,116,7,0,124,2,0,124,4,0,131,2,0,1, - 87,113,90,0,4,116,8,0,107,10,0,114,230,0,1,125, - 5,0,1,122,47,0,116,9,0,124,5,0,131,1,0,106, - 10,0,116,11,0,131,1,0,114,209,0,124,5,0,106,12, - 0,124,4,0,107,2,0,114,209,0,119,90,0,130,0,0, - 87,89,100,5,0,100,5,0,125,5,0,126,5,0,88,113, - 90,0,88,113,90,0,87,124,0,0,83,41,6,122,238,70, - 105,103,117,114,101,32,111,117,116,32,119,104,97,116,32,95, - 95,105,109,112,111,114,116,95,95,32,115,104,111,117,108,100, - 32,114,101,116,117,114,110,46,10,10,32,32,32,32,84,104, - 101,32,105,109,112,111,114,116,95,32,112,97,114,97,109,101, - 116,101,114,32,105,115,32,97,32,99,97,108,108,97,98,108, - 101,32,119,104,105,99,104,32,116,97,107,101,115,32,116,104, - 101,32,110,97,109,101,32,111,102,32,109,111,100,117,108,101, - 32,116,111,10,32,32,32,32,105,109,112,111,114,116,46,32, - 73,116,32,105,115,32,114,101,113,117,105,114,101,100,32,116, - 111,32,100,101,99,111,117,112,108,101,32,116,104,101,32,102, - 117,110,99,116,105,111,110,32,102,114,111,109,32,97,115,115, - 117,109,105,110,103,32,105,109,112,111,114,116,108,105,98,39, - 115,10,32,32,32,32,105,109,112,111,114,116,32,105,109,112, - 108,101,109,101,110,116,97,116,105,111,110,32,105,115,32,100, - 101,115,105,114,101,100,46,10,10,32,32,32,32,114,246,0, - 0,0,250,1,42,218,7,95,95,97,108,108,95,95,122,5, - 123,125,46,123,125,78,41,13,114,60,0,0,0,114,245,0, - 0,0,218,6,114,101,109,111,118,101,114,196,0,0,0,114, - 117,1,0,0,114,47,0,0,0,114,57,0,0,0,114,114, - 0,0,0,114,154,0,0,0,114,83,1,0,0,114,9,0, - 0,0,218,15,95,69,82,82,95,77,83,71,95,80,82,69, - 70,73,88,114,67,0,0,0,41,6,114,178,0,0,0,218, - 8,102,114,111,109,108,105,115,116,114,112,1,0,0,114,16, - 0,0,0,90,9,102,114,111,109,95,110,97,109,101,114,40, - 1,0,0,114,4,0,0,0,114,4,0,0,0,114,5,0, - 0,0,218,16,95,104,97,110,100,108,101,95,102,114,111,109, - 108,105,115,116,184,8,0,0,115,34,0,0,0,0,10,15, - 1,12,1,12,1,13,1,15,1,16,1,13,1,15,1,21, - 1,3,1,17,1,18,4,21,1,15,1,3,1,26,1,114, - 121,1,0,0,99,1,0,0,0,0,0,0,0,2,0,0, - 0,2,0,0,0,67,0,0,0,115,72,0,0,0,124,0, - 0,106,0,0,100,1,0,131,1,0,125,1,0,124,1,0, - 100,2,0,107,8,0,114,68,0,124,0,0,100,3,0,25, - 125,1,0,100,4,0,124,0,0,107,7,0,114,68,0,124, - 1,0,106,1,0,100,5,0,131,1,0,100,6,0,25,125, - 1,0,124,1,0,83,41,7,122,167,67,97,108,99,117,108, - 97,116,101,32,119,104,97,116,32,95,95,112,97,99,107,97, - 103,101,95,95,32,115,104,111,117,108,100,32,98,101,46,10, - 10,32,32,32,32,95,95,112,97,99,107,97,103,101,95,95, - 32,105,115,32,110,111,116,32,103,117,97,114,97,110,116,101, - 101,100,32,116,111,32,98,101,32,100,101,102,105,110,101,100, - 32,111,114,32,99,111,117,108,100,32,98,101,32,115,101,116, - 32,116,111,32,78,111,110,101,10,32,32,32,32,116,111,32, - 114,101,112,114,101,115,101,110,116,32,116,104,97,116,32,105, - 116,115,32,112,114,111,112,101,114,32,118,97,108,117,101,32, - 105,115,32,117,110,107,110,111,119,110,46,10,10,32,32,32, - 32,114,249,0,0,0,78,114,57,0,0,0,114,246,0,0, - 0,114,116,0,0,0,114,84,0,0,0,41,2,114,93,0, - 0,0,114,32,0,0,0,41,2,218,7,103,108,111,98,97, - 108,115,114,102,1,0,0,114,4,0,0,0,114,4,0,0, - 0,114,5,0,0,0,218,17,95,99,97,108,99,95,95,95, - 112,97,99,107,97,103,101,95,95,216,8,0,0,115,12,0, - 0,0,0,7,15,1,12,1,10,1,12,1,19,1,114,123, - 1,0,0,99,0,0,0,0,0,0,0,0,3,0,0,0, - 3,0,0,0,67,0,0,0,115,55,0,0,0,116,0,0, - 116,1,0,106,2,0,131,0,0,102,2,0,125,0,0,116, - 3,0,116,4,0,102,2,0,125,1,0,116,5,0,116,6, - 0,102,2,0,125,2,0,124,0,0,124,1,0,124,2,0, - 103,3,0,83,41,1,122,95,82,101,116,117,114,110,115,32, - 97,32,108,105,115,116,32,111,102,32,102,105,108,101,45,98, - 97,115,101,100,32,109,111,100,117,108,101,32,108,111,97,100, - 101,114,115,46,10,10,32,32,32,32,69,97,99,104,32,105, - 116,101,109,32,105,115,32,97,32,116,117,112,108,101,32,40, - 108,111,97,100,101,114,44,32,115,117,102,102,105,120,101,115, - 41,46,10,32,32,32,32,41,7,114,56,1,0,0,114,106, - 0,0,0,218,18,101,120,116,101,110,115,105,111,110,95,115, - 117,102,102,105,120,101,115,114,7,1,0,0,114,135,0,0, - 0,114,6,1,0,0,114,232,0,0,0,41,3,90,10,101, - 120,116,101,110,115,105,111,110,115,90,6,115,111,117,114,99, - 101,90,8,98,121,116,101,99,111,100,101,114,4,0,0,0, - 114,4,0,0,0,114,5,0,0,0,114,240,0,0,0,231, - 8,0,0,115,8,0,0,0,0,5,18,1,12,1,12,1, - 114,240,0,0,0,99,5,0,0,0,0,0,0,0,9,0, - 0,0,5,0,0,0,67,0,0,0,115,227,0,0,0,124, - 4,0,100,1,0,107,2,0,114,27,0,116,0,0,124,0, - 0,131,1,0,125,5,0,110,54,0,124,1,0,100,2,0, - 107,9,0,114,45,0,124,1,0,110,3,0,105,0,0,125, - 6,0,116,1,0,124,6,0,131,1,0,125,7,0,116,0, - 0,124,0,0,124,7,0,124,4,0,131,3,0,125,5,0, - 124,3,0,115,207,0,124,4,0,100,1,0,107,2,0,114, - 122,0,116,0,0,124,0,0,106,2,0,100,3,0,131,1, - 0,100,1,0,25,131,1,0,83,124,0,0,115,132,0,124, - 5,0,83,116,3,0,124,0,0,131,1,0,116,3,0,124, - 0,0,106,2,0,100,3,0,131,1,0,100,1,0,25,131, - 1,0,24,125,8,0,116,4,0,106,5,0,124,5,0,106, - 6,0,100,2,0,116,3,0,124,5,0,106,6,0,131,1, - 0,124,8,0,24,133,2,0,25,25,83,110,16,0,116,7, - 0,124,5,0,124,3,0,116,0,0,131,3,0,83,100,2, - 0,83,41,4,97,214,1,0,0,73,109,112,111,114,116,32, - 97,32,109,111,100,117,108,101,46,10,10,32,32,32,32,84, - 104,101,32,39,103,108,111,98,97,108,115,39,32,97,114,103, - 117,109,101,110,116,32,105,115,32,117,115,101,100,32,116,111, - 32,105,110,102,101,114,32,119,104,101,114,101,32,116,104,101, - 32,105,109,112,111,114,116,32,105,115,32,111,99,99,117,114, - 105,110,103,32,102,114,111,109,10,32,32,32,32,116,111,32, - 104,97,110,100,108,101,32,114,101,108,97,116,105,118,101,32, - 105,109,112,111,114,116,115,46,32,84,104,101,32,39,108,111, - 99,97,108,115,39,32,97,114,103,117,109,101,110,116,32,105, - 115,32,105,103,110,111,114,101,100,46,32,84,104,101,10,32, - 32,32,32,39,102,114,111,109,108,105,115,116,39,32,97,114, - 103,117,109,101,110,116,32,115,112,101,99,105,102,105,101,115, - 32,119,104,97,116,32,115,104,111,117,108,100,32,101,120,105, - 115,116,32,97,115,32,97,116,116,114,105,98,117,116,101,115, - 32,111,110,32,116,104,101,32,109,111,100,117,108,101,10,32, - 32,32,32,98,101,105,110,103,32,105,109,112,111,114,116,101, - 100,32,40,101,46,103,46,32,96,96,102,114,111,109,32,109, - 111,100,117,108,101,32,105,109,112,111,114,116,32,60,102,114, - 111,109,108,105,115,116,62,96,96,41,46,32,32,84,104,101, - 32,39,108,101,118,101,108,39,10,32,32,32,32,97,114,103, - 117,109,101,110,116,32,114,101,112,114,101,115,101,110,116,115, - 32,116,104,101,32,112,97,99,107,97,103,101,32,108,111,99, - 97,116,105,111,110,32,116,111,32,105,109,112,111,114,116,32, - 102,114,111,109,32,105,110,32,97,32,114,101,108,97,116,105, - 118,101,10,32,32,32,32,105,109,112,111,114,116,32,40,101, - 46,103,46,32,96,96,102,114,111,109,32,46,46,112,107,103, - 32,105,109,112,111,114,116,32,109,111,100,96,96,32,119,111, - 117,108,100,32,104,97,118,101,32,97,32,39,108,101,118,101, - 108,39,32,111,102,32,50,41,46,10,10,32,32,32,32,114, - 84,0,0,0,78,114,116,0,0,0,41,8,114,115,1,0, - 0,114,123,1,0,0,114,134,0,0,0,114,31,0,0,0, - 114,7,0,0,0,114,73,0,0,0,114,57,0,0,0,114, - 121,1,0,0,41,9,114,67,0,0,0,114,122,1,0,0, - 218,6,108,111,99,97,108,115,114,120,1,0,0,114,103,1, - 0,0,114,178,0,0,0,90,8,103,108,111,98,97,108,115, - 95,114,102,1,0,0,90,7,99,117,116,95,111,102,102,114, - 4,0,0,0,114,4,0,0,0,114,5,0,0,0,218,10, - 95,95,105,109,112,111,114,116,95,95,242,8,0,0,115,26, - 0,0,0,0,11,12,1,15,2,24,1,12,1,18,1,6, - 3,12,1,23,1,6,1,4,4,35,3,40,2,114,126,1, - 0,0,99,1,0,0,0,0,0,0,0,2,0,0,0,3, - 0,0,0,67,0,0,0,115,53,0,0,0,116,0,0,106, - 1,0,124,0,0,131,1,0,125,1,0,124,1,0,100,0, - 0,107,8,0,114,43,0,116,2,0,100,1,0,124,0,0, - 23,131,1,0,130,1,0,116,3,0,124,1,0,131,1,0, - 83,41,2,78,122,25,110,111,32,98,117,105,108,116,45,105, - 110,32,109,111,100,117,108,101,32,110,97,109,101,100,32,41, - 4,114,9,1,0,0,114,12,1,0,0,114,154,0,0,0, - 114,5,1,0,0,41,2,114,67,0,0,0,114,177,0,0, - 0,114,4,0,0,0,114,4,0,0,0,114,5,0,0,0, - 218,18,95,98,117,105,108,116,105,110,95,102,114,111,109,95, - 110,97,109,101,21,9,0,0,115,8,0,0,0,0,1,15, - 1,12,1,16,1,114,127,1,0,0,99,2,0,0,0,0, - 0,0,0,18,0,0,0,12,0,0,0,67,0,0,0,115, - 208,2,0,0,124,1,0,97,0,0,124,0,0,97,1,0, - 116,1,0,106,2,0,106,3,0,114,33,0,116,4,0,97, - 5,0,110,6,0,116,6,0,97,5,0,116,7,0,116,1, - 0,131,1,0,125,2,0,120,123,0,116,1,0,106,8,0, - 106,9,0,131,0,0,68,93,106,0,92,2,0,125,3,0, - 125,4,0,116,10,0,124,4,0,124,2,0,131,2,0,114, - 67,0,124,3,0,116,1,0,106,11,0,107,6,0,114,118, - 0,116,12,0,125,5,0,110,27,0,116,0,0,106,13,0, - 124,3,0,131,1,0,114,67,0,116,14,0,125,5,0,110, - 3,0,113,67,0,116,15,0,124,4,0,124,5,0,131,2, - 0,125,6,0,116,16,0,124,6,0,124,4,0,131,2,0, - 1,113,67,0,87,116,1,0,106,8,0,116,17,0,25,125, - 7,0,120,73,0,100,26,0,68,93,65,0,125,8,0,124, - 8,0,116,1,0,106,8,0,107,7,0,114,233,0,116,18, - 0,124,8,0,131,1,0,125,9,0,110,13,0,116,1,0, - 106,8,0,124,8,0,25,125,9,0,116,19,0,124,7,0, - 124,8,0,124,9,0,131,3,0,1,113,197,0,87,100,5, - 0,100,6,0,103,1,0,102,2,0,100,7,0,100,8,0, - 100,6,0,103,2,0,102,2,0,102,2,0,125,10,0,120, - 146,0,124,10,0,68,93,126,0,92,2,0,125,11,0,125, - 12,0,116,20,0,100,9,0,100,10,0,132,0,0,124,12, - 0,68,131,1,0,131,1,0,115,93,1,116,21,0,130,1, - 0,124,12,0,100,11,0,25,125,13,0,124,11,0,116,1, - 0,106,8,0,107,6,0,114,135,1,116,1,0,106,8,0, - 124,11,0,25,125,14,0,80,113,50,1,121,17,0,116,18, - 0,124,11,0,131,1,0,125,14,0,80,87,113,50,1,4, - 116,22,0,107,10,0,114,175,1,1,1,1,119,50,1,89, - 113,50,1,88,113,50,1,87,116,22,0,100,12,0,131,1, - 0,130,1,0,116,19,0,124,7,0,100,13,0,124,14,0, - 131,3,0,1,116,19,0,124,7,0,100,14,0,124,13,0, - 131,3,0,1,116,19,0,124,7,0,100,15,0,100,16,0, - 106,23,0,124,12,0,131,1,0,131,3,0,1,121,16,0, - 116,18,0,100,17,0,131,1,0,125,15,0,87,110,24,0, - 4,116,22,0,107,10,0,114,35,2,1,1,1,100,18,0, - 125,15,0,89,110,1,0,88,116,19,0,124,7,0,100,17, - 0,124,15,0,131,3,0,1,116,18,0,100,19,0,131,1, - 0,125,16,0,116,19,0,124,7,0,100,19,0,124,16,0, - 131,3,0,1,124,11,0,100,7,0,107,2,0,114,120,2, - 116,18,0,100,20,0,131,1,0,125,17,0,116,19,0,124, - 7,0,100,21,0,124,17,0,131,3,0,1,116,19,0,124, - 7,0,100,22,0,116,24,0,131,0,0,131,3,0,1,116, - 25,0,106,26,0,116,0,0,106,27,0,131,0,0,131,1, - 0,1,124,11,0,100,7,0,107,2,0,114,204,2,116,28, - 0,106,29,0,100,23,0,131,1,0,1,100,24,0,116,25, - 0,107,6,0,114,204,2,100,25,0,116,30,0,95,31,0, - 100,18,0,83,41,27,122,250,83,101,116,117,112,32,105,109, - 112,111,114,116,108,105,98,32,98,121,32,105,109,112,111,114, - 116,105,110,103,32,110,101,101,100,101,100,32,98,117,105,108, - 116,45,105,110,32,109,111,100,117,108,101,115,32,97,110,100, - 32,105,110,106,101,99,116,105,110,103,32,116,104,101,109,10, - 32,32,32,32,105,110,116,111,32,116,104,101,32,103,108,111, - 98,97,108,32,110,97,109,101,115,112,97,99,101,46,10,10, - 32,32,32,32,65,115,32,115,121,115,32,105,115,32,110,101, - 101,100,101,100,32,102,111,114,32,115,121,115,46,109,111,100, - 117,108,101,115,32,97,99,99,101,115,115,32,97,110,100,32, - 95,105,109,112,32,105,115,32,110,101,101,100,101,100,32,116, - 111,32,108,111,97,100,32,98,117,105,108,116,45,105,110,10, - 32,32,32,32,109,111,100,117,108,101,115,44,32,116,104,111, - 115,101,32,116,119,111,32,109,111,100,117,108,101,115,32,109, - 117,115,116,32,98,101,32,101,120,112,108,105,99,105,116,108, - 121,32,112,97,115,115,101,100,32,105,110,46,10,10,32,32, - 32,32,114,49,0,0,0,114,167,0,0,0,218,8,98,117, - 105,108,116,105,110,115,114,190,0,0,0,90,5,112,111,115, - 105,120,250,1,47,218,2,110,116,250,1,92,99,1,0,0, - 0,0,0,0,0,2,0,0,0,3,0,0,0,115,0,0, - 0,115,33,0,0,0,124,0,0,93,23,0,125,1,0,116, - 0,0,124,1,0,131,1,0,100,0,0,107,2,0,86,1, - 113,3,0,100,1,0,83,41,2,114,29,0,0,0,78,41, - 1,114,31,0,0,0,41,2,114,22,0,0,0,114,129,0, - 0,0,114,4,0,0,0,114,4,0,0,0,114,5,0,0, - 0,114,77,0,0,0,71,9,0,0,115,2,0,0,0,6, - 0,122,25,95,115,101,116,117,112,46,60,108,111,99,97,108, - 115,62,46,60,103,101,110,101,120,112,114,62,114,84,0,0, - 0,122,30,105,109,112,111,114,116,108,105,98,32,114,101,113, - 117,105,114,101,115,32,112,111,115,105,120,32,111,114,32,110, - 116,114,3,0,0,0,114,25,0,0,0,114,21,0,0,0, - 114,30,0,0,0,114,85,0,0,0,78,114,111,0,0,0, - 90,6,119,105,110,114,101,103,114,23,1,0,0,114,6,0, - 0,0,122,4,46,112,121,119,122,6,95,100,46,112,121,100, - 84,41,4,122,3,95,105,111,122,9,95,119,97,114,110,105, - 110,103,115,122,8,98,117,105,108,116,105,110,115,122,7,109, - 97,114,115,104,97,108,41,32,114,106,0,0,0,114,7,0, - 0,0,114,117,0,0,0,114,118,0,0,0,114,120,0,0, - 0,114,232,0,0,0,114,119,0,0,0,114,66,0,0,0, - 114,73,0,0,0,218,5,105,116,101,109,115,114,191,0,0, - 0,114,158,0,0,0,114,9,1,0,0,114,163,0,0,0, - 114,18,1,0,0,114,247,0,0,0,114,253,0,0,0,114, - 57,0,0,0,114,127,1,0,0,114,61,0,0,0,218,3, - 97,108,108,114,100,0,0,0,114,154,0,0,0,114,26,0, - 0,0,114,11,0,0,0,114,59,1,0,0,114,196,0,0, - 0,114,124,1,0,0,114,135,0,0,0,114,223,0,0,0, - 114,22,1,0,0,114,26,1,0,0,41,18,218,10,115,121, - 115,95,109,111,100,117,108,101,218,11,95,105,109,112,95,109, - 111,100,117,108,101,90,11,109,111,100,117,108,101,95,116,121, - 112,101,114,67,0,0,0,114,178,0,0,0,114,170,0,0, - 0,114,177,0,0,0,90,11,115,101,108,102,95,109,111,100, - 117,108,101,90,12,98,117,105,108,116,105,110,95,110,97,109, - 101,90,14,98,117,105,108,116,105,110,95,109,111,100,117,108, - 101,90,10,111,115,95,100,101,116,97,105,108,115,90,10,98, - 117,105,108,116,105,110,95,111,115,114,21,0,0,0,114,25, - 0,0,0,90,9,111,115,95,109,111,100,117,108,101,90,13, - 116,104,114,101,97,100,95,109,111,100,117,108,101,90,14,119, - 101,97,107,114,101,102,95,109,111,100,117,108,101,90,13,119, - 105,110,114,101,103,95,109,111,100,117,108,101,114,4,0,0, - 0,114,4,0,0,0,114,5,0,0,0,218,6,95,115,101, - 116,117,112,28,9,0,0,115,106,0,0,0,0,9,6,1, - 6,2,12,1,9,2,6,3,12,1,28,1,15,1,15,1, - 9,1,15,1,9,2,3,1,15,1,17,3,13,1,13,1, - 15,1,15,2,13,1,20,3,33,1,19,2,31,1,10,1, - 15,1,13,1,4,2,3,1,12,1,5,1,13,1,12,2, - 12,1,16,1,16,1,25,3,3,1,16,1,13,2,11,1, - 16,3,12,1,16,3,12,1,12,1,16,3,19,1,19,1, - 12,1,13,1,12,1,114,136,1,0,0,99,2,0,0,0, - 0,0,0,0,3,0,0,0,3,0,0,0,67,0,0,0, - 115,133,0,0,0,116,0,0,124,0,0,124,1,0,131,2, - 0,1,116,1,0,131,0,0,125,2,0,116,2,0,106,3, - 0,106,4,0,116,5,0,106,6,0,124,2,0,140,0,0, - 103,1,0,131,1,0,1,116,2,0,106,7,0,106,8,0, - 116,9,0,131,1,0,1,116,2,0,106,7,0,106,8,0, - 116,10,0,131,1,0,1,116,11,0,106,12,0,100,1,0, - 107,2,0,114,113,0,116,2,0,106,7,0,106,8,0,116, - 13,0,131,1,0,1,116,2,0,106,7,0,106,8,0,116, - 14,0,131,1,0,1,100,2,0,83,41,3,122,50,73,110, - 115,116,97,108,108,32,105,109,112,111,114,116,108,105,98,32, - 97,115,32,116,104,101,32,105,109,112,108,101,109,101,110,116, - 97,116,105,111,110,32,111,102,32,105,109,112,111,114,116,46, - 114,130,1,0,0,78,41,15,114,136,1,0,0,114,240,0, - 0,0,114,7,0,0,0,114,78,1,0,0,114,196,0,0, - 0,114,87,1,0,0,114,100,1,0,0,114,106,1,0,0, - 114,223,0,0,0,114,9,1,0,0,114,18,1,0,0,114, - 3,0,0,0,114,57,0,0,0,114,22,1,0,0,114,73, - 1,0,0,41,3,114,134,1,0,0,114,135,1,0,0,90, - 17,115,117,112,112,111,114,116,101,100,95,108,111,97,100,101, - 114,115,114,4,0,0,0,114,4,0,0,0,114,5,0,0, - 0,218,8,95,105,110,115,116,97,108,108,114,9,0,0,115, - 16,0,0,0,0,2,13,1,9,1,28,1,16,1,16,1, - 15,1,16,1,114,137,1,0,0,41,3,122,3,119,105,110, - 114,1,0,0,0,114,2,0,0,0,41,98,114,59,0,0, - 0,114,10,0,0,0,114,11,0,0,0,114,17,0,0,0, - 114,19,0,0,0,114,28,0,0,0,114,38,0,0,0,114, - 39,0,0,0,114,43,0,0,0,114,44,0,0,0,114,46, - 0,0,0,114,55,0,0,0,114,65,0,0,0,114,68,0, - 0,0,114,66,0,0,0,218,8,95,95,99,111,100,101,95, - 95,114,192,0,0,0,114,69,0,0,0,114,109,0,0,0, - 114,92,0,0,0,114,99,0,0,0,114,82,0,0,0,114, - 83,0,0,0,114,102,0,0,0,114,103,0,0,0,114,105, - 0,0,0,114,112,0,0,0,114,114,0,0,0,114,15,0, - 0,0,114,184,0,0,0,114,14,0,0,0,114,18,0,0, - 0,90,17,95,82,65,87,95,77,65,71,73,67,95,78,85, - 77,66,69,82,114,124,0,0,0,114,135,0,0,0,114,119, - 0,0,0,114,120,0,0,0,114,132,0,0,0,114,136,0, - 0,0,114,143,0,0,0,114,145,0,0,0,114,153,0,0, - 0,114,157,0,0,0,114,162,0,0,0,114,165,0,0,0, - 114,173,0,0,0,114,179,0,0,0,114,189,0,0,0,114, - 194,0,0,0,114,197,0,0,0,114,202,0,0,0,114,211, - 0,0,0,114,212,0,0,0,114,216,0,0,0,114,174,0, - 0,0,218,6,111,98,106,101,99,116,114,241,0,0,0,114, - 239,0,0,0,114,247,0,0,0,114,253,0,0,0,114,1, - 1,0,0,114,209,0,0,0,114,175,0,0,0,114,4,1, - 0,0,114,5,1,0,0,114,176,0,0,0,114,8,1,0, - 0,114,9,1,0,0,114,18,1,0,0,114,22,1,0,0, - 114,32,1,0,0,114,33,1,0,0,114,48,1,0,0,114, - 7,1,0,0,114,6,1,0,0,114,59,1,0,0,114,56, - 1,0,0,114,60,1,0,0,114,250,0,0,0,114,73,1, - 0,0,114,87,1,0,0,114,101,1,0,0,114,104,1,0, - 0,114,105,1,0,0,114,107,1,0,0,114,110,1,0,0, - 114,119,1,0,0,114,111,1,0,0,114,113,1,0,0,114, - 114,1,0,0,114,115,1,0,0,114,121,1,0,0,114,123, - 1,0,0,114,240,0,0,0,114,126,1,0,0,114,127,1, - 0,0,114,136,1,0,0,114,137,1,0,0,114,4,0,0, - 0,114,4,0,0,0,114,4,0,0,0,114,5,0,0,0, - 218,8,60,109,111,100,117,108,101,62,8,0,0,0,115,182, - 0,0,0,6,17,6,3,12,12,12,5,12,5,12,6,12, - 12,12,10,12,9,12,5,12,7,15,22,12,8,12,4,15, - 4,19,20,6,2,6,3,22,4,19,68,19,21,19,19,12, - 19,12,20,12,115,22,1,18,2,6,2,9,2,9,1,9, - 2,15,27,12,23,12,19,12,12,18,8,12,18,12,11,12, - 11,12,18,12,15,21,55,21,12,18,10,12,14,12,36,19, - 27,19,106,24,22,9,3,12,1,15,63,18,45,18,56,12, - 18,12,17,12,25,12,29,12,23,12,14,15,25,19,70,19, - 75,19,63,19,27,22,110,19,41,25,43,25,16,6,3,19, - 57,19,57,19,41,19,134,19,146,19,13,12,9,12,9,15, - 40,12,17,6,1,10,2,12,27,12,6,18,24,12,32,12, - 15,12,11,24,35,12,7,12,86, + 16,95,104,97,110,100,108,101,95,102,114,111,109,108,105,115, + 116,180,8,0,0,115,34,0,0,0,0,10,15,1,12,1, + 12,1,13,1,15,1,16,1,13,1,15,1,21,1,3,1, + 17,1,18,4,21,1,15,1,3,1,26,1,114,121,1,0, + 0,99,1,0,0,0,0,0,0,0,2,0,0,0,2,0, + 0,0,67,0,0,0,115,72,0,0,0,124,0,0,106,0, + 0,100,1,0,131,1,0,125,1,0,124,1,0,100,2,0, + 107,8,0,114,68,0,124,0,0,100,3,0,25,125,1,0, + 100,4,0,124,0,0,107,7,0,114,68,0,124,1,0,106, + 1,0,100,5,0,131,1,0,100,6,0,25,125,1,0,124, + 1,0,83,41,7,122,167,67,97,108,99,117,108,97,116,101, + 32,119,104,97,116,32,95,95,112,97,99,107,97,103,101,95, + 95,32,115,104,111,117,108,100,32,98,101,46,10,10,32,32, + 32,32,95,95,112,97,99,107,97,103,101,95,95,32,105,115, + 32,110,111,116,32,103,117,97,114,97,110,116,101,101,100,32, + 116,111,32,98,101,32,100,101,102,105,110,101,100,32,111,114, + 32,99,111,117,108,100,32,98,101,32,115,101,116,32,116,111, + 32,78,111,110,101,10,32,32,32,32,116,111,32,114,101,112, + 114,101,115,101,110,116,32,116,104,97,116,32,105,116,115,32, + 112,114,111,112,101,114,32,118,97,108,117,101,32,105,115,32, + 117,110,107,110,111,119,110,46,10,10,32,32,32,32,114,249, + 0,0,0,78,114,57,0,0,0,114,246,0,0,0,114,116, + 0,0,0,114,84,0,0,0,41,2,114,93,0,0,0,114, + 32,0,0,0,41,2,218,7,103,108,111,98,97,108,115,114, + 102,1,0,0,114,4,0,0,0,114,4,0,0,0,114,5, + 0,0,0,218,17,95,99,97,108,99,95,95,95,112,97,99, + 107,97,103,101,95,95,212,8,0,0,115,12,0,0,0,0, + 7,15,1,12,1,10,1,12,1,19,1,114,123,1,0,0, + 99,0,0,0,0,0,0,0,0,3,0,0,0,3,0,0, + 0,67,0,0,0,115,55,0,0,0,116,0,0,116,1,0, + 106,2,0,131,0,0,102,2,0,125,0,0,116,3,0,116, + 4,0,102,2,0,125,1,0,116,5,0,116,6,0,102,2, + 0,125,2,0,124,0,0,124,1,0,124,2,0,103,3,0, + 83,41,1,122,95,82,101,116,117,114,110,115,32,97,32,108, + 105,115,116,32,111,102,32,102,105,108,101,45,98,97,115,101, + 100,32,109,111,100,117,108,101,32,108,111,97,100,101,114,115, + 46,10,10,32,32,32,32,69,97,99,104,32,105,116,101,109, + 32,105,115,32,97,32,116,117,112,108,101,32,40,108,111,97, + 100,101,114,44,32,115,117,102,102,105,120,101,115,41,46,10, + 32,32,32,32,41,7,114,56,1,0,0,114,106,0,0,0, + 218,18,101,120,116,101,110,115,105,111,110,95,115,117,102,102, + 105,120,101,115,114,7,1,0,0,114,135,0,0,0,114,6, + 1,0,0,114,232,0,0,0,41,3,90,10,101,120,116,101, + 110,115,105,111,110,115,90,6,115,111,117,114,99,101,90,8, + 98,121,116,101,99,111,100,101,114,4,0,0,0,114,4,0, + 0,0,114,5,0,0,0,114,240,0,0,0,227,8,0,0, + 115,8,0,0,0,0,5,18,1,12,1,12,1,114,240,0, + 0,0,99,5,0,0,0,0,0,0,0,9,0,0,0,5, + 0,0,0,67,0,0,0,115,227,0,0,0,124,4,0,100, + 1,0,107,2,0,114,27,0,116,0,0,124,0,0,131,1, + 0,125,5,0,110,54,0,124,1,0,100,2,0,107,9,0, + 114,45,0,124,1,0,110,3,0,105,0,0,125,6,0,116, + 1,0,124,6,0,131,1,0,125,7,0,116,0,0,124,0, + 0,124,7,0,124,4,0,131,3,0,125,5,0,124,3,0, + 115,207,0,124,4,0,100,1,0,107,2,0,114,122,0,116, + 0,0,124,0,0,106,2,0,100,3,0,131,1,0,100,1, + 0,25,131,1,0,83,124,0,0,115,132,0,124,5,0,83, + 116,3,0,124,0,0,131,1,0,116,3,0,124,0,0,106, + 2,0,100,3,0,131,1,0,100,1,0,25,131,1,0,24, + 125,8,0,116,4,0,106,5,0,124,5,0,106,6,0,100, + 2,0,116,3,0,124,5,0,106,6,0,131,1,0,124,8, + 0,24,133,2,0,25,25,83,110,16,0,116,7,0,124,5, + 0,124,3,0,116,0,0,131,3,0,83,100,2,0,83,41, + 4,97,214,1,0,0,73,109,112,111,114,116,32,97,32,109, + 111,100,117,108,101,46,10,10,32,32,32,32,84,104,101,32, + 39,103,108,111,98,97,108,115,39,32,97,114,103,117,109,101, + 110,116,32,105,115,32,117,115,101,100,32,116,111,32,105,110, + 102,101,114,32,119,104,101,114,101,32,116,104,101,32,105,109, + 112,111,114,116,32,105,115,32,111,99,99,117,114,105,110,103, + 32,102,114,111,109,10,32,32,32,32,116,111,32,104,97,110, + 100,108,101,32,114,101,108,97,116,105,118,101,32,105,109,112, + 111,114,116,115,46,32,84,104,101,32,39,108,111,99,97,108, + 115,39,32,97,114,103,117,109,101,110,116,32,105,115,32,105, + 103,110,111,114,101,100,46,32,84,104,101,10,32,32,32,32, + 39,102,114,111,109,108,105,115,116,39,32,97,114,103,117,109, + 101,110,116,32,115,112,101,99,105,102,105,101,115,32,119,104, + 97,116,32,115,104,111,117,108,100,32,101,120,105,115,116,32, + 97,115,32,97,116,116,114,105,98,117,116,101,115,32,111,110, + 32,116,104,101,32,109,111,100,117,108,101,10,32,32,32,32, + 98,101,105,110,103,32,105,109,112,111,114,116,101,100,32,40, + 101,46,103,46,32,96,96,102,114,111,109,32,109,111,100,117, + 108,101,32,105,109,112,111,114,116,32,60,102,114,111,109,108, + 105,115,116,62,96,96,41,46,32,32,84,104,101,32,39,108, + 101,118,101,108,39,10,32,32,32,32,97,114,103,117,109,101, + 110,116,32,114,101,112,114,101,115,101,110,116,115,32,116,104, + 101,32,112,97,99,107,97,103,101,32,108,111,99,97,116,105, + 111,110,32,116,111,32,105,109,112,111,114,116,32,102,114,111, + 109,32,105,110,32,97,32,114,101,108,97,116,105,118,101,10, + 32,32,32,32,105,109,112,111,114,116,32,40,101,46,103,46, + 32,96,96,102,114,111,109,32,46,46,112,107,103,32,105,109, + 112,111,114,116,32,109,111,100,96,96,32,119,111,117,108,100, + 32,104,97,118,101,32,97,32,39,108,101,118,101,108,39,32, + 111,102,32,50,41,46,10,10,32,32,32,32,114,84,0,0, + 0,78,114,116,0,0,0,41,8,114,115,1,0,0,114,123, + 1,0,0,114,134,0,0,0,114,31,0,0,0,114,7,0, + 0,0,114,73,0,0,0,114,57,0,0,0,114,121,1,0, + 0,41,9,114,67,0,0,0,114,122,1,0,0,218,6,108, + 111,99,97,108,115,114,120,1,0,0,114,103,1,0,0,114, + 178,0,0,0,90,8,103,108,111,98,97,108,115,95,114,102, + 1,0,0,90,7,99,117,116,95,111,102,102,114,4,0,0, + 0,114,4,0,0,0,114,5,0,0,0,218,10,95,95,105, + 109,112,111,114,116,95,95,238,8,0,0,115,26,0,0,0, + 0,11,12,1,15,2,24,1,12,1,18,1,6,3,12,1, + 23,1,6,1,4,4,35,3,40,2,114,126,1,0,0,99, + 1,0,0,0,0,0,0,0,2,0,0,0,3,0,0,0, + 67,0,0,0,115,53,0,0,0,116,0,0,106,1,0,124, + 0,0,131,1,0,125,1,0,124,1,0,100,0,0,107,8, + 0,114,43,0,116,2,0,100,1,0,124,0,0,23,131,1, + 0,130,1,0,116,3,0,124,1,0,131,1,0,83,41,2, + 78,122,25,110,111,32,98,117,105,108,116,45,105,110,32,109, + 111,100,117,108,101,32,110,97,109,101,100,32,41,4,114,9, + 1,0,0,114,12,1,0,0,114,154,0,0,0,114,5,1, + 0,0,41,2,114,67,0,0,0,114,177,0,0,0,114,4, + 0,0,0,114,4,0,0,0,114,5,0,0,0,218,18,95, + 98,117,105,108,116,105,110,95,102,114,111,109,95,110,97,109, + 101,17,9,0,0,115,8,0,0,0,0,1,15,1,12,1, + 16,1,114,127,1,0,0,99,2,0,0,0,0,0,0,0, + 18,0,0,0,12,0,0,0,67,0,0,0,115,208,2,0, + 0,124,1,0,97,0,0,124,0,0,97,1,0,116,1,0, + 106,2,0,106,3,0,114,33,0,116,4,0,97,5,0,110, + 6,0,116,6,0,97,5,0,116,7,0,116,1,0,131,1, + 0,125,2,0,120,123,0,116,1,0,106,8,0,106,9,0, + 131,0,0,68,93,106,0,92,2,0,125,3,0,125,4,0, + 116,10,0,124,4,0,124,2,0,131,2,0,114,67,0,124, + 3,0,116,1,0,106,11,0,107,6,0,114,118,0,116,12, + 0,125,5,0,110,27,0,116,0,0,106,13,0,124,3,0, + 131,1,0,114,67,0,116,14,0,125,5,0,110,3,0,113, + 67,0,116,15,0,124,4,0,124,5,0,131,2,0,125,6, + 0,116,16,0,124,6,0,124,4,0,131,2,0,1,113,67, + 0,87,116,1,0,106,8,0,116,17,0,25,125,7,0,120, + 73,0,100,26,0,68,93,65,0,125,8,0,124,8,0,116, + 1,0,106,8,0,107,7,0,114,233,0,116,18,0,124,8, + 0,131,1,0,125,9,0,110,13,0,116,1,0,106,8,0, + 124,8,0,25,125,9,0,116,19,0,124,7,0,124,8,0, + 124,9,0,131,3,0,1,113,197,0,87,100,5,0,100,6, + 0,103,1,0,102,2,0,100,7,0,100,8,0,100,6,0, + 103,2,0,102,2,0,102,2,0,125,10,0,120,146,0,124, + 10,0,68,93,126,0,92,2,0,125,11,0,125,12,0,116, + 20,0,100,9,0,100,10,0,132,0,0,124,12,0,68,131, + 1,0,131,1,0,115,93,1,116,21,0,130,1,0,124,12, + 0,100,11,0,25,125,13,0,124,11,0,116,1,0,106,8, + 0,107,6,0,114,135,1,116,1,0,106,8,0,124,11,0, + 25,125,14,0,80,113,50,1,121,17,0,116,18,0,124,11, + 0,131,1,0,125,14,0,80,87,113,50,1,4,116,22,0, + 107,10,0,114,175,1,1,1,1,119,50,1,89,113,50,1, + 88,113,50,1,87,116,22,0,100,12,0,131,1,0,130,1, + 0,116,19,0,124,7,0,100,13,0,124,14,0,131,3,0, + 1,116,19,0,124,7,0,100,14,0,124,13,0,131,3,0, + 1,116,19,0,124,7,0,100,15,0,100,16,0,106,23,0, + 124,12,0,131,1,0,131,3,0,1,121,16,0,116,18,0, + 100,17,0,131,1,0,125,15,0,87,110,24,0,4,116,22, + 0,107,10,0,114,35,2,1,1,1,100,18,0,125,15,0, + 89,110,1,0,88,116,19,0,124,7,0,100,17,0,124,15, + 0,131,3,0,1,116,18,0,100,19,0,131,1,0,125,16, + 0,116,19,0,124,7,0,100,19,0,124,16,0,131,3,0, + 1,124,11,0,100,7,0,107,2,0,114,120,2,116,18,0, + 100,20,0,131,1,0,125,17,0,116,19,0,124,7,0,100, + 21,0,124,17,0,131,3,0,1,116,19,0,124,7,0,100, + 22,0,116,24,0,131,0,0,131,3,0,1,116,25,0,106, + 26,0,116,0,0,106,27,0,131,0,0,131,1,0,1,124, + 11,0,100,7,0,107,2,0,114,204,2,116,28,0,106,29, + 0,100,23,0,131,1,0,1,100,24,0,116,25,0,107,6, + 0,114,204,2,100,25,0,116,30,0,95,31,0,100,18,0, + 83,41,27,122,250,83,101,116,117,112,32,105,109,112,111,114, + 116,108,105,98,32,98,121,32,105,109,112,111,114,116,105,110, + 103,32,110,101,101,100,101,100,32,98,117,105,108,116,45,105, + 110,32,109,111,100,117,108,101,115,32,97,110,100,32,105,110, + 106,101,99,116,105,110,103,32,116,104,101,109,10,32,32,32, + 32,105,110,116,111,32,116,104,101,32,103,108,111,98,97,108, + 32,110,97,109,101,115,112,97,99,101,46,10,10,32,32,32, + 32,65,115,32,115,121,115,32,105,115,32,110,101,101,100,101, + 100,32,102,111,114,32,115,121,115,46,109,111,100,117,108,101, + 115,32,97,99,99,101,115,115,32,97,110,100,32,95,105,109, + 112,32,105,115,32,110,101,101,100,101,100,32,116,111,32,108, + 111,97,100,32,98,117,105,108,116,45,105,110,10,32,32,32, + 32,109,111,100,117,108,101,115,44,32,116,104,111,115,101,32, + 116,119,111,32,109,111,100,117,108,101,115,32,109,117,115,116, + 32,98,101,32,101,120,112,108,105,99,105,116,108,121,32,112, + 97,115,115,101,100,32,105,110,46,10,10,32,32,32,32,114, + 49,0,0,0,114,167,0,0,0,218,8,98,117,105,108,116, + 105,110,115,114,190,0,0,0,90,5,112,111,115,105,120,250, + 1,47,218,2,110,116,250,1,92,99,1,0,0,0,0,0, + 0,0,2,0,0,0,3,0,0,0,115,0,0,0,115,33, + 0,0,0,124,0,0,93,23,0,125,1,0,116,0,0,124, + 1,0,131,1,0,100,0,0,107,2,0,86,1,113,3,0, + 100,1,0,83,41,2,114,29,0,0,0,78,41,1,114,31, + 0,0,0,41,2,114,22,0,0,0,114,129,0,0,0,114, + 4,0,0,0,114,4,0,0,0,114,5,0,0,0,114,77, + 0,0,0,67,9,0,0,115,2,0,0,0,6,0,122,25, + 95,115,101,116,117,112,46,60,108,111,99,97,108,115,62,46, + 60,103,101,110,101,120,112,114,62,114,84,0,0,0,122,30, + 105,109,112,111,114,116,108,105,98,32,114,101,113,117,105,114, + 101,115,32,112,111,115,105,120,32,111,114,32,110,116,114,3, + 0,0,0,114,25,0,0,0,114,21,0,0,0,114,30,0, + 0,0,114,85,0,0,0,78,114,111,0,0,0,90,6,119, + 105,110,114,101,103,114,23,1,0,0,114,6,0,0,0,122, + 4,46,112,121,119,122,6,95,100,46,112,121,100,84,41,4, + 122,3,95,105,111,122,9,95,119,97,114,110,105,110,103,115, + 122,8,98,117,105,108,116,105,110,115,122,7,109,97,114,115, + 104,97,108,41,32,114,106,0,0,0,114,7,0,0,0,114, + 117,0,0,0,114,118,0,0,0,114,120,0,0,0,114,232, + 0,0,0,114,119,0,0,0,114,66,0,0,0,114,73,0, + 0,0,218,5,105,116,101,109,115,114,191,0,0,0,114,158, + 0,0,0,114,9,1,0,0,114,163,0,0,0,114,18,1, + 0,0,114,247,0,0,0,114,253,0,0,0,114,57,0,0, + 0,114,127,1,0,0,114,61,0,0,0,218,3,97,108,108, + 114,100,0,0,0,114,154,0,0,0,114,26,0,0,0,114, + 11,0,0,0,114,59,1,0,0,114,196,0,0,0,114,124, + 1,0,0,114,135,0,0,0,114,223,0,0,0,114,22,1, + 0,0,114,26,1,0,0,41,18,218,10,115,121,115,95,109, + 111,100,117,108,101,218,11,95,105,109,112,95,109,111,100,117, + 108,101,90,11,109,111,100,117,108,101,95,116,121,112,101,114, + 67,0,0,0,114,178,0,0,0,114,170,0,0,0,114,177, + 0,0,0,90,11,115,101,108,102,95,109,111,100,117,108,101, + 90,12,98,117,105,108,116,105,110,95,110,97,109,101,90,14, + 98,117,105,108,116,105,110,95,109,111,100,117,108,101,90,10, + 111,115,95,100,101,116,97,105,108,115,90,10,98,117,105,108, + 116,105,110,95,111,115,114,21,0,0,0,114,25,0,0,0, + 90,9,111,115,95,109,111,100,117,108,101,90,13,116,104,114, + 101,97,100,95,109,111,100,117,108,101,90,14,119,101,97,107, + 114,101,102,95,109,111,100,117,108,101,90,13,119,105,110,114, + 101,103,95,109,111,100,117,108,101,114,4,0,0,0,114,4, + 0,0,0,114,5,0,0,0,218,6,95,115,101,116,117,112, + 24,9,0,0,115,106,0,0,0,0,9,6,1,6,2,12, + 1,9,2,6,3,12,1,28,1,15,1,15,1,9,1,15, + 1,9,2,3,1,15,1,17,3,13,1,13,1,15,1,15, + 2,13,1,20,3,33,1,19,2,31,1,10,1,15,1,13, + 1,4,2,3,1,12,1,5,1,13,1,12,2,12,1,16, + 1,16,1,25,3,3,1,16,1,13,2,11,1,16,3,12, + 1,16,3,12,1,12,1,16,3,19,1,19,1,12,1,13, + 1,12,1,114,136,1,0,0,99,2,0,0,0,0,0,0, + 0,3,0,0,0,3,0,0,0,67,0,0,0,115,133,0, + 0,0,116,0,0,124,0,0,124,1,0,131,2,0,1,116, + 1,0,131,0,0,125,2,0,116,2,0,106,3,0,106,4, + 0,116,5,0,106,6,0,124,2,0,140,0,0,103,1,0, + 131,1,0,1,116,2,0,106,7,0,106,8,0,116,9,0, + 131,1,0,1,116,2,0,106,7,0,106,8,0,116,10,0, + 131,1,0,1,116,11,0,106,12,0,100,1,0,107,2,0, + 114,113,0,116,2,0,106,7,0,106,8,0,116,13,0,131, + 1,0,1,116,2,0,106,7,0,106,8,0,116,14,0,131, + 1,0,1,100,2,0,83,41,3,122,50,73,110,115,116,97, + 108,108,32,105,109,112,111,114,116,108,105,98,32,97,115,32, + 116,104,101,32,105,109,112,108,101,109,101,110,116,97,116,105, + 111,110,32,111,102,32,105,109,112,111,114,116,46,114,130,1, + 0,0,78,41,15,114,136,1,0,0,114,240,0,0,0,114, + 7,0,0,0,114,78,1,0,0,114,196,0,0,0,114,87, + 1,0,0,114,100,1,0,0,114,106,1,0,0,114,223,0, + 0,0,114,9,1,0,0,114,18,1,0,0,114,3,0,0, + 0,114,57,0,0,0,114,22,1,0,0,114,73,1,0,0, + 41,3,114,134,1,0,0,114,135,1,0,0,90,17,115,117, + 112,112,111,114,116,101,100,95,108,111,97,100,101,114,115,114, + 4,0,0,0,114,4,0,0,0,114,5,0,0,0,218,8, + 95,105,110,115,116,97,108,108,110,9,0,0,115,16,0,0, + 0,0,2,13,1,9,1,28,1,16,1,16,1,15,1,16, + 1,114,137,1,0,0,41,3,122,3,119,105,110,114,1,0, + 0,0,114,2,0,0,0,41,98,114,59,0,0,0,114,10, + 0,0,0,114,11,0,0,0,114,17,0,0,0,114,19,0, + 0,0,114,28,0,0,0,114,38,0,0,0,114,39,0,0, + 0,114,43,0,0,0,114,44,0,0,0,114,46,0,0,0, + 114,55,0,0,0,114,65,0,0,0,114,68,0,0,0,114, + 66,0,0,0,218,8,95,95,99,111,100,101,95,95,114,192, + 0,0,0,114,69,0,0,0,114,109,0,0,0,114,92,0, + 0,0,114,99,0,0,0,114,82,0,0,0,114,83,0,0, + 0,114,102,0,0,0,114,103,0,0,0,114,105,0,0,0, + 114,112,0,0,0,114,114,0,0,0,114,15,0,0,0,114, + 184,0,0,0,114,14,0,0,0,114,18,0,0,0,90,17, + 95,82,65,87,95,77,65,71,73,67,95,78,85,77,66,69, + 82,114,124,0,0,0,114,135,0,0,0,114,119,0,0,0, + 114,120,0,0,0,114,132,0,0,0,114,136,0,0,0,114, + 143,0,0,0,114,145,0,0,0,114,153,0,0,0,114,157, + 0,0,0,114,162,0,0,0,114,165,0,0,0,114,173,0, + 0,0,114,179,0,0,0,114,189,0,0,0,114,194,0,0, + 0,114,197,0,0,0,114,202,0,0,0,114,211,0,0,0, + 114,212,0,0,0,114,216,0,0,0,114,174,0,0,0,218, + 6,111,98,106,101,99,116,114,241,0,0,0,114,239,0,0, + 0,114,247,0,0,0,114,253,0,0,0,114,1,1,0,0, + 114,209,0,0,0,114,175,0,0,0,114,4,1,0,0,114, + 5,1,0,0,114,176,0,0,0,114,8,1,0,0,114,9, + 1,0,0,114,18,1,0,0,114,22,1,0,0,114,32,1, + 0,0,114,33,1,0,0,114,48,1,0,0,114,7,1,0, + 0,114,6,1,0,0,114,59,1,0,0,114,56,1,0,0, + 114,60,1,0,0,114,250,0,0,0,114,73,1,0,0,114, + 87,1,0,0,114,101,1,0,0,114,104,1,0,0,114,105, + 1,0,0,114,107,1,0,0,114,110,1,0,0,114,119,1, + 0,0,114,111,1,0,0,114,113,1,0,0,114,114,1,0, + 0,114,115,1,0,0,114,121,1,0,0,114,123,1,0,0, + 114,240,0,0,0,114,126,1,0,0,114,127,1,0,0,114, + 136,1,0,0,114,137,1,0,0,114,4,0,0,0,114,4, + 0,0,0,114,4,0,0,0,114,5,0,0,0,218,8,60, + 109,111,100,117,108,101,62,8,0,0,0,115,182,0,0,0, + 6,17,6,3,12,12,12,5,12,5,12,6,12,12,12,10, + 12,9,12,5,12,7,15,22,12,8,12,4,15,4,19,20, + 6,2,6,3,22,4,19,68,19,21,19,19,12,19,12,20, + 12,111,22,1,18,2,6,2,9,2,9,1,9,2,15,27, + 12,23,12,19,12,12,18,8,12,18,12,11,12,11,12,18, + 12,15,21,55,21,12,18,10,12,14,12,36,19,27,19,106, + 24,22,9,3,12,1,15,63,18,45,18,56,12,18,12,17, + 12,25,12,29,12,23,12,14,15,25,19,70,19,75,19,63, + 19,27,22,110,19,41,25,43,25,16,6,3,19,57,19,57, + 19,41,19,134,19,146,19,13,12,9,12,9,15,40,12,17, + 6,1,10,2,12,27,12,6,18,24,12,32,12,15,12,11, + 24,35,12,7,12,86, }; diff -r 9a0caf6e7a16 Python/opcode_targets.h --- a/Python/opcode_targets.h Tue Apr 07 01:30:33 2015 -0400 +++ b/Python/opcode_targets.h Tue Apr 07 06:17:38 2015 -0400 @@ -148,11 +148,11 @@ &&TARGET_SET_ADD, &&TARGET_MAP_ADD, &&TARGET_LOAD_CLASSDEREF, - &&_unknown_opcode, - &&_unknown_opcode, - &&_unknown_opcode, - &&_unknown_opcode, - &&_unknown_opcode, + &&TARGET_BUILD_LIST_UNPACK, + &&TARGET_BUILD_MAP_UNPACK, + &&TARGET_BUILD_MAP_UNPACK_WITH_CALL, + &&TARGET_BUILD_TUPLE_UNPACK, + &&TARGET_BUILD_SET_UNPACK, &&_unknown_opcode, &&_unknown_opcode, &&_unknown_opcode, diff -r 9a0caf6e7a16 Python/symtable.c --- a/Python/symtable.c Tue Apr 07 01:30:33 2015 -0400 +++ b/Python/symtable.c Tue Apr 07 06:17:38 2015 -0400 @@ -1201,10 +1201,6 @@ VISIT_QUIT(st, 0); VISIT_SEQ(st, expr, s->v.ClassDef.bases); VISIT_SEQ(st, keyword, s->v.ClassDef.keywords); - if (s->v.ClassDef.starargs) - VISIT(st, expr, s->v.ClassDef.starargs); - if (s->v.ClassDef.kwargs) - VISIT(st, expr, s->v.ClassDef.kwargs); if (s->v.ClassDef.decorator_list) VISIT_SEQ(st, expr, s->v.ClassDef.decorator_list); if (!symtable_enter_block(st, s->v.ClassDef.name, ClassBlock, @@ -1373,128 +1369,127 @@ static int symtable_visit_expr(struct symtable *st, expr_ty e) { - if (++st->recursion_depth > st->recursion_limit) { - PyErr_SetString(PyExc_RuntimeError, - "maximum recursion depth exceeded during compilation"); - VISIT_QUIT(st, 0); - } - switch (e->kind) { - case BoolOp_kind: - VISIT_SEQ(st, expr, e->v.BoolOp.values); - break; - case BinOp_kind: - VISIT(st, expr, e->v.BinOp.left); - VISIT(st, expr, e->v.BinOp.right); - break; - case UnaryOp_kind: - VISIT(st, expr, e->v.UnaryOp.operand); - break; - case Lambda_kind: { - if (!GET_IDENTIFIER(lambda)) + if (e != NULL) { + if (++st->recursion_depth > st->recursion_limit) { + PyErr_SetString(PyExc_RuntimeError, + "maximum recursion depth exceeded during compilation"); VISIT_QUIT(st, 0); - if (e->v.Lambda.args->defaults) - VISIT_SEQ(st, expr, e->v.Lambda.args->defaults); - if (e->v.Lambda.args->kw_defaults) - VISIT_KWONLYDEFAULTS(st, - e->v.Lambda.args->kw_defaults); - if (!symtable_enter_block(st, lambda, - FunctionBlock, (void *)e, e->lineno, - e->col_offset)) - VISIT_QUIT(st, 0); - VISIT(st, arguments, e->v.Lambda.args); - VISIT(st, expr, e->v.Lambda.body); - if (!symtable_exit_block(st, (void *)e)) - VISIT_QUIT(st, 0); - break; - } - case IfExp_kind: - VISIT(st, expr, e->v.IfExp.test); - VISIT(st, expr, e->v.IfExp.body); - VISIT(st, expr, e->v.IfExp.orelse); - break; - case Dict_kind: - VISIT_SEQ(st, expr, e->v.Dict.keys); - VISIT_SEQ(st, expr, e->v.Dict.values); - break; - case Set_kind: - VISIT_SEQ(st, expr, e->v.Set.elts); - break; - case GeneratorExp_kind: - if (!symtable_visit_genexp(st, e)) - VISIT_QUIT(st, 0); - break; - case ListComp_kind: - if (!symtable_visit_listcomp(st, e)) - VISIT_QUIT(st, 0); - break; - case SetComp_kind: - if (!symtable_visit_setcomp(st, e)) - VISIT_QUIT(st, 0); - break; - case DictComp_kind: - if (!symtable_visit_dictcomp(st, e)) - VISIT_QUIT(st, 0); - break; - case Yield_kind: - if (e->v.Yield.value) - VISIT(st, expr, e->v.Yield.value); - st->st_cur->ste_generator = 1; - break; - case YieldFrom_kind: - VISIT(st, expr, e->v.YieldFrom.value); - st->st_cur->ste_generator = 1; - break; - case Compare_kind: - VISIT(st, expr, e->v.Compare.left); - VISIT_SEQ(st, expr, e->v.Compare.comparators); - break; - case Call_kind: - VISIT(st, expr, e->v.Call.func); - VISIT_SEQ(st, expr, e->v.Call.args); - VISIT_SEQ(st, keyword, e->v.Call.keywords); - if (e->v.Call.starargs) - VISIT(st, expr, e->v.Call.starargs); - if (e->v.Call.kwargs) - VISIT(st, expr, e->v.Call.kwargs); - break; - case Num_kind: - case Str_kind: - case Bytes_kind: - case Ellipsis_kind: - case NameConstant_kind: - /* Nothing to do here. */ - break; - /* The following exprs can be assignment targets. */ - case Attribute_kind: - VISIT(st, expr, e->v.Attribute.value); - break; - case Subscript_kind: - VISIT(st, expr, e->v.Subscript.value); - VISIT(st, slice, e->v.Subscript.slice); - break; - case Starred_kind: - VISIT(st, expr, e->v.Starred.value); - break; - case Name_kind: - if (!symtable_add_def(st, e->v.Name.id, - e->v.Name.ctx == Load ? USE : DEF_LOCAL)) - VISIT_QUIT(st, 0); - /* Special-case super: it counts as a use of __class__ */ - if (e->v.Name.ctx == Load && - st->st_cur->ste_type == FunctionBlock && - !PyUnicode_CompareWithASCIIString(e->v.Name.id, "super")) { - if (!GET_IDENTIFIER(__class__) || - !symtable_add_def(st, __class__, USE)) + } + switch (e->kind) { + case BoolOp_kind: + VISIT_SEQ(st, expr, e->v.BoolOp.values); + break; + case BinOp_kind: + VISIT(st, expr, e->v.BinOp.left); + VISIT(st, expr, e->v.BinOp.right); + break; + case UnaryOp_kind: + VISIT(st, expr, e->v.UnaryOp.operand); + break; + case Lambda_kind: { + if (!GET_IDENTIFIER(lambda)) VISIT_QUIT(st, 0); + if (e->v.Lambda.args->defaults) + VISIT_SEQ(st, expr, e->v.Lambda.args->defaults); + if (e->v.Lambda.args->kw_defaults) + VISIT_KWONLYDEFAULTS(st, + e->v.Lambda.args->kw_defaults); + if (!symtable_enter_block(st, lambda, + FunctionBlock, (void *)e, e->lineno, + e->col_offset)) + VISIT_QUIT(st, 0); + VISIT(st, arguments, e->v.Lambda.args); + VISIT(st, expr, e->v.Lambda.body); + if (!symtable_exit_block(st, (void *)e)) + VISIT_QUIT(st, 0); + break; } - break; - /* child nodes of List and Tuple will have expr_context set */ - case List_kind: - VISIT_SEQ(st, expr, e->v.List.elts); - break; - case Tuple_kind: - VISIT_SEQ(st, expr, e->v.Tuple.elts); - break; + case IfExp_kind: + VISIT(st, expr, e->v.IfExp.test); + VISIT(st, expr, e->v.IfExp.body); + VISIT(st, expr, e->v.IfExp.orelse); + break; + case Dict_kind: + VISIT_SEQ(st, expr, e->v.Dict.keys); + VISIT_SEQ(st, expr, e->v.Dict.values); + break; + case Set_kind: + VISIT_SEQ(st, expr, e->v.Set.elts); + break; + case GeneratorExp_kind: + if (!symtable_visit_genexp(st, e)) + VISIT_QUIT(st, 0); + break; + case ListComp_kind: + if (!symtable_visit_listcomp(st, e)) + VISIT_QUIT(st, 0); + break; + case SetComp_kind: + if (!symtable_visit_setcomp(st, e)) + VISIT_QUIT(st, 0); + break; + case DictComp_kind: + if (!symtable_visit_dictcomp(st, e)) + VISIT_QUIT(st, 0); + break; + case Yield_kind: + if (e->v.Yield.value) + VISIT(st, expr, e->v.Yield.value); + st->st_cur->ste_generator = 1; + break; + case YieldFrom_kind: + VISIT(st, expr, e->v.YieldFrom.value); + st->st_cur->ste_generator = 1; + break; + case Compare_kind: + VISIT(st, expr, e->v.Compare.left); + VISIT_SEQ(st, expr, e->v.Compare.comparators); + break; + case Call_kind: + VISIT(st, expr, e->v.Call.func); + VISIT_SEQ(st, expr, e->v.Call.args); + VISIT_SEQ(st, keyword, e->v.Call.keywords); + break; + case Num_kind: + case Str_kind: + case Bytes_kind: + case Ellipsis_kind: + case NameConstant_kind: + /* Nothing to do here. */ + break; + /* The following exprs can be assignment targets. */ + case Attribute_kind: + VISIT(st, expr, e->v.Attribute.value); + break; + case Subscript_kind: + VISIT(st, expr, e->v.Subscript.value); + VISIT(st, slice, e->v.Subscript.slice); + break; + case Starred_kind: + VISIT(st, expr, e->v.Starred.value); + break; + case Name_kind: + if (!symtable_add_def(st, e->v.Name.id, + e->v.Name.ctx == Load ? USE : DEF_LOCAL)) + VISIT_QUIT(st, 0); + /* Special-case super: it counts as a use of __class__ */ + if (e->v.Name.ctx == Load && + st->st_cur->ste_type == FunctionBlock && + !PyUnicode_CompareWithASCIIString( + e->v.Name.id, "super")) { + if (!GET_IDENTIFIER(__class__) || + !symtable_add_def(st, __class__, USE)) + VISIT_QUIT(st, 0); + } + break; + /* child nodes of List and Tuple will have expr_context set */ + case List_kind: + VISIT_SEQ(st, expr, e->v.List.elts); + break; + case Tuple_kind: + VISIT_SEQ(st, expr, e->v.Tuple.elts); + break; + } } VISIT_QUIT(st, 1); } diff -r 9a0caf6e7a16 Tools/parser/unparse.py --- a/Tools/parser/unparse.py Tue Apr 07 01:30:33 2015 -0400 +++ b/Tools/parser/unparse.py Tue Apr 07 06:17:38 2015 -0400 @@ -211,16 +211,6 @@ if comma: self.write(", ") else: comma = True self.dispatch(e) - if t.starargs: - if comma: self.write(", ") - else: comma = True - self.write("*") - self.dispatch(t.starargs) - if t.kwargs: - if comma: self.write(", ") - else: comma = True - self.write("**") - self.dispatch(t.kwargs) self.write(")") self.enter() @@ -450,16 +440,6 @@ if comma: self.write(", ") else: comma = True self.dispatch(e) - if t.starargs: - if comma: self.write(", ") - else: comma = True - self.write("*") - self.dispatch(t.starargs) - if t.kwargs: - if comma: self.write(", ") - else: comma = True - self.write("**") - self.dispatch(t.kwargs) self.write(")") def _Subscript(self, t): @@ -543,8 +523,11 @@ self.dispatch(t.kwarg.annotation) def _keyword(self, t): - self.write(t.arg) - self.write("=") + if t.arg is None: + self.write("**") + else: + self.write(t.arg) + self.write("=") self.dispatch(t.value) def _Lambda(self, t):